HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
#MALLOC = malloc
-#MALLOC = malloc-930716
+MALLOC = malloc-930716
# If you want to collect common syscall code into one function, set to this to
# `true'. Set it to false otherwise.
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-#MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
#MALLOC = malloc
MALLOC = malloc-930716
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-MALLOC = malloc-simple
-#MALLOC = malloc
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
+MALLOC = malloc
#MALLOC = malloc-930716
# Having brk allows one to use malloc-930716, which is an order
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-MALLOC = malloc-simple
-#MALLOC = malloc
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
+MALLOC = malloc
#MALLOC = malloc-930716
# If you want to collect common syscall code into one function, set to this to
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-#MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
#MALLOC = malloc
MALLOC = malloc-930716
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-#MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
MALLOC = malloc
#MALLOC = malloc-930716
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-MALLOC = malloc-simple
-#MALLOC = malloc
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
+MALLOC = malloc
#MALLOC = malloc-930716
# Having brk allows one to use malloc-930716, which is an order
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-MALLOC = malloc-simple
-#MALLOC = malloc
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
+MALLOC = malloc
#MALLOC = malloc-930716
# Having brk allows one to use malloc-930716, which is an order
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-#MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
#MALLOC = malloc
MALLOC = malloc-930716
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-#MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
#MALLOC = malloc
MALLOC = malloc-930716
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-#MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
#MALLOC = malloc
MALLOC = malloc-930716
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-MALLOC = malloc-simple
-#MALLOC = malloc
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
+MALLOC = malloc
#MALLOC = malloc-930716
# If you want to collect common syscall code into one function, set to this to
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-#MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
#MALLOC = malloc
MALLOC = malloc-930716
HAS_WCHAR = false
# This specifies which malloc implementation is used.
-# "malloc-simple" is very, very small, but is also very, very dumb
-# and does not try to make good use of memory or clean up after itself.
#
-# "malloc" on the other hand is a bit bigger, but is pretty smart thereby
-# minimizing memory wastage and reusing already allocated memory. This
-# can be lots faster and safer IMHO.
+# "malloc" use mmap for all allocations and so works very well on MMU-less
+# systems that do not support the brk() system call. It is pretty smart
+# about reusing already allocated memory, and minimizing memory wastage.
#
-# "malloc-930716" is from libc-5.3.12 and was/is the standard gnu malloc.
-# It is actually smaller than "malloc", but because it is based on brk/sbrk
-# it will only work on systems with an MMU.
-#MALLOC = malloc-simple
+# "malloc-930716" is derived from libc-5.3.12 and uses the brk() system call
+# for all memory allocations. This makes it very fast. It is also pretty
+# smart about reusing already allocated memory, and minimizing memory wastage.
+# Because this uses brk() it will not work on uClinux MMU-less systems.
MALLOC = malloc
#MALLOC = malloc-930716
+++ /dev/null
---blank-lines-after-declarations
---blank-lines-after-procedures
---break-before-boolean-operator
---no-blank-lines-after-commas
---braces-on-if-line
---braces-on-struct-decl-line
---comment-indentation25
---declaration-comment-column25
---no-comment-delimiters-on-blank-lines
---cuddle-else
---continuation-indentation4
---case-indentation0
---else-endif-column33
---space-after-cast
---line-comments-indentation0
---declaration-indentation1
---dont-format-first-column-comments
---dont-format-comments
---honour-newlines
---indent-level4
-/* changed from 0 to 4 */
---parameter-indentation4
---line-length78 /* changed from 75 */
---continue-at-parentheses
---no-space-after-function-call-names
---dont-break-procedure-type
---dont-star-comments
---leave-optional-blank-lines
---dont-space-special-semicolon
---tab-size4
-/* additions by Mark */
---case-brace-indentation0
---leave-preprocessor-space
+++ /dev/null
-# Makefile for uClibc
-#
-# Copyright (C) 2000 by Lineo, inc.
-# Copyright (C) 2000,2001 Erik Andersen <andersen@uclibc.org>
-#
-# This program 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 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 Library General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Library General Public License
-# along with this program; if not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# Derived in part from the Linux-8086 C library, the GNU C Library, and several
-# other sundry sources. Files within this library are copyright by their
-# respective copyright holders.
-
-TOPDIR=../../../
-include $(TOPDIR)Rules.mak
-
-MSRC=alloc.c
-MOBJ=malloc.o realloc.o free.o calloc.o #malloc_dbg.o free_dbg.o calloc_dbg.o
-OBJS=$(MOBJ)
-
-
-all: $(OBJS) $(LIBC)
-
-$(LIBC): ar-target
-
-ar-target: $(OBJS)
- $(AR) $(ARFLAGS) $(LIBC) $(OBJS)
-
-$(MOBJ): $(MSRC)
- $(CC) $(CFLAGS) -DL_$* $< -c -o $*.o
- $(STRIPTOOL) -x -R .note -R .comment $*.o
-
-$(COBJS): %.o : %.c
- $(CC) $(CFLAGS) -c $< -o $@
- $(STRIPTOOL) -x -R .note -R .comment $*.o
-
-clean:
- rm -f *.[oa] *~ core
-
+++ /dev/null
-
-/*
- * For MMU hosts we need to track the size of the allocations otherwise
- * munmap will fail to free the memory (EINVAL).
- */
-
-#include <features.h>
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/mman.h>
-
-
-#ifdef L_calloc_dbg
-
-void *calloc_dbg(size_t num, size_t size, char *function, char *file,
- int line)
-{
- void *ptr;
-
- fprintf(stderr, "calloc of %d bytes at %s @%s:%d = ", (int) (num * size),
- function, file, line);
- ptr = calloc(num, size);
- fprintf(stderr, "%p\n", ptr);
- return ptr;
-}
-
-#endif
-
-#ifdef L_malloc_dbg
-
-void *malloc_dbg(size_t size, char *function, char *file, int line)
-{
- void *result;
-
- fprintf(stderr, "malloc of %d bytes at %s @%s:%d = ", (int) size, function,
- file, line);
- result = malloc(size);
- fprintf(stderr, "%p\n", result);
- return result;
-}
-
-#endif
-
-#ifdef L_free_dbg
-
-void free_dbg(void *ptr, char *function, char *file, int line)
-{
- fprintf(stderr, "free of %p at %s @%s:%d\n", ptr, function, file,
- line);
- free(ptr);
-}
-
-#endif
-
-
-#ifdef L_calloc
-
-void *calloc(size_t num, size_t size)
-{
- void *ptr = malloc(num * size);
-
- if (ptr)
- memset(ptr, 0, num * size);
- return ptr;
-}
-
-#endif
-
-#ifdef L_malloc
-
-void *malloc(size_t size)
-{
- void *result;
-
- /* Some programs will call malloc (0). Lets be strict and return NULL */
- if (size == 0)
- return NULL;
-
-#ifdef __UCLIBC_HAS_MMU__
- result = mmap((void *) 0, size + sizeof(size_t), PROT_READ | PROT_WRITE,
- MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
-#else
- result = mmap((void *) 0, size, PROT_READ | PROT_WRITE,
- MAP_SHARED | MAP_ANONYMOUS, 0, 0);
-#endif
-
- if (result == MAP_FAILED)
- return 0;
-
-#ifdef __UCLIBC_HAS_MMU__
- * (size_t *) result = size;
- return(result + sizeof(size_t));
-#else
- return(result);
-#endif
-}
-
-#endif
-
-#ifdef L_free
-
-void free(void *ptr)
-{
-#ifdef __UCLIBC_HAS_MMU__
- if (ptr) {
- ptr -= sizeof(size_t);
- munmap(ptr, * (size_t *) ptr + sizeof(size_t));
- }
-#else
- munmap(ptr, 0);
-#endif
-}
-
-#endif
-
-#ifdef L_realloc
-
-void *realloc(void *ptr, size_t size)
-{
- void *newptr = NULL;
-
- if (size > 0) {
- newptr = malloc(size);
- if (newptr && ptr) {
-#ifdef __UCLIBC_HAS_MMU__
- memcpy(newptr, ptr, * ((size_t *) (ptr - sizeof(size_t))));
-#else
- memcpy(newptr, ptr, size);
-#endif
- free(ptr);
- }
- }
- else
- free(ptr);
- return newptr;
-}
-
-#endif
# Makefile for uClibc
#
-# Copyright (C) 2000 by Lineo, inc.
-# Copyright (C) 2000,2001 Erik Andersen <andersen@uclibc.org>
+# Copyright (C) 2002 NEC Corporation
+# Copyright (C) 2002 Miles Bader <miles@gnu.org>
#
# This program 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
TOPDIR=../../../
include $(TOPDIR)Rules.mak
-#MSRC=alloc.c
-#MOBJ=malloc_dbg.o free_dbg.o calloc_dbg.o realloc_dbg.o
-
-MSRC1=malloc.c
-MOBJ1=_avl_support.o _free_support.o _malloc_init.o _realloc_no_move.o calloc.o \
- free.o malloc.o realloc.o
-
-OBJS=$(MOBJ) $(MOBJ1)
+CSRC = malloc.o free.o realloc.o calloc.o heap_alloc.o \
+ heap_alloc_at.o heap_free.o heap_append_free.o
+COBJS=$(patsubst %.c,%.o, $(CSRC))
+OBJS=$(COBJS)
all: $(OBJS) $(LIBC)
ar-target: $(OBJS)
$(AR) $(ARFLAGS) $(LIBC) $(OBJS)
-$(MOBJ): $(MSRC)
- $(CC) $(CFLAGS) -DL_$* $< -c -o $*.o
- $(STRIPTOOL) -x -R .note -R .comment $*.o
-
-$(MOBJ1): $(MSRC1)
- $(CC) $(CFLAGS) -DL_$* $< -c -o $*.o
+$(COBJS): %.o : %.c
+ $(CC) $(CFLAGS) -c $< -o $@
$(STRIPTOOL) -x -R .note -R .comment $*.o
clean:
+++ /dev/null
-#include <unistd.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/mman.h>
-
-
-#ifdef L_calloc_dbg
-
-void *calloc_dbg(size_t num, size_t size, char *function, char *file,
- int line)
-{
- void *ptr;
-
- fprintf(stderr, "calloc of %ld bytes at %s @%s:%d = ",
- (long) (num * size), function, file, line);
- ptr = calloc(num, size);
- fprintf(stderr, "%p\n", ptr);
- return ptr;
-}
-
-#endif
-
-#ifdef L_malloc_dbg
-
-void *malloc_dbg(size_t len, char *function, char *file, int line)
-{
- void *result;
-
- fprintf(stderr, "malloc of %ld bytes at %s @%s:%d = ", (long) len,
- function, file, line);
- result = malloc(len);
- fprintf(stderr, "%p\n", result);
- return result;
-}
-
-#endif
-
-#ifdef L_free_dbg
-
-void free_dbg(void *ptr, char *function, char *file, int line)
-{
- fprintf(stderr, "free of %p at %s @%s:%d\n", ptr, function, file,
- line);
- free(ptr);
-}
-
-#endif
-
-#ifdef L_realloc_dbg
-void *realloc_dbg(void *ptr, size_t size, char *function, char *file, int line)
-{
- fprintf(stderr, "realloc of %p to %ld bytes at %s @%s;%d = ", ptr,
- (long)size, function, file, line);
- ptr = realloc(ptr, size);
- fprintf(stderr, "%p\n", ptr);
- return ptr;
-}
-#endif
+++ /dev/null
-/* MACRO-CODED FAST FIXED AVL TREES IMPLEMENTATION IN C */
-/* COPYRIGHT (C) 1998 VALERY SHCHEDRIN */
-/* IT IS DISTRIBUTED UNDER GLPL (GNU GENERAL LIBRARY PUBLIC LICENSE) */
-
-/*
- * Manuel Novoa III Jan 2001
- *
- * Modified to decrease object size.
- * Tree balancing is now done in a fuction rather than inline.
- * Removed common code in balance by use of a goto.
- * Added macro Avl_Tree_no_replace since ptrs_replace was not used.
- * Prepended may symbols with "__" for possible conversion to extern.
- */
-
-#define __Avl_balance_proto(objname, pr, root) \
- static int __Avl_##objname##pr##balance(objname **root) \
- { \
- objname *p; \
- int ht_changed; \
- p = *root; \
- if (p->bal_##pr < -1) \
- { \
- if (p->l_##pr->bal_##pr == 1) \
- { \
- objname *pp; \
- pp=p->l_##pr; *root=p->l_##pr->r_##pr; p->l_##pr = (*root)->r_##pr; \
- (*root)->r_##pr = p; pp->r_##pr = (*root)->l_##pr; \
- p = *root; p->l_##pr = pp; \
- goto pr_common_ht_changed; \
- } \
- else \
- { \
- ht_changed = (p->l_##pr ->bal_##pr)?1:0; \
- *root = p->l_##pr ; \
- p->l_##pr = (*root)->r_##pr ; (*root)->r_##pr = p; \
- p->bal_##pr = - (++((*root)->bal_##pr )); \
- } \
- } \
- else if (p->bal_##pr > 1) \
- { \
- if (p->r_##pr->bal_##pr == -1) \
- { \
- objname *pp; \
- pp=p->r_##pr ; *root=p->r_##pr ->l_##pr ; p->r_##pr =(*root)->l_##pr ; \
- (*root)->l_##pr = p; pp->l_##pr = (*root)->r_##pr ; \
- p = *root; p->r_##pr = pp; \
- pr_common_ht_changed: \
- if (p->bal_##pr > 0) p->l_##pr ->bal_##pr = -p->bal_##pr ; \
- else p->l_##pr ->bal_##pr = 0; \
- if (p->bal_##pr < 0) p->r_##pr ->bal_##pr = -p->bal_##pr ; \
- else p->r_##pr ->bal_##pr = 0; \
- p->bal_##pr = 0; \
- ht_changed = 1; \
- } \
- else \
- { \
- ht_changed = (p->r_##pr ->bal_##pr)?1:0; \
- *root = p->r_##pr ; \
- p->r_##pr = (*root)->l_##pr ; (*root)->l_##pr = p; \
- p->bal_##pr = - (--((*root)->bal_##pr )); \
- } \
- } else ht_changed = 0; \
- return ht_changed; \
- }
-
-#define balance(objname, pr, root) \
- __Avl_##objname##pr##balance(root)
-
-#define __Avl_r_insert_proto(objname, pr, COMPARE) \
- static int __Avl_##objname##pr##_r_insert(objname **root) \
- { \
- int i; /* height increase */ \
- if (!*root) \
- { \
- *root = __Avl_##objname##pr##_new_node; \
- __Avl_##objname##pr##_new_node = NULL; \
- return 1; \
- } \
- COMPARE(i, __Avl_##objname##pr##_new_node, *root); \
- \
- if (i < 0) \
- { /* insert into the left subtree */ \
- i = -__Avl_##objname##pr##_r_insert(&((*root)->l_##pr)); \
- if (__Avl_##objname##pr##_new_node != NULL) return 0; /* already there */ \
- } \
- else if (i > 0) \
- { /* insert into the right subtree */ \
- i = __Avl_##objname##pr##_r_insert(&((*root)->r_##pr)); \
- if (__Avl_##objname##pr##_new_node != NULL) return 0; /* already there */ \
- } \
- else \
- { /* found */ \
- __Avl_##objname##pr##_new_node = *root; \
- return 0; \
- } \
- if (!i) return 0; \
- (*root)->bal_##pr += i; /* update balance factor */ \
- if ((*root)->bal_##pr) \
- { \
- return 1 - balance(objname,pr,root); \
- } \
- else return 0; \
- }
-
-#define __Avl_r_delete_proto(objname,pr,COMPARE) \
- static int __Avl_##objname##pr##_r_delete(objname **root) \
- { \
- int i; /* height decrease */ \
- \
- if (!*root) return 0; /* not found */ \
- \
- COMPARE(i, __Avl_##objname##pr##_new_node, *root); \
- \
- if (i < 0) \
- i = -__Avl_##objname##pr##_r_delete(&((*root)->l_##pr)); \
- else if (i > 0) \
- i = __Avl_##objname##pr##_r_delete(&((*root)->r_##pr)); \
- else \
- { \
- if (!(*root)->l_##pr) \
- { \
- *root = (*root)->r_##pr; \
- return 1; \
- } \
- else if (!(*root)->r_##pr) \
- { \
- *root = (*root)->l_##pr; \
- return 1; \
- } \
- else \
- { \
- i = __Avl_##objname##pr##_r_delfix(&((*root)->r_##pr)); \
- __Avl_##objname##pr##_new_node->l_##pr = (*root)->l_##pr; \
- __Avl_##objname##pr##_new_node->r_##pr = (*root)->r_##pr; \
- __Avl_##objname##pr##_new_node->bal_##pr = (*root)->bal_##pr; \
- *root = __Avl_##objname##pr##_new_node; \
- } \
- } \
- if (!i) return 0; \
- (*root)->bal_##pr -= i; \
- if ((*root)->bal_##pr) \
- { \
- return balance(objname,pr,root); \
- } \
- return 1; \
- }
-
-#define __Avl_r_delfix_proto(objname,pr) \
- static int __Avl_##objname##pr##_r_delfix(objname **root) \
- { \
- int i; /* height decrease */ \
- \
- if (!(*root)->l_##pr) \
- { \
- __Avl_##objname##pr##_new_node = *root; \
- *root = (*root)->r_##pr; \
- return 1; \
- } \
- i = -__Avl_##objname##pr##_r_delfix(&((*root)->l_##pr)); \
- if (!i) return 0; \
- (*root)->bal_##pr -= i; \
- if ((*root)->bal_##pr) \
- { \
- return balance(objname,pr,root); \
- } \
- return 1; \
- }
-
-#define __Avl_ins_proto(alias,objname,pr) \
- objname *__##alias##_ins(objname *data) \
- { \
- __Avl_##objname##pr##_new_node = data; \
- (data)->l_##pr = NULL; \
- (data)->r_##pr = NULL; \
- (data)->bal_##pr = 0; \
- __Avl_##objname##pr##_r_insert(&__Avl_##objname##pr##_tree); \
- if (__Avl_##objname##pr##_new_node) \
- return __Avl_##objname##pr##_new_node; \
- return NULL; \
- }
-
-#define __Avl_del_proto(alias,objname,pr) \
- void __##alias##_del(objname *data) \
- { \
- __Avl_##objname##pr##_new_node = data; \
- __Avl_##objname##pr##_r_delete(&__Avl_##objname##pr##_tree); \
- }
-
-#define __Avl_replace_proto(alias,objname,pr,COMPARE) \
- void __##alias##_replace(objname *data) \
- { \
- objname **p = &__Avl_##objname##pr##_tree; \
- int cmp; \
- while (*p) \
- { \
- COMPARE(cmp, data, *p); \
- if (cmp < 0) \
- p = &((*p)->l_##pr); \
- else if (cmp > 0) \
- p = &((*p)->r_##pr); \
- else \
- { \
- (data)->l_##pr = (*p)->l_##pr; \
- (data)->r_##pr = (*p)->r_##pr; \
- (data)->bal_##pr = (*p)->bal_##pr; \
- *p = data; \
- return; \
- } \
- } \
- }
-
-#define Avl_Root(objname,pr) __Avl_##objname##pr##_tree
-
-#define Avl_Tree_no_replace(alias,objname,pr,COMPARE) \
-objname *__Avl_##objname##pr##_tree = NULL; \
-static objname *__Avl_##objname##pr##_new_node; \
-__Avl_balance_proto(objname, pr, root) \
-__Avl_r_insert_proto(objname,pr,COMPARE) \
-__Avl_r_delfix_proto(objname,pr) \
-__Avl_r_delete_proto(objname,pr,COMPARE) \
-__Avl_ins_proto(alias,objname,pr) \
-__Avl_del_proto(alias,objname,pr)
-
-#define Avl_Tree(alias,objname,pr,COMPARE) \
-Avl_Tree_no_replace(alias,objname,pr,COMPARE) \
-__Avl_replace_proto(alias,objname,pr,COMPARE)
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/calloc.c -- calloc function
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "malloc.h"
+
+
+void *
+calloc (size_t size, size_t num)
+{
+ void *mem;
+
+ size *= num;
+
+ mem = malloc (size);
+ if (mem)
+ memset (mem, 0, size);
+
+ return mem;
+}
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/free.c -- free function
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <stdlib.h>
+#include <sys/mman.h>
+
+#include "malloc.h"
+#include "heap.h"
+
+
+void free (void *mem)
+{
+ size_t size;
+
+ mem = (size_t *)mem - 1;
+ size = *(size_t *)mem;
+
+ MALLOC_DEBUG ("free: 0x%lx (base = 0x%lx, total_size = %d)\n",
+ (long)mem + sizeof (size_t), (long)mem, size);
+
+ if (size >= MALLOC_MMAP_THRESHOLD)
+ munmap (mem, size);
+ else
+ __heap_free (&__malloc_heap, mem, size);
+}
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/heap.h -- heap allocator used for malloc
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <features.h>
+
+
+#ifdef __UCLIBC_HAS_THREADS__
+#include <pthread.h>
+typedef pthread_mutex_t mutex_t;
+# define MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+# define mutex_lock(x) pthread_mutex_lock(&(x))
+# define mutex_unlock(x) pthread_mutex_unlock(&(x));
+#else
+/* Mutex operations are currently a nop. */
+typedef int mutex_t;
+# define MUTEX_INITIALIZER 0
+# define mutex_lock(x)
+# define mutex_unlock(x)
+#endif
+
+
+
+/* The unit in which allocation is done, due to alignment constraints, etc.
+ All allocation requests are rounded up to a multiple of this size.
+ Must be a power of 2. */
+#define HEAP_GRANULARITY (sizeof (double))
+
+
+struct heap
+{
+ struct heap_free_area *free_areas;
+ mutex_t lock;
+};
+
+#define HEAP_INIT { 0, MUTEX_INITIALIZER }
+
+
+/* A free-list area `header'. These are actually stored at the _ends_ of
+ free areas (to make allocating from the beginning of the area simpler),
+ so one might call it a `footer'. */
+struct heap_free_area
+{
+ size_t size;
+ struct heap_free_area *next, *prev;
+};
+
+/* Return the address of the end of the frea area FA. */
+#define HEAP_FREE_AREA_END(fa) ((void *)(fa + 1))
+/* Return the address of the beginning of the frea area FA. FA is
+ evaulated multiple times. */
+#define HEAP_FREE_AREA_START(fa) ((void *)((char *)(fa + 1) - (fa)->size))
+
+
+/* Rounds SZ up to be a multiple of HEAP_GRANULARITY. */
+#define HEAP_ADJUST_SIZE(sz) \
+ (((sz) + HEAP_GRANULARITY - 1) & ~(HEAP_GRANULARITY - 1))
+
+/* The minimum size of a free area. It must include at least enough room
+ to hold a struct heap_free_area, plus enough extra to be usefully
+ allocated. */
+#define HEAP_MIN_FREE_AREA_SIZE \
+ (sizeof (struct heap_free_area) + HEAP_ADJUST_SIZE (1))
+
+
+#if 0
+#include <stdio.h>
+static void HEAP_DEBUG (struct heap *heap, const char *str)
+{
+ static int recursed = 0;
+ if (! recursed)
+ {
+ struct heap_free_area *fa;
+ recursed = 1;
+ fprintf (stderr, " %s: heap @0x%lx:\n", str, (long)heap);
+ for (fa = heap->free_areas; fa; fa = fa->next)
+ fprintf (stderr,
+ " 0x%lx: 0x%lx - 0x%lx (%d)\tN=0x%lx, P=0x%lx\n",
+ (long)fa,
+ (long)HEAP_FREE_AREA_START (fa),
+ (long)HEAP_FREE_AREA_END (fa),
+ fa->size,
+ (long)fa->prev,
+ (long)fa->next);
+ recursed = 0;
+ }
+}
+#else
+#define HEAP_DEBUG(heap, str) (void)0
+#endif
+
+
+/* Allocate SIZE bytes from the front of the free-area FA in HEAP, and
+ return the amount actually allocated (which may be more than SIZE). */
+extern inline size_t
+__heap_free_area_alloc (struct heap *heap,
+ struct heap_free_area *fa, size_t size)
+{
+ size_t fa_size = fa->size;
+
+ if (fa_size < size + HEAP_MIN_FREE_AREA_SIZE)
+ /* There's not enough room left over in FA after allocating the block, so
+ just use the whole thing, removing it from the list of free areas. */
+ {
+ if (fa->next)
+ fa->next->prev = fa->prev;
+ if (fa->prev)
+ fa->prev->next = fa->next;
+ else
+ heap->free_areas = fa->next;
+ /* Remember that we've alloced the whole area. */
+ size = fa_size;
+ }
+ else
+ /* Reduce size of FA to account for this allocation. */
+ fa->size = fa_size - size;
+
+ return size;
+}
+
+
+/* Allocate and return a block at least *SIZE bytes long from HEAP.
+ *SIZE is adjusted to reflect the actual amount allocated (which may be
+ greater than requested). */
+extern void *__heap_alloc (struct heap *heap, size_t *size);
+
+/* Allocate SIZE bytes at address MEM in HEAP. Return the actual size
+ allocated, or 0 if we failed. */
+extern size_t __heap_alloc_at (struct heap *heap, void *mem, size_t size);
+
+/* Return the memory area MEM of size SIZE to HEAP. */
+extern void __heap_free (struct heap *heap, void *mem, size_t size);
+
+/* If the memory area MEM, of size SIZE, immediately follows an existing
+ free-area in HEAP, use it to extend that free-area, and return true;
+ otherwise return false. */
+extern int __heap_append_free (struct heap *heap, void *mem, size_t size);
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/heap_alloc.c -- allocate from a heap
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <stdlib.h>
+
+#include "heap.h"
+
+
+/* Allocate and return a block at least *SIZE bytes long from HEAP.
+ *SIZE is adjusted to reflect the actual amount allocated (which may be
+ greater than requested). */
+void *
+__heap_alloc (struct heap *heap, size_t *size)
+{
+ struct heap_free_area *fa;
+ size_t _size = *size;
+ void *mem = 0;
+
+ _size = HEAP_ADJUST_SIZE (_size);
+
+ if (_size < sizeof (struct heap_free_area))
+ /* Because we sometimes must use a freed block to hold a free-area node,
+ we must make sure that every allocated block can hold one. */
+ _size = HEAP_ADJUST_SIZE (sizeof (struct heap_free_area));
+
+ mutex_lock (heap->lock);
+
+ HEAP_DEBUG (heap, "before __heap_alloc");
+
+ /* Look for a free area that can contain _SIZE bytes. */
+ for (fa = heap->free_areas; fa; fa = fa->next)
+ if (fa->size >= _size)
+ {
+ /* Found one! */
+ mem = HEAP_FREE_AREA_START (fa);
+ *size = __heap_free_area_alloc (heap, fa, _size);
+ break;
+ }
+
+ HEAP_DEBUG (heap, "after __heap_alloc");
+
+ mutex_unlock (heap->lock);
+
+ return mem;
+}
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/heap_alloc_at.c -- allocate at a specific address
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <stdlib.h>
+
+#include "heap.h"
+
+
+/* Allocate SIZE bytes at address MEM in HEAP. Return the actual size
+ allocated, or 0 if we failed. */
+size_t
+__heap_alloc_at (struct heap *heap, void *mem, size_t size)
+{
+ struct heap_free_area *fa;
+ size_t alloced = 0;
+
+ size = HEAP_ADJUST_SIZE (size);
+
+ mutex_lock (heap->lock);
+
+ HEAP_DEBUG (heap, "before __heap_alloc_at");
+
+ /* Look for a free area that can contain SIZE bytes. */
+ for (fa = heap->free_areas; fa; fa = fa->next)
+ {
+ void *fa_mem = HEAP_FREE_AREA_START (fa);
+ if (fa_mem <= mem)
+ {
+ if (fa_mem == mem && fa->size >= size)
+ /* FA has the right addr, and is big enough! */
+ alloced = __heap_free_area_alloc (heap, fa, size);
+ break;
+ }
+ }
+
+ HEAP_DEBUG (heap, "after __heap_alloc_at");
+
+ mutex_unlock (heap->lock);
+
+ return alloced;
+}
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/heap_append_free.c -- append to heap free area
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <stdlib.h>
+
+#include "heap.h"
+
+
+/* If the block MEM, of size SIZE, immediately follows an existing free-area
+ in HEAP, use it to extend that free-area, and return true; otherwise return
+ false. */
+int
+__heap_append_free (struct heap *heap, void *mem, size_t size)
+{
+ int success = 0;
+ struct heap_free_area *fa;
+
+ mutex_lock (heap->lock);
+
+ HEAP_DEBUG (heap, "before __heap_append_free");
+
+ /* Find an adjacent free-list entry. */
+ for (fa = heap->free_areas; fa; fa = fa->next)
+ if (HEAP_FREE_AREA_END (fa) == mem)
+ /* MEM follows FA, extend FA to include it. Since the descriptor for FA
+ is located at the end, we must actually write a new descriptor. Note
+ that we _don't_ handle the case where the extended FA can be merged
+ with a following free area; this is because this function is
+ generally only used in cases were we believe that usually won't
+ happen (it doesn't cause any incorrectness, and the two blocks can be
+ merged by __heap_free later). */
+ {
+ struct heap_free_area *next_fa = fa->next;
+ struct heap_free_area *prev_fa = fa->prev;
+ size_t fa_size = fa->size;
+ struct heap_free_area *new_fa =
+ (struct heap_free_area *)((char *)fa + size);
+
+ /* Update surrounding free-areas to point to FA's new address. */
+ if (prev_fa)
+ prev_fa->next = new_fa;
+ else
+ heap->free_areas = new_fa;
+ if (next_fa)
+ next_fa->prev = new_fa;
+
+ /* Fill in the moved descriptor. */
+ new_fa->prev = prev_fa;
+ new_fa->next = next_fa;
+ new_fa->size = fa_size + size;
+
+ success = 1;
+ break;
+ }
+
+ HEAP_DEBUG (heap, "after __heap_append_free");
+
+ mutex_unlock (heap->lock);
+
+ return success;
+}
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/heap_free.c -- return memory to a heap
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <stdlib.h>
+
+#include "heap.h"
+
+
+/* Return the memory area MEM of size SIZE to HEAP. */
+void
+__heap_free (struct heap *heap, void *mem, size_t size)
+{
+ struct heap_free_area *prev_fa, *fa, *new_fa;
+ void *end = (char *)mem + size;
+
+ mutex_lock (heap->lock);
+
+ HEAP_DEBUG (heap, "before __heap_free");
+
+ /* Find an adjacent free-list entry. */
+ for (prev_fa = 0, fa = heap->free_areas; fa; prev_fa = fa, fa = fa->next)
+ {
+ size_t fa_size = fa->size;
+ void *fa_end = HEAP_FREE_AREA_END (fa);
+ void *fa_mem = HEAP_FREE_AREA_START (fa);
+
+ if (fa_mem == end)
+ /* FA is just after MEM, grow down to encompass it. */
+ {
+ fa_size += size;
+
+ /* See if FA can now be merged with its predecessor. */
+ if (prev_fa && fa_mem - size == HEAP_FREE_AREA_END (prev_fa))
+ /* Yup; merge PREV_FA's info into FA. */
+ {
+ struct heap_free_area *pp = prev_fa->prev;
+ fa_size += prev_fa->size;
+ if (pp)
+ pp->next = fa;
+ else
+ heap->free_areas = fa;
+ fa->prev = pp;
+ }
+
+ fa->size = fa_size;
+
+ goto done;
+ }
+ else if (fa_end == mem)
+ /* FA is just before MEM, expand to encompass it. */
+ {
+ struct heap_free_area *next_fa = fa->next;
+
+ fa_size += size;
+
+ /* See if FA can now be merged with its successor. */
+ if (next_fa && fa_end + size == HEAP_FREE_AREA_START (next_fa))
+ {
+ /* Yup; merge FA's info into NEXT_FA. */
+ fa_size += next_fa->size;
+ if (prev_fa)
+ prev_fa->next = next_fa;
+ else
+ heap->free_areas = next_fa;
+ next_fa->prev = prev_fa;
+ fa = next_fa;
+ }
+ else
+ /* FA can't be merged; move the descriptor for it to the tail-end
+ of the memory block. */
+ {
+ new_fa = (struct heap_free_area *)((char *)fa + size);
+ /* Update surrounding free-areas to point to FA's new address. */
+ if (prev_fa)
+ prev_fa->next = new_fa;
+ else
+ heap->free_areas = new_fa;
+ if (next_fa)
+ next_fa->prev = new_fa;
+ /* Fill in the moved descriptor. */
+ new_fa->prev = prev_fa;
+ new_fa->next = next_fa;
+ fa = new_fa;
+ }
+
+ fa->size = fa_size;
+
+ goto done;
+ }
+ else if (fa_mem > mem)
+ /* We've reached the right spot in the free-list without finding an
+ adjacent free-area, so add a new free area to hold MEM. */
+ break;
+ }
+
+ /* Make a new free-list entry. */
+
+ /* NEW_FA initially holds only MEM. */
+ new_fa = (struct heap_free_area *)
+ ((char *)mem + size - sizeof (struct heap_free_area));
+ new_fa->size = size;
+ new_fa->next = fa;
+ new_fa->prev = prev_fa;
+
+ /* Insert NEW_FA in the free-list between PREV_FA and FA. */
+ if (prev_fa)
+ prev_fa->next = new_fa;
+ else
+ heap->free_areas = new_fa;
+ if (fa)
+ fa->prev = new_fa;
+
+ done:
+ HEAP_DEBUG (heap, "after __heap_free");
+
+ mutex_unlock (heap->lock);
+}
/*
- malloc - heap manager based on heavy use of virtual memory management.
- Copyright (C) 1998 Valery Shchedrin
-
- 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; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- MA 02111-1307, USA
-
- Public Functions:
-
- void *malloc(size_t size);
-
- Allocates `size` bytes
- returns NULL if no free memory available
-
- void *calloc(size_t unit, size_t quantity);
-
- Allocates `quantity*unit` zeroed bytes via internal malloc call
-
- void *realloc(void *ptr, size_t size);
-
- Reallocates already allocated block `ptr`, if `ptr` is not valid block
- then it works as malloc. NULL is returned if no free memory available
-
- void *_realloc_no_move(void *ptr, size_t size);
-
- Reallocates already allocated block `ptr`, if `ptr` is not valid block
- or if reallocation can't be done with shrinking/expanding already
- allocated block NULL is returned
-
- void free(void *ptr);
-
- Frees already allocated block, if `ptr` is incorrect one nothing will
- happen.
-*/
-
-/*
- * Manuel Novoa III Jan 2001
+ * libc/stdlib/malloc-zarg/malloc.c -- malloc function
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
*
- * Modified to decrease object sizes.
- * Broke into independent object files.
- * Converted INIT_BLOCK() and FREE_MEM_DEL_BLOCK() from macros to functions.
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
*/
-#include <features.h>
-#ifndef _XOPEN_SOURCE
-#define _XOPEN_SOURCE
-#endif
-#include <sys/types.h>
-#include <unistd.h>
-#include <limits.h>
-#include <sys/time.h>
-#include <asm/page.h>
-#include <unistd.h>
+#include <stdlib.h>
#include <sys/mman.h>
-#include <string.h>
-#include "malloc.h"
-#include <stdio.h>
-
-#define M_DOTRIMMING 1
-#define M_MULTITHREADED 0
-
-#define VALLOC_MSTART ((void*)0x1c000000)
-#define LARGE_MSTART ((void*)0x19000000)
-#define HUNK_MSTART ((void*)0x18000000)
-#define HUNK_MSIZE M_PAGESIZE
-#define HUNK_ID 0x99171713
-
-/* alignment of allocations > HUNK_THRESHOLD */
-#define MALLOC_ALIGN 4
-
-/* allocations < HUNK_THRESHOLD will not be aligned */
-#define HUNK_THRESHOLD 4
-
-/*up to HUNK_MAXSIZE blocks will be joined together to decrease memory waste*/
-#define HUNK_MAXSIZE 128
-
-/* returns value not less than size, aligned to MALLOC_ALIGN */
-#define ALIGN(size) (((size)+(MALLOC_ALIGN)-1)&(~((MALLOC_ALIGN)-1)))
-
-/* aligns s or p to page boundaries */
-#define PAGE_ALIGN(s) (((s)+M_PAGESIZE-1)&(~(M_PAGESIZE-1)))
-#define PAGE_ALIGNP(p) ((char*)PAGE_ALIGN((unsigned)(p)))
-#define PAGE_DOWNALIGNP(p) ((char*)(((unsigned)(p))&(~(M_PAGESIZE-1))))
-
-/* returns v * 2 for your machine (speed-up) */
-#define MUL2(v) ((v)*2)
-
-/* does v *= 8 for your machine (speed-up) */
-#define EMUL8(v) v*=8
-
-/* does v/8 for your machind (speed-up) */
-#define DIV8(v) ((v)/8)
-
-#if M_MULTITHREADED
-#error This version does not support threads
-#else
-typedef int mutex_t;
-
-#define mutex_lock(x)
-#define mutex_unlock(x)
-#define mutex_init(x)
-#define MUTEX_INITIALIZER 0
-//static mutex_t malloc_lock = MUTEX_INITIALIZER;
-#endif
-
-extern int __malloc_initialized;
-
-#ifdef L__malloc_init
-int __malloc_initialized = -1;
-
- /* -1 == uninitialized, 0 == initializing, 1 == initialized */
-#endif
-
-#ifndef MAP_FAILED
-#define MAP_FAILED ((void*)-1)
-#endif
-
-#if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
-#define MAP_ANON MAP_ANONYMOUS
-#endif
-
-#ifndef NULL
-#define NULL ((void*)0)
-#endif
-
-/* guess pagesize */
-#define M_PAGESIZE getpagesize()
-
-/* HUNK MANAGER */
-
-typedef struct Hunk_s Hunk_t;
-
-struct Hunk_s { /* Hunked block - 8 byte overhead */
- int id; /* unique id */
- unsigned int total:12, used:12, size:8;
- Hunk_t *next; /* next free in __free_h */
-};
-
-#define usagemap(h) (((unsigned char *)(h))+sizeof(Hunk_t))
-#define hunk_ptr(h) (((char*)(h))+sizeof(Hunk_t)+ALIGN(DIV8(h->total+7)))
-#define hunk(h) ((Hunk_t*)(h))
-
-extern Hunk_t *__free_h[HUNK_MAXSIZE + 1];
-extern int __total_h[HUNK_MAXSIZE + 1];
-
-#ifdef L__malloc_init
-Hunk_t *__free_h[HUNK_MAXSIZE + 1]; /* free hash */
-int __total_h[HUNK_MAXSIZE + 1]; /* Hunk_t's `total` member */
-#endif
-
-extern void *__hunk_alloc(int size);
-
-#ifdef L_malloc
-/* __hunk_alloc allocates <= HUNK_MAXSIZE blocks */
-void *__hunk_alloc(int size)
-{
- Hunk_t *p;
- unsigned long *cpl;
- int i, c;
-
- // if (size >= HUNK_THRESHOLD)
- size = ALIGN(size);
-
- /* Look for already allocated hunkblocks */
- if ((p = __free_h[size]) == NULL) {
- if (
- (p =
- (Hunk_t *) mmap(HUNK_MSTART, HUNK_MSIZE,
- PROT_READ | PROT_WRITE,
-#ifdef __UCLIBC_HAS_MMU__
- MAP_PRIVATE | MAP_ANONYMOUS
-#else
- MAP_SHARED | MAP_ANONYMOUS
-#endif
- , 0, 0)) == (Hunk_t *) MAP_FAILED)
- // {
- // printf("hunk_alloc failed: %d, %d\n", size, errno);
- return NULL;
- // }
- memset(p, 0, HUNK_MSIZE);
- p->id = HUNK_ID;
- p->total = __total_h[size];
- /* p->used = 0; */
- p->size = size;
- /* p->next = (Hunk_t*)NULL; */
- /* memset(usagemap(p), 0, bound); */
- __free_h[size] = p;
- }
-
- /* Locate free point in usagemap */
-
- /* First find a word where not all the bits are set */
- for (cpl = (unsigned long *) usagemap(p); *cpl == 0xFFFFFFFF; cpl++);
-
- /* Remember the byte position of that word */
- i = ((unsigned char *) cpl) - usagemap(p);
-
- /* Now find find a free bit in the word using binary search */
- if (*(unsigned short *) cpl != 0xFFFF) {
-
- if (*(unsigned char *) cpl == 0xFF) {
- c = *(((unsigned char *) cpl) + 1);
- i++;
- }
- else
- {
- c = *(unsigned char *) cpl;
- }
- } else {
- i += 2;
- c = *(((unsigned char *) cpl) + 2);
- if (c == 0xFF) {
- c = *(((unsigned char *) cpl) + 3);
- i++;
- }
- }
-
- /*
- * Multiply i by 8 for the bit position
- * Further down, we divide by 8 again to find the byte position
- */
- EMUL8(i);
-
- /* If bottom nibble is set, shift down the top nibble */
- if ((c & 0xF) == 0xF) {
- c >>= 4;
- i += 4;
- }
-
- /* If bottom 2 bits are set, shift down the top two */
- if ((c & 0x3) == 0x3) {
- c >>= 2;
- i += 2;
- }
-
- /* Check which one of the two bits is set */
- if (c & 1)
- i++;
-
- usagemap(p)[DIV8(i)] |= (1 << (i & 7)); /* set bit */
- /* Increment counter and update hashes */
- if (++p->used == p->total) {
- __free_h[p->size] = p->next;
- p->next = NULL;
- }
-
- // fprintf(stderr, "hunk_alloc: i=%d, p->size=%d, p=%p\n", i, p->size, p);
- return hunk_ptr(p) + i * p->size;
-}
-#endif /* L_malloc */
-
-extern void __hunk_free(char *ptr);
-
-#ifdef L__free_support
-/* __hunk_free frees blocks allocated by __hunk_alloc */
-void __hunk_free(char *ptr)
-{
- unsigned char *up;
- int i, v;
- Hunk_t *h;
-
- if (!ptr)
- return;
-
- h = (Hunk_t *) PAGE_DOWNALIGNP(ptr);
-
- /* Validate `ptr` */
- if (h->id != HUNK_ID)
- return;
- v = ptr - hunk_ptr(h);
- i = v / h->size;
- if (v % h->size != 0 || i < 0 || i >= h->total)
- return;
-
- /* Update `usagemap` */
- up = &(usagemap(h)[DIV8(i)]);
- i = 1 << (i & 7);
- if (!(*up & i))
- return;
- *up ^= i;
-
- /* Update hunk counters */
- if (h->used == h->total) {
- if (--h->used) { /* insert into __free_h */
- h->next = __free_h[h->size];
- __free_h[h->size] = h;
- } /* else - it will be unmapped */
- } else {
- if (!--h->used) { /* delete from __free_h - will be __bl_freed */
- Hunk_t *p, *pp;
-
- for (p = __free_h[h->size], pp = NULL; p != h;
- pp = p, p = p->next);
- if (!pp)
- __free_h[h->size] = p->next;
- else
- pp->next = p->next;
- }
- }
-
- /* Unmap empty Hunk_t */
- if (!h->used)
- munmap((void *) h, HUNK_MSIZE);
-}
-#endif /* L__free_support */
-
-/* BLOCK MANAGER */
-
-typedef struct Block_s Block_t;
-
-struct Block_s { /* 32-bytes long control structure (if 4-byte aligned) */
- char *ptr; /* pointer to related data */
- Block_t *next; /* next in free_mem list */
- Block_t *l_free_mem, *r_free_mem; /* left & right subtrees of <free_mem> */
- Block_t *l_ptrs, *r_ptrs; /* left & right subtrees of <ptrs> */
- size_t size; /* size - divided by align */
-
- /* packed 4-byte attributes */
-/* { */
- signed char bal_free_mem:8; /* balance of <free_mem> subtree */
- signed char bal_ptrs:8; /* balance of <ptrs> subtree */
- unsigned int used:1; /* used/free state of the block */
- unsigned int broken:1; /* 1 if previous block can't be merged with it */
-/* } */
-};
-
-extern Block_t *__bl_last; /* last mmapped block */
-
-#ifdef L__malloc_init
-Block_t *__bl_last; /* last mmapped block */
-#endif
-
-#define bl_get() __hunk_alloc(sizeof(Block_t))
-#define bl_rel(p) __hunk_free((char*)p)
-
-extern Block_t *__Avl_Block_tfree_mem_tree;
-extern Block_t *__free_mem_ins(Block_t * data);
-extern void __free_mem_del(Block_t * data);
-extern void __free_mem_replace(Block_t * data);
-extern Block_t *__Avl_Block_tptrs_tree;
-extern Block_t *__ptrs_ins(Block_t * data);
-extern void __ptrs_del(Block_t * data);
-
-extern void __bl_uncommit(Block_t * b);
-extern void __bl_free(Block_t * b);
-
-/* like C++ templates ;-) */
-#include "avlmacro.h"
-
-#define FREE_MEM_COMPARE(i,a,b) \
-{ \
- if ( (a)->size < (b)->size ) { \
- i = -1; \
- } else if ( (a)->size > (b)->size ) { \
- i = 1; \
- } else { \
- i = 0; \
- } \
-}
-
-#define PTRS_COMPARE(i,a,b) \
-{ \
- if ( (a)->ptr < (b)->ptr ) { \
- i = -1; \
- } else if ( (a)->ptr > (b)->ptr ) { \
- i = 1; \
- } else { \
- i = 0; \
- } \
-}
-
-#ifdef L__avl_support
-Avl_Tree(free_mem, Block_t, free_mem, FREE_MEM_COMPARE)
- Avl_Tree_no_replace(ptrs, Block_t, ptrs, PTRS_COMPARE)
-#endif
-#define free_mem_root Avl_Root(Block_t, free_mem)
-#define ptrs_root Avl_Root(Block_t, ptrs)
-/* pp is freed block */
-#define FREE_MEM_DEL_BLOCK(pp,p) {p = __free_mem_del_block(pp,p);}
-extern Block_t *__free_mem_del_block(Block_t * pp, Block_t * p);
-
-#ifdef L_malloc
-Block_t *__free_mem_del_block(Block_t * pp, Block_t * p)
-{
- for (p = free_mem_root;;)
- if (p->size > pp->size)
- p = p->l_free_mem;
- else if (p->size < pp->size)
- p = p->r_free_mem;
- else
- break;
- if (p == pp) {
- if (pp->next)
- __free_mem_replace(pp->next);
- else
- __free_mem_del(pp);
- } else {
- for (; p->next != pp; p = p->next);
- p->next = pp->next;
- }
- return p;
-}
-#endif /* L_malloc */
-
-#define FREE_MEM_INS_BLOCK(pp) \
-{ \
- if ((p = __free_mem_ins(pp)) != NULL)\
- {\
- pp->next = p->next;\
- p->next = pp;\
- }\
- else pp->next = NULL; \
-}
-
-/* `b` is current block, `pp` is next block */
-#define COMBINE_BLOCKS(b,pp) \
-{\
- __ptrs_del(pp); \
- b->size += pp->size; \
- if (pp == __bl_last) __bl_last = b; \
- bl_rel(pp); \
-}
-
-/* initializes new block b */
-#define INIT_BLOCK(b, pppp, sz) { p = __init_block(b, pppp, sz); }
-
-extern Block_t *__init_block(Block_t * b, char *pppp, size_t sz);
-
-#ifdef L_malloc
-Block_t *__init_block(Block_t * b, char *pppp, size_t sz)
-{
- Block_t *p;
-
- memset(b, 0, sizeof(Block_t));
- b->ptr = pppp;
- b->size = sz;
- __ptrs_ins(b);
- FREE_MEM_INS_BLOCK(b);
- return p;
-}
-#endif /* L_malloc */
-
-/* `b` is current block, `sz` its new size */
-/* block `b` will be splitted to one busy & one free block */
-#define SPLIT_BLOCK(b,sz) \
-{\
- Block_t *bt; \
- bt = bl_get(); \
- INIT_BLOCK(bt, b->ptr + sz, b->size - sz); \
- b->size = sz; \
- if (__bl_last == b) __bl_last = bt; \
- __bl_uncommit(bt);\
-}
-
-/* `b` is current block, `pp` is next free block, `sz` is needed size */
-#define SHRINK_BLOCK(b,pp,sz) \
-{\
- FREE_MEM_DEL_BLOCK(pp,p); \
- pp->ptr = b->ptr + sz; \
- pp->size += b->size - sz; \
- b->size = sz; \
- FREE_MEM_INS_BLOCK(pp); \
- __bl_uncommit(pp); \
-}
-
-#ifdef L_malloc
-static Block_t *bl_mapnew(size_t size)
-{
- size_t map_size;
- Block_t *pp, *p;
- void *pt;
-
- map_size = PAGE_ALIGN(size);
- pt = mmap(LARGE_MSTART, map_size, PROT_READ | PROT_WRITE | PROT_EXEC,
-#ifdef __UCLIBC_HAS_MMU__
- MAP_PRIVATE | MAP_ANONYMOUS
-#else
- MAP_SHARED | MAP_ANONYMOUS
-#endif
- , 0, 0);
-
- if (pt == MAP_FAILED)
- return (Block_t *) NULL;
-
- __bl_last = pp = bl_get();
- INIT_BLOCK(pp, (char *) pt, map_size);
- pp->broken = 1;
-
- return pp;
-}
-
-void __bl_uncommit(Block_t * b)
-{
- char *u_start, *u_end;
-
- u_start = PAGE_ALIGNP(b->ptr);
- u_end = PAGE_DOWNALIGNP(b->ptr + b->size);
- if (u_end <= u_start)
- return;
-
-#if M_DOTRIMMING
- mmap(u_start, u_end - u_start, PROT_READ | PROT_WRITE | PROT_EXEC,
-#ifdef __UCLIBC_HAS_MMU__
- MAP_PRIVATE | MAP_ANONYMOUS |MAP_FIXED
-#else
- MAP_SHARED | MAP_ANONYMOUS |MAP_FIXED
-#endif
- , 0, 0);
-#endif
-}
-
-/* requested size must be aligned to ALIGNMENT */
-static Block_t *bl_alloc(size_t size)
-{
- Block_t *p, *pp;
-
- /* try to find needed space in existing memory */
- for (p = free_mem_root, pp = NULL; p;) {
- if (p->size > size) {
- pp = p;
- p = p->l_free_mem;
- } else if (p->size < size)
- p = p->r_free_mem;
- else {
- pp = p;
- break;
- }
- }
-
- if (!pp) { /* map some memory */
- if (!__bl_last) { /* just do initial mmap */
- pp = bl_mapnew(size);
- if (!pp)
- return NULL;
- } else if (!__bl_last->used) { /* try growing last unused */
- if (mremap(PAGE_DOWNALIGNP(__bl_last->ptr),
- PAGE_ALIGNP(__bl_last->ptr + __bl_last->size) -
- PAGE_DOWNALIGNP(__bl_last->ptr),
- PAGE_ALIGNP(__bl_last->ptr + size) -
- PAGE_DOWNALIGNP(__bl_last->ptr), 0) == MAP_FAILED) { /* unable to grow -- initiate new block */
- pp = bl_mapnew(size);
- if (!pp)
- return NULL;
- } else {
- pp = __bl_last;
- FREE_MEM_DEL_BLOCK(pp, p);
- pp->size = PAGE_ALIGNP(pp->ptr + size) - pp->ptr;
- FREE_MEM_INS_BLOCK(pp);
- }
- } else { /* __bl_last is used block */
- if (mremap(PAGE_DOWNALIGNP(__bl_last->ptr),
- PAGE_ALIGNP(__bl_last->ptr + __bl_last->size) -
- PAGE_DOWNALIGNP(__bl_last->ptr),
- PAGE_ALIGNP(__bl_last->ptr + __bl_last->size +
- size) - PAGE_DOWNALIGNP(__bl_last->ptr),
- 0) == MAP_FAILED) {
- pp = bl_mapnew(size);
- if (!pp)
- return NULL;
- } else {
- pp = bl_get();
- INIT_BLOCK(pp, __bl_last->ptr + __bl_last->size,
- PAGE_ALIGNP(__bl_last->ptr + __bl_last->size +
- size) - __bl_last->ptr -
- __bl_last->size);
- __bl_last = pp;
- }
- }
- }
-
- /* just delete this node from free_mem tree */
- if (pp->next)
- __free_mem_replace(pp->next);
- else
- __free_mem_del(pp);
- pp->used = 1;
-
- if (pp->size - size > MALLOC_ALIGN) { /* this block can be splitted (it is unused,not_broken) */
- SPLIT_BLOCK(pp, size);
- }
-
- return pp;
-}
-#endif /* L_malloc */
-
-#ifdef L__free_support
-void __bl_free(Block_t * b)
-{
- Block_t *p, *bl_next, *bl_prev;
-
- /* Look for blocks before & after `b` */
- for (p = ptrs_root, bl_next = NULL, bl_prev = NULL; p;) {
- if (p->ptr > b->ptr) {
- bl_next = p;
- p = p->l_ptrs;
- } else if (p->ptr < b->ptr) {
- bl_prev = p;
- p = p->r_ptrs;
- } else
- break;
- }
- if (b->l_ptrs)
- for (bl_prev = b->l_ptrs; bl_prev->r_ptrs;
- bl_prev = bl_prev->r_ptrs);
- if (b->r_ptrs)
- for (bl_next = b->r_ptrs; bl_next->l_ptrs;
- bl_next = bl_next->l_ptrs);
-
- if (bl_next && !bl_next->broken && !bl_next->used) {
- FREE_MEM_DEL_BLOCK(bl_next, p)
- COMBINE_BLOCKS(b, bl_next)
- }
-
- if (bl_prev && !b->broken && !bl_prev->used) {
- FREE_MEM_DEL_BLOCK(bl_prev, p)
- COMBINE_BLOCKS(bl_prev, b)
- b = bl_prev;
- }
-
- b->used = 0;
- FREE_MEM_INS_BLOCK(b)
- __bl_uncommit(b);
-}
-#endif /* L__free_support */
-
-extern void __malloc_init(void);
-
-#ifdef L__malloc_init
-void __malloc_init(void)
-{
- int i, mapsize, x, old_x, gcount;
-
- mapsize = M_PAGESIZE;
-
- __malloc_initialized = 0;
- __bl_last = NULL;
- free_mem_root = NULL;
- ptrs_root = NULL;
- mapsize -= sizeof(Hunk_t);
- for (i = 1; i <= HUNK_MAXSIZE; i++) {
- __free_h[i] = (Hunk_t *) NULL;
- for (x = mapsize / i, gcount = 0, old_x = 0; old_x != x;) {
- old_x = x;
- x = (mapsize - ALIGN(DIV8(old_x + 7))) / i;
- if (gcount > 1 && x * i + ALIGN(DIV8(x + 7)) <= mapsize)
- break;
- if (x * i + ALIGN(DIV8(x + 7)) > mapsize)
- gcount++;
- }
- __total_h[i] = x;
- }
- mutex_init(&malloc_lock);
- __malloc_initialized = 1;
- // fprintf(stderr, "malloc_init: hunk_t=%d\n", sizeof(Hunk_t));
-}
-#endif /* L__malloc_init */
-
-#ifdef L_malloc
-void *malloc(size_t size)
-{
- void *p;
-
- if (size == 0)
- return NULL;
-
- if (__malloc_initialized < 0)
- __malloc_init();
- if (__malloc_initialized)
- mutex_lock(&malloc_lock);
-
- if (size <= HUNK_MAXSIZE)
- p = __hunk_alloc(size);
- else {
- if ((p = bl_alloc(ALIGN(size))) != NULL)
- p = ((Block_t *) p)->ptr;
- }
-
- if (__malloc_initialized)
- mutex_unlock(&malloc_lock);
-
- // fprintf(stderr, "malloc returning: s=%d, p=%p\n", size, p);
- return p;
-}
-#endif /* L_malloc */
-
-#ifdef L_free
-void free(void *ptr)
-{
- Block_t *p, *best;
-
- if (__malloc_initialized < 0)
- return;
- if (__malloc_initialized)
- mutex_lock(&malloc_lock);
-
- for (p = ptrs_root, best = NULL; p;) {
- if (p->ptr > (char *) ptr)
- p = p->l_ptrs;
- else {
- best = p;
- p = p->r_ptrs;
- }
- }
-
- if (!best || !best->used || best->ptr != (char *) ptr) {
- __hunk_free(ptr);
- if (__malloc_initialized)
- mutex_unlock(&malloc_lock);
- return;
- }
-
- __bl_free(best);
-
- if (__malloc_initialized)
- mutex_unlock(&malloc_lock);
-}
-#endif /* L_free */
-
-extern void *_realloc_no_move(void *ptr, size_t size);
-
-#ifdef L__realloc_no_move
-void *_realloc_no_move(void *ptr, size_t size)
-{
- Block_t *p, *best, *next;
-
- if (size <= HUNK_MAXSIZE)
- return NULL;
-
- if (__malloc_initialized <= 0)
- return malloc(size);
-
- mutex_lock(&malloc_lock);
-
- /* Locate block */
- for (p = ptrs_root, best = NULL; p;) {
- if (p->ptr > (char *) ptr)
- p = p->l_ptrs;
- else {
- best = p;
- p = p->r_ptrs;
- }
- }
-
- if (!best || !best->used || best->ptr != (char *) ptr) {
- mutex_unlock(&malloc_lock);
- return NULL;
- }
-
- size = ALIGN(size);
-
- if (size == best->size) {
- mutex_unlock(&malloc_lock);
- return ptr;
- }
-
- if (best->r_ptrs) /* get block just after */
- for (next = best->r_ptrs; next->l_ptrs; next = next->l_ptrs);
- else
- for (p = ptrs_root, next = NULL; p;) {
- if (p->ptr > best->ptr) {
- next = p;
- p = p->l_ptrs;
- } else if (p->ptr < best->ptr)
- p = p->r_ptrs;
- else
- break;
- }
-
- if (size < best->size) { /* shrink block */
- if (!next || next->used || next->broken) {
- if (best->size - size > MALLOC_ALIGN) { /* do split */
- SPLIT_BLOCK(best, size);
- }
- } else { /* just move border of next block */
- SHRINK_BLOCK(best, next, size);
- }
- } else if (next && !next->broken && !next->used) { /* can expand */
- if (best->size + next->size > size + HUNK_MAXSIZE) { /* shrink next free block */
- SHRINK_BLOCK(best, next, size);
- } else if (best->size + next->size >= size) { /* combine blocks (eat next one) */
- FREE_MEM_DEL_BLOCK(next, p);
- COMBINE_BLOCKS(best, next);
- } else { /* not enough memory in next block */
- mutex_unlock(&malloc_lock);
- return NULL;
- }
- } else { /* no next block */
- mutex_unlock(&malloc_lock);
- return NULL;
- }
- mutex_unlock(&malloc_lock);
- return best->ptr;
-}
-#endif /* L__realloc_no_move */
-
-#ifdef L_realloc
-void *realloc(void *ptr, size_t size)
-{
- void *tmp;
-
- tmp = _realloc_no_move(ptr, size);
-
- if (!tmp) {
- Block_t *p, *best;
-
- mutex_lock(&malloc_lock);
-
- for (p = ptrs_root, best = NULL; p;) {
- if (p->ptr > (char *) ptr)
- p = p->l_ptrs;
- else {
- best = p;
- p = p->r_ptrs;
- }
- }
-
- if (!best || !best->used || best->ptr != (char *) ptr) {
- if (ptr) {
- Hunk_t *h;
+#include "malloc.h"
+#include "heap.h"
- h = (Hunk_t *) PAGE_DOWNALIGNP(ptr);
- if (h->id == HUNK_ID) {
- mutex_unlock(&malloc_lock);
- if ((size >= HUNK_THRESHOLD && ALIGN(size) == h->size)
- || size == h->size)
- return ptr;
- if ((tmp = malloc(size)) == NULL)
- return NULL;
- mutex_lock(&malloc_lock);
- memcpy(tmp, ptr, ((size < h->size) ? size : h->size));
- __hunk_free(ptr);
- mutex_unlock(&malloc_lock);
- return tmp;
- }
- }
- mutex_unlock(&malloc_lock);
- return malloc(size);
- }
- mutex_unlock(&malloc_lock);
+/* When we give memory to the heap, start this many bytes after the
+ beginning of the mmaped block. This is because we must ensure that
+ malloc return values are aligned to MALLOC_ALIGNMENT, but since we need
+ to use one word _before_ the beginning of that, we actually want the heap
+ to return values that are MALLOC_ALIGNMENT aligned - sizeof (size_t).
+ Since the heap always allocates in multiples of HEAP_GRANULARITY, we can
+ do this by (1) ensuring that HEAP_GRANULARITY is a multiple of
+ MALLOC_ALIGNMENT, and (2) making sure that the heap's free areas start
+ sizeof(size_t) bytes before our required alignment. */
+#define MALLOC_HEAP_BLOCK_SHIM (MALLOC_ALIGNMENT - sizeof (size_t))
- /* copy whole block */
- if ((tmp = malloc(size)) == NULL)
- return NULL;
- memcpy(tmp, ptr, ((size < best->size) ? size : best->size));
- mutex_lock(&malloc_lock);
- __bl_free(best);
- mutex_unlock(&malloc_lock);
- }
- return tmp;
-}
-#endif /* L_realloc */
+/* The heap used for small allocations. */
+struct heap __malloc_heap = HEAP_INIT;
-#ifdef L_calloc
-void *calloc(size_t unit, size_t quantity)
+\f
+void *malloc (size_t size)
{
- void *p;
-
- unit *= quantity;
-
- if ((p = malloc(unit)) == NULL)
- return NULL;
- memset(p, 0, unit);
- return p;
+ void *mem;
+
+ MALLOC_DEBUG ("malloc: %d bytes\n", size);
+
+ /* Include an extra word to record the size of the allocated block. */
+ size += sizeof (size_t);
+
+ if (size >= MALLOC_MMAP_THRESHOLD)
+ /* Use mmap for large allocations. */
+ {
+ /* Make sure we request enough memory to align the result correctly,
+ and that SIZE reflects that mmap hands back whole pages. */
+ size += MALLOC_ROUND_UP_TO_PAGE_SIZE (MALLOC_ALIGNMENT - sizeof(size_t));
+
+ mem = mmap (0, size, PROT_READ | PROT_WRITE,
+ MAP_SHARED | MAP_ANONYMOUS, 0, 0);
+ if (mem == MAP_FAILED)
+ return 0;
+ }
+ else
+ /* Use the heap for small allocations. */
+ {
+ mem = __heap_alloc (&__malloc_heap, &size);
+
+ if (! mem)
+ /* We couldn't allocate from the heap, so get some more memory
+ from the system, add it to the heap, and try again. */
+ {
+ /* If we're trying to allocate a block bigger than the default
+ MALLOC_HEAP_EXTEND_SIZE, make sure we get enough to hold it. */
+ size_t block_size = (size < MALLOC_HEAP_EXTEND_SIZE
+ ? MALLOC_HEAP_EXTEND_SIZE
+ : MALLOC_ROUND_UP_TO_PAGE_SIZE (size));
+ /* Allocate the new heap block. */
+ void *block = mmap (0, block_size,
+ PROT_READ | PROT_WRITE,
+ MAP_SHARED | MAP_ANONYMOUS, 0, 0);
+
+ if (block != MAP_FAILED)
+ {
+ /* Put BLOCK into the heap. We first try to append BLOCK to
+ an existing free area, which is more efficient because it
+ doesn't require using a `shim' at the beginning (which
+ would prevent merging free-areas); since mmap often returns
+ contiguous areas, this is worth it. */
+ if (! __heap_append_free (&__malloc_heap, block, block_size))
+ /* Couldn't append, just add BLOCK as a new free-area. */
+ __heap_free (&__malloc_heap,
+ block + MALLOC_HEAP_BLOCK_SHIM,
+ block_size - MALLOC_HEAP_BLOCK_SHIM);
+
+ /* Try again to allocate. */
+ mem = __heap_alloc (&__malloc_heap, &size);
+ }
+ }
+ }
+
+ if (mem)
+ /* Record the size of this block just before the returned address. */
+ {
+ *(size_t *)mem = size;
+ mem = (size_t *)mem + 1;
+
+ MALLOC_DEBUG (" malloc: returning 0x%lx (base:0x%lx, total_size:%d)\n",
+ (long)mem, (long)mem - sizeof (size_t), size);
+ }
+
+ return mem;
}
-#endif /* L_calloc */
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/malloc.h -- small malloc implementation
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+/* The alignment we guarantee for malloc return values. */
+#define MALLOC_ALIGNMENT (sizeof (double))
+
+/* The system pagesize we assume; we really ought to get it with
+ getpagesize, but gee, how annoying. */
+#define MALLOC_PAGE_SIZE 4096
+
+/* The minimum size of block we request from the the system to extend the
+ heap for small allocations (we may request a bigger block if necessary to
+ satisfy a particularly big request). */
+#define MALLOC_HEAP_EXTEND_SIZE MALLOC_PAGE_SIZE
+
+/* The threshold above which blocks are allocated/freed with mmap/munmap,
+ rather than using the heap. */
+#define MALLOC_MMAP_THRESHOLD (8*MALLOC_PAGE_SIZE)
+
+
+#if 0
+#include <stdio.h>
+#define MALLOC_DEBUG(fmt, args...) fprintf (stderr, fmt , ##args)
+#else
+#define MALLOC_DEBUG(fmt, args...) (void)0
+#endif
+
+
+/* Return SZ rounded up to a multiple MALLOC_PAGE_SIZE. */
+#define MALLOC_ROUND_UP_TO_PAGE_SIZE(sz) \
+ (((sz) + (MALLOC_PAGE_SIZE - 1)) & ~(MALLOC_PAGE_SIZE - 1))
+
+
+/* The heap used for small allocations. */
+extern struct heap __malloc_heap;
--- /dev/null
+/*
+ * libc/stdlib/malloc-zarg/realloc.c -- realloc function
+ *
+ * Copyright (C) 2002 NEC Corporation
+ * Copyright (C) 2002 Miles Bader <miles@gnu.org>
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License. See the file COPYING.LIB in the main
+ * directory of this archive for more details.
+ *
+ * Written by Miles Bader <miles@gnu.org>
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+
+#include "malloc.h"
+#include "heap.h"
+
+
+void *realloc (void *mem, size_t new_size)
+{
+ if (! mem)
+ return malloc (new_size);
+ else
+ {
+ void *base_mem = (size_t *)mem - 1;
+ size_t size = *(size_t *)base_mem;
+
+ MALLOC_DEBUG ("realloc: 0x%lx, %d (base = 0x%lx, total_size = %d)\n",
+ (long)mem, new_size, (long)base_mem, size);
+
+ if (new_size <= size)
+ return mem;
+ else
+ {
+ void *new_mem = 0;
+ size_t ext_size = new_size - size;
+ void *ext_addr = (char *)base_mem + ext_size;
+
+ if (size >= MALLOC_MMAP_THRESHOLD)
+ /* Try to extend this block in place using mmap. */
+ {
+ ext_size += MALLOC_ROUND_UP_TO_PAGE_SIZE (ext_size);
+
+ new_mem = mmap (ext_addr, ext_size, PROT_READ | PROT_WRITE,
+ MAP_FIXED | MAP_SHARED | MAP_ANONYMOUS, 0, 0);
+ if (new_mem == MAP_FAILED)
+ /* Can't do it. */
+ ext_size = 0;
+ }
+ else
+ ext_size = __heap_alloc_at (&__malloc_heap, ext_addr, ext_size);
+
+ if (! ext_size)
+ /* Our attempts to extend MEM in place failed, just
+ allocate-and-copy. */
+ {
+ new_mem = malloc (new_size);
+ if (new_mem)
+ {
+ memcpy (new_mem, mem, size);
+ free (mem);
+ }
+ }
+
+ if (new_mem)
+ MALLOC_DEBUG (" realloc: returning 0x%lx"
+ " (base:0x%lx, total_size:%d)\n",
+ (long)new_mem, (long)new_mem - sizeof(size_t), size);
+
+ return new_mem;
+ }
+ }
+}
OSDN Git Service
