diff options
Diffstat (limited to 'src/gmalloc.c')
| -rw-r--r-- | src/gmalloc.c | 614 |
1 files changed, 225 insertions, 389 deletions
diff --git a/src/gmalloc.c b/src/gmalloc.c index 7b5e6df009..78d6934755 100644 --- a/src/gmalloc.c +++ b/src/gmalloc.c @@ -1,9 +1,3 @@ -/* This file is no longer automatically generated from libc. */ - -#define _MALLOC_INTERNAL - -/* The malloc headers and source files from the C library follow here. */ - /* Declarations for `malloc' and friends. Copyright (C) 1990, 1991, 1992, 1993, 1995, 1996, 1999, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. @@ -27,76 +21,50 @@ Fifth Floor, Boston, MA 02110-1301, USA. The author may be reached (Email) at the address mike@ai.mit.edu, or (US mail) as Mike Haertel c/o Free Software Foundation. */ -#ifndef _MALLOC_H - -#define _MALLOC_H 1 - -#ifdef _MALLOC_INTERNAL - -#ifdef HAVE_CONFIG_H #include <config.h> -#endif #ifdef HAVE_PTHREAD #define USE_PTHREAD #endif -#undef PP -#define PP(args) args -#undef __ptr_t -#define __ptr_t void * - #include <string.h> #include <limits.h> +#include <stdint.h> #include <unistd.h> #ifdef USE_PTHREAD #include <pthread.h> #endif -#endif /* _MALLOC_INTERNAL. */ - - #ifdef __cplusplus extern "C" { #endif #include <stddef.h> -#define __malloc_size_t size_t -#define __malloc_ptrdiff_t ptrdiff_t /* Allocate SIZE bytes of memory. */ -extern __ptr_t malloc PP ((__malloc_size_t __size)); +extern void *malloc (size_t size); /* Re-allocate the previously allocated block - in __ptr_t, making the new block SIZE bytes long. */ -extern __ptr_t realloc PP ((__ptr_t __ptr, __malloc_size_t __size)); + in ptr, making the new block SIZE bytes long. */ +extern void *realloc (void *ptr, size_t size); /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */ -extern __ptr_t calloc PP ((__malloc_size_t __nmemb, __malloc_size_t __size)); +extern void *calloc (size_t nmemb, size_t size); /* Free a block allocated by `malloc', `realloc' or `calloc'. */ -extern void free PP ((__ptr_t __ptr)); +extern void free (void *ptr); /* Allocate SIZE bytes allocated to ALIGNMENT bytes. */ -#if !defined (_MALLOC_INTERNAL) || defined (MSDOS) /* Avoid conflict. */ -extern __ptr_t memalign PP ((__malloc_size_t __alignment, - __malloc_size_t __size)); -extern int posix_memalign PP ((__ptr_t *, __malloc_size_t, - __malloc_size_t size)); -#endif - -/* Allocate SIZE bytes on a page boundary. */ -#if ! (defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC)) -extern __ptr_t valloc PP ((__malloc_size_t __size)); +#ifdef MSDOS +extern void *memalign (size_t, size_t); +extern int posix_memalign (void **, size_t, size_t); #endif #ifdef USE_PTHREAD /* Set up mutexes and make malloc etc. thread-safe. */ -extern void malloc_enable_thread PP ((void)); +extern void malloc_enable_thread (void); #endif -#ifdef _MALLOC_INTERNAL - /* 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, @@ -128,22 +96,22 @@ typedef union { struct { - __malloc_size_t nfree; /* Free frags in a fragmented block. */ - __malloc_size_t first; /* First free fragment of the block. */ + size_t nfree; /* Free frags in a fragmented block. */ + size_t first; /* First free fragment of the block. */ } frag; /* For a large object, in its first block, this has the number of blocks in the object. In the other blocks, this has a negative number which says how far back the first block is. */ - __malloc_ptrdiff_t size; + ptrdiff_t size; } info; } busy; /* Heap information for a free block (that may be the first of a free cluster). */ struct { - __malloc_size_t size; /* Size (in blocks) of a free cluster. */ - __malloc_size_t next; /* Index of next free cluster. */ - __malloc_size_t 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; } malloc_info; @@ -155,13 +123,13 @@ extern malloc_info *_heapinfo; /* Address to block number and vice versa. */ #define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1) -#define ADDRESS(B) ((__ptr_t) (((B) - 1) * BLOCKSIZE + _heapbase)) +#define ADDRESS(B) ((void *) (((B) - 1) * BLOCKSIZE + _heapbase)) /* Current search index for the heap table. */ -extern __malloc_size_t _heapindex; +extern size_t _heapindex; /* Limit of valid info table indices. */ -extern __malloc_size_t _heaplimit; +extern size_t _heaplimit; /* Doubly linked lists of free fragments. */ struct list @@ -177,26 +145,26 @@ extern struct list _fraghead[]; struct alignlist { struct alignlist *next; - __ptr_t aligned; /* The address that memaligned returned. */ - __ptr_t exact; /* The address that malloc returned. */ + void *aligned; /* The address that memaligned returned. */ + void *exact; /* The address that malloc returned. */ }; extern struct alignlist *_aligned_blocks; /* Instrumentation. */ -extern __malloc_size_t _chunks_used; -extern __malloc_size_t _bytes_used; -extern __malloc_size_t _chunks_free; -extern __malloc_size_t _bytes_free; +extern size_t _chunks_used; +extern size_t _bytes_used; +extern size_t _chunks_free; +extern size_t _bytes_free; /* Internal versions of `malloc', `realloc', and `free' used when these functions need to call each other. They are the same but don't call the hooks. */ -extern __ptr_t _malloc_internal PP ((__malloc_size_t __size)); -extern __ptr_t _realloc_internal PP ((__ptr_t __ptr, __malloc_size_t __size)); -extern void _free_internal PP ((__ptr_t __ptr)); -extern __ptr_t _malloc_internal_nolock PP ((__malloc_size_t __size)); -extern __ptr_t _realloc_internal_nolock PP ((__ptr_t __ptr, __malloc_size_t __size)); -extern void _free_internal_nolock PP ((__ptr_t __ptr)); +extern void *_malloc_internal (size_t); +extern void *_realloc_internal (void *, size_t); +extern void _free_internal (void *); +extern void *_malloc_internal_nolock (size_t); +extern void *_realloc_internal_nolock (void *, size_t); +extern void _free_internal_nolock (void *); #ifdef USE_PTHREAD extern pthread_mutex_t _malloc_mutex, _aligned_blocks_mutex; @@ -228,39 +196,36 @@ extern int _malloc_thread_enabled_p; #define UNLOCK_ALIGNED_BLOCKS() #endif -#endif /* _MALLOC_INTERNAL. */ - /* Given an address in the middle of a malloc'd object, return the address of the beginning of the object. */ -extern __ptr_t malloc_find_object_address PP ((__ptr_t __ptr)); +extern void *malloc_find_object_address (void *ptr); /* Underlying allocation function; successive calls should return contiguous pieces of memory. */ -extern __ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size)); +extern void *(*__morecore) (ptrdiff_t size); /* Default value of `__morecore'. */ -extern __ptr_t __default_morecore PP ((__malloc_ptrdiff_t __size)); +extern void *__default_morecore (ptrdiff_t size); /* If not NULL, this function is called after each time `__morecore' is called to increase the data size. */ -extern void (*__after_morecore_hook) PP ((void)); +extern void (*__after_morecore_hook) (void); /* Number of extra blocks to get each time we ask for more core. This reduces the frequency of calling `(*__morecore)'. */ -extern __malloc_size_t __malloc_extra_blocks; +extern size_t __malloc_extra_blocks; /* Nonzero if `malloc' has been called and done its initialization. */ extern int __malloc_initialized; /* Function called to initialize malloc data structures. */ -extern int __malloc_initialize PP ((void)); +extern int __malloc_initialize (void); /* Hooks for debugging versions. */ -extern void (*__malloc_initialize_hook) PP ((void)); -extern void (*__free_hook) PP ((__ptr_t __ptr)); -extern __ptr_t (*__malloc_hook) PP ((__malloc_size_t __size)); -extern __ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size)); -extern __ptr_t (*__memalign_hook) PP ((__malloc_size_t __size, - __malloc_size_t __alignment)); +extern void (*__malloc_initialize_hook) (void); +extern void (*__free_hook) (void *ptr); +extern void *(*__malloc_hook) (size_t size); +extern void *(*__realloc_hook) (void *ptr, size_t size); +extern void *(*__memalign_hook) (size_t size, size_t alignment); /* Return values for `mprobe': these are the kinds of inconsistencies that `mcheck' enables detection of. */ @@ -277,52 +242,37 @@ enum mcheck_status before `malloc' is ever called. ABORTFUNC is called with an error code (see enum above) when an inconsistency is detected. If ABORTFUNC is null, the standard function prints on stderr and then calls `abort'. */ -extern int mcheck PP ((void (*__abortfunc) PP ((enum mcheck_status)))); +extern int mcheck (void (*abortfunc) (enum mcheck_status)); /* Check for aberrations in a particular malloc'd block. You must have called `mcheck' already. These are the same checks that `mcheck' does when you free or reallocate a block. */ -extern enum mcheck_status mprobe PP ((__ptr_t __ptr)); +extern enum mcheck_status mprobe (void *ptr); /* Activate a standard collection of tracing hooks. */ -extern void mtrace PP ((void)); -extern void muntrace PP ((void)); +extern void mtrace (void); +extern void muntrace (void); /* Statistics available to the user. */ struct mstats { - __malloc_size_t bytes_total; /* Total size of the heap. */ - __malloc_size_t chunks_used; /* Chunks allocated by the user. */ - __malloc_size_t bytes_used; /* Byte total of user-allocated chunks. */ - __malloc_size_t chunks_free; /* Chunks in the free list. */ - __malloc_size_t bytes_free; /* Byte total of chunks in the free list. */ + size_t bytes_total; /* Total size of the heap. */ + size_t chunks_used; /* Chunks allocated by the user. */ + size_t bytes_used; /* Byte total of user-allocated chunks. */ + size_t chunks_free; /* Chunks in the free list. */ + size_t bytes_free; /* Byte total of chunks in the free list. */ }; /* Pick up the current statistics. */ -extern struct mstats mstats PP ((void)); +extern struct mstats mstats (void); /* Call WARNFUN with a warning message when memory usage is high. */ -extern void memory_warnings PP ((__ptr_t __start, - void (*__warnfun) PP ((const char *)))); - - -/* Relocating allocator. */ - -/* Allocate SIZE bytes, and store the address in *HANDLEPTR. */ -extern __ptr_t r_alloc PP ((__ptr_t *__handleptr, __malloc_size_t __size)); - -/* Free the storage allocated in HANDLEPTR. */ -extern void r_alloc_free PP ((__ptr_t *__handleptr)); - -/* Adjust the block at HANDLEPTR to be SIZE bytes long. */ -extern __ptr_t r_re_alloc PP ((__ptr_t *__handleptr, __malloc_size_t __size)); - +extern void memory_warnings (void *start, void (*warnfun) (const char *)); #ifdef __cplusplus } #endif -#endif /* malloc.h */ /* Memory allocator `malloc'. Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. Written May 1989 by Mike Haertel. @@ -345,10 +295,6 @@ Fifth Floor, Boston, MA 02110-1301, USA. The author may be reached (Email) at the address mike@ai.mit.edu, or (US mail) as Mike Haertel c/o Free Software Foundation. */ -#ifndef _MALLOC_INTERNAL -#define _MALLOC_INTERNAL -#include <malloc.h> -#endif #include <errno.h> /* On Cygwin there are two heaps. temacs uses the static heap @@ -362,15 +308,15 @@ Fifth Floor, Boston, MA 02110-1301, USA. this is changed in the future, we'll have to similarly deal with reinitializing ralloc. */ #ifdef CYGWIN -extern __ptr_t bss_sbrk PP ((ptrdiff_t __size)); +extern void *bss_sbrk (ptrdiff_t size); extern int bss_sbrk_did_unexec; char *bss_sbrk_heapbase; /* _heapbase for static heap */ malloc_info *bss_sbrk_heapinfo; /* _heapinfo for static heap */ #endif -__ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size)) = __default_morecore; +void *(*__morecore) (ptrdiff_t size) = __default_morecore; /* Debugging hook for `malloc'. */ -__ptr_t (*__malloc_hook) PP ((__malloc_size_t __size)); +void *(*__malloc_hook) (size_t size); /* Pointer to the base of the first block. */ char *_heapbase; @@ -379,30 +325,30 @@ char *_heapbase; malloc_info *_heapinfo; /* Number of info entries. */ -static __malloc_size_t heapsize; +static size_t heapsize; /* Search index in the info table. */ -__malloc_size_t _heapindex; +size_t _heapindex; /* Limit of valid info table indices. */ -__malloc_size_t _heaplimit; +size_t _heaplimit; /* Free lists for each fragment size. */ struct list _fraghead[BLOCKLOG]; /* Instrumentation. */ -__malloc_size_t _chunks_used; -__malloc_size_t _bytes_used; -__malloc_size_t _chunks_free; -__malloc_size_t _bytes_free; +size_t _chunks_used; +size_t _bytes_used; +size_t _chunks_free; +size_t _bytes_free; /* Are you experienced? */ int __malloc_initialized; -__malloc_size_t __malloc_extra_blocks; +size_t __malloc_extra_blocks; -void (*__malloc_initialize_hook) PP ((void)); -void (*__after_morecore_hook) PP ((void)); +void (*__malloc_initialize_hook) (void); +void (*__after_morecore_hook) (void); #if defined GC_MALLOC_CHECK && defined GC_PROTECT_MALLOC_STATE @@ -419,12 +365,11 @@ void (*__after_morecore_hook) PP ((void)); #include <sys/mman.h> static int state_protected_p; -static __malloc_size_t last_state_size; +static size_t last_state_size; static malloc_info *last_heapinfo; void -protect_malloc_state (protect_p) - int protect_p; +protect_malloc_state (int protect_p) { /* If _heapinfo has been relocated, make sure its old location isn't left read-only; it will be reused by malloc. */ @@ -453,29 +398,25 @@ protect_malloc_state (protect_p) /* Aligned allocation. */ -static __ptr_t align PP ((__malloc_size_t)); -static __ptr_t -align (size) - __malloc_size_t size; +static void * +align (size_t size) { - __ptr_t result; - unsigned long int adj; + void *result; + ptrdiff_t adj; /* align accepts an unsigned argument, but __morecore accepts a - signed one. This could lead to trouble if SIZE overflows a - signed int type accepted by __morecore. We just punt in that + signed one. This could lead to trouble if SIZE overflows the + ptrdiff_t type accepted by __morecore. We just punt in that case, since they are requesting a ludicrous amount anyway. */ - if ((__malloc_ptrdiff_t)size < 0) + if (PTRDIFF_MAX < size) result = 0; else result = (*__morecore) (size); - adj = (unsigned long int) ((unsigned long int) ((char *) result - - (char *) NULL)) % BLOCKSIZE; + adj = (uintptr_t) result % BLOCKSIZE; if (adj != 0) { - __ptr_t new; adj = BLOCKSIZE - adj; - new = (*__morecore) (adj); + (*__morecore) (adj); result = (char *) result + adj; } @@ -488,14 +429,11 @@ align (size) /* Get SIZE bytes, if we can get them starting at END. Return the address of the space we got. If we cannot get space at END, fail and return 0. */ -static __ptr_t get_contiguous_space PP ((__malloc_ptrdiff_t, __ptr_t)); -static __ptr_t -get_contiguous_space (size, position) - __malloc_ptrdiff_t size; - __ptr_t position; +static void * +get_contiguous_space (ptrdiff_t size, void *position) { - __ptr_t before; - __ptr_t after; + void *before; + void *after; before = (*__morecore) (0); /* If we can tell in advance that the break is at the wrong place, @@ -525,7 +463,7 @@ get_contiguous_space (size, position) static inline void register_heapinfo (void) { - __malloc_size_t block, blocks; + size_t block, blocks; block = BLOCK (_heapinfo); blocks = BLOCKIFY (heapsize * sizeof (malloc_info)); @@ -548,21 +486,21 @@ pthread_mutex_t _aligned_blocks_mutex = PTHREAD_MUTEX_INITIALIZER; int _malloc_thread_enabled_p; static void -malloc_atfork_handler_prepare () +malloc_atfork_handler_prepare (void) { LOCK (); LOCK_ALIGNED_BLOCKS (); } static void -malloc_atfork_handler_parent () +malloc_atfork_handler_parent (void) { UNLOCK_ALIGNED_BLOCKS (); UNLOCK (); } static void -malloc_atfork_handler_child () +malloc_atfork_handler_child (void) { UNLOCK_ALIGNED_BLOCKS (); UNLOCK (); @@ -570,7 +508,7 @@ malloc_atfork_handler_child () /* Set up mutexes and make malloc etc. thread-safe. */ void -malloc_enable_thread () +malloc_enable_thread (void) { if (_malloc_thread_enabled_p) return; @@ -589,7 +527,7 @@ malloc_enable_thread () #endif static void -malloc_initialize_1 () +malloc_initialize_1 (void) { #ifdef GC_MCHECK mcheck (NULL); @@ -609,7 +547,7 @@ malloc_initialize_1 () (*__malloc_initialize_hook) (); heapsize = HEAP / BLOCKSIZE; - _heapinfo = (malloc_info *) align (heapsize * sizeof (malloc_info)); + _heapinfo = align (heapsize * sizeof (malloc_info)); if (_heapinfo == NULL) return; memset (_heapinfo, 0, heapsize * sizeof (malloc_info)); @@ -630,7 +568,7 @@ malloc_initialize_1 () main will call malloc which calls this function. That is before any threads or signal handlers has been set up, so we don't need thread protection. */ int -__malloc_initialize () +__malloc_initialize (void) { if (__malloc_initialized) return 0; @@ -644,14 +582,12 @@ static int morecore_recursing; /* Get neatly aligned memory, initializing or growing the heap info table as necessary. */ -static __ptr_t morecore_nolock PP ((__malloc_size_t)); -static __ptr_t -morecore_nolock (size) - __malloc_size_t size; +static void * +morecore_nolock (size_t size) { - __ptr_t result; + void *result; malloc_info *newinfo, *oldinfo; - __malloc_size_t newsize; + size_t newsize; if (morecore_recursing) /* Avoid recursion. The caller will know how to handle a null return. */ @@ -664,7 +600,7 @@ morecore_nolock (size) PROTECT_MALLOC_STATE (0); /* Check if we need to grow the info table. */ - if ((__malloc_size_t) BLOCK ((char *) result + size) > heapsize) + if ((size_t) BLOCK ((char *) result + size) > heapsize) { /* Calculate the new _heapinfo table size. We do not account for the added blocks in the table itself, as we hope to place them in @@ -673,7 +609,7 @@ morecore_nolock (size) newsize = heapsize; do newsize *= 2; - while ((__malloc_size_t) BLOCK ((char *) result + size) > newsize); + while ((size_t) BLOCK ((char *) result + size) > newsize); /* We must not reuse existing core for the new info table when called from realloc in the case of growing a large block, because the @@ -689,8 +625,8 @@ morecore_nolock (size) `morecore_recursing' flag and return null. */ int save = errno; /* Don't want to clobber errno with ENOMEM. */ morecore_recursing = 1; - newinfo = (malloc_info *) _realloc_internal_nolock - (_heapinfo, newsize * sizeof (malloc_info)); + newinfo = _realloc_internal_nolock (_heapinfo, + newsize * sizeof (malloc_info)); morecore_recursing = 0; if (newinfo == NULL) errno = save; @@ -710,7 +646,7 @@ morecore_nolock (size) /* Allocate new space for the malloc info table. */ while (1) { - newinfo = (malloc_info *) align (newsize * sizeof (malloc_info)); + newinfo = align (newsize * sizeof (malloc_info)); /* Did it fail? */ if (newinfo == NULL) @@ -721,8 +657,8 @@ morecore_nolock (size) /* Is it big enough to record status for its own space? If so, we win. */ - if ((__malloc_size_t) BLOCK ((char *) newinfo - + newsize * sizeof (malloc_info)) + if ((size_t) BLOCK ((char *) newinfo + + newsize * sizeof (malloc_info)) < newsize) break; @@ -759,13 +695,12 @@ morecore_nolock (size) } /* Allocate memory from the heap. */ -__ptr_t -_malloc_internal_nolock (size) - __malloc_size_t size; +void * +_malloc_internal_nolock (size_t size) { - __ptr_t result; - __malloc_size_t block, blocks, lastblocks, start; - register __malloc_size_t i; + void *result; + size_t block, blocks, lastblocks, start; + register size_t i; struct list *next; /* ANSI C allows `malloc (0)' to either return NULL, or to return a @@ -790,7 +725,7 @@ _malloc_internal_nolock (size) { /* Small allocation to receive a fragment of a block. Determine the logarithm to base two of the fragment size. */ - register __malloc_size_t log = 1; + register size_t log = 1; --size; while ((size /= 2) != 0) ++log; @@ -803,15 +738,14 @@ _malloc_internal_nolock (size) /* There are free fragments of this size. Pop a fragment out of the fragment list and return it. Update the block's nfree and first counters. */ - result = (__ptr_t) next; + result = next; next->prev->next = next->next; if (next->next != NULL) next->next->prev = next->prev; block = BLOCK (result); if (--_heapinfo[block].busy.info.frag.nfree != 0) - _heapinfo[block].busy.info.frag.first = (unsigned long int) - ((unsigned long int) ((char *) next->next - (char *) NULL) - % BLOCKSIZE) >> log; + _heapinfo[block].busy.info.frag.first = + (uintptr_t) next->next % BLOCKSIZE >> log; /* Update the statistics. */ ++_chunks_used; @@ -843,7 +777,7 @@ _malloc_internal_nolock (size) next->prev = &_fraghead[log]; _fraghead[log].next = next; - for (i = 2; i < (__malloc_size_t) (BLOCKSIZE >> log); ++i) + for (i = 2; i < (size_t) (BLOCKSIZE >> log); ++i) { next = (struct list *) ((char *) result + (i << log)); next->next = _fraghead[log].next; @@ -877,7 +811,7 @@ _malloc_internal_nolock (size) if (block == start) { /* Need to get more from the system. Get a little extra. */ - __malloc_size_t wantblocks = blocks + __malloc_extra_blocks; + size_t wantblocks = blocks + __malloc_extra_blocks; block = _heapinfo[0].free.prev; lastblocks = _heapinfo[block].free.size; /* Check to see if the new core will be contiguous with the @@ -959,11 +893,10 @@ _malloc_internal_nolock (size) return result; } -__ptr_t -_malloc_internal (size) - __malloc_size_t size; +void * +_malloc_internal (size_t size) { - __ptr_t result; + void *result; LOCK (); result = _malloc_internal_nolock (size); @@ -972,11 +905,10 @@ _malloc_internal (size) return result; } -__ptr_t -malloc (size) - __malloc_size_t size; +void * +malloc (size_t size) { - __ptr_t (*hook) (__malloc_size_t); + void *(*hook) (size_t); if (!__malloc_initialized && !__malloc_initialize ()) return NULL; @@ -998,24 +930,24 @@ malloc (size) /* On some ANSI C systems, some libc functions call _malloc, _free and _realloc. Make them use the GNU functions. */ -__ptr_t -_malloc (size) - __malloc_size_t size; +extern void *_malloc (size_t); +extern void _free (void *); +extern void *_realloc (void *, size_t); + +void * +_malloc (size_t size) { return malloc (size); } void -_free (ptr) - __ptr_t ptr; +_free (void *ptr) { free (ptr); } -__ptr_t -_realloc (ptr, size) - __ptr_t ptr; - __malloc_size_t size; +void * +_realloc (void *ptr, size_t size) { return realloc (ptr, size); } @@ -1043,14 +975,9 @@ Fifth Floor, Boston, MA 02110-1301, USA. The author may be reached (Email) at the address mike@ai.mit.edu, or (US mail) as Mike Haertel c/o Free Software Foundation. */ -#ifndef _MALLOC_INTERNAL -#define _MALLOC_INTERNAL -#include <malloc.h> -#endif - /* Debugging hook for free. */ -void (*__free_hook) PP ((__ptr_t __ptr)); +void (*__free_hook) (void *__ptr); /* List of blocks allocated by memalign. */ struct alignlist *_aligned_blocks = NULL; @@ -1058,15 +985,14 @@ struct alignlist *_aligned_blocks = NULL; /* Return memory to the heap. Like `_free_internal' but don't lock mutex. */ void -_free_internal_nolock (ptr) - __ptr_t ptr; +_free_internal_nolock (void *ptr) { int type; - __malloc_size_t block, blocks; - register __malloc_size_t i; + size_t block, blocks; + register size_t i; struct list *prev, *next; - __ptr_t curbrk; - const __malloc_size_t lesscore_threshold + void *curbrk; + const size_t lesscore_threshold /* Threshold of free space at which we will return some to the system. */ = FINAL_FREE_BLOCKS + 2 * __malloc_extra_blocks; @@ -1076,7 +1002,7 @@ _free_internal_nolock (ptr) return; #ifdef CYGWIN - if (ptr < _heapbase) + if ((char *) ptr < _heapbase) /* We're being asked to free something in the static heap. */ return; #endif @@ -1162,12 +1088,12 @@ _free_internal_nolock (ptr) It's possible that moving _heapinfo will allow us to return some space to the system. */ - __malloc_size_t info_block = BLOCK (_heapinfo); - __malloc_size_t info_blocks = _heapinfo[info_block].busy.info.size; - __malloc_size_t prev_block = _heapinfo[block].free.prev; - __malloc_size_t prev_blocks = _heapinfo[prev_block].free.size; - __malloc_size_t next_block = _heapinfo[block].free.next; - __malloc_size_t next_blocks = _heapinfo[next_block].free.size; + size_t info_block = BLOCK (_heapinfo); + size_t info_blocks = _heapinfo[info_block].busy.info.size; + size_t prev_block = _heapinfo[block].free.prev; + size_t prev_blocks = _heapinfo[prev_block].free.size; + size_t next_block = _heapinfo[block].free.next; + size_t next_blocks = _heapinfo[next_block].free.size; if (/* Win if this block being freed is last in core, the info table is just before it, the previous free block is just before the @@ -1190,7 +1116,7 @@ _free_internal_nolock (ptr) ) { malloc_info *newinfo; - __malloc_size_t oldlimit = _heaplimit; + size_t oldlimit = _heaplimit; /* Free the old info table, clearing _heaplimit to avoid recursion into this code. We don't want to return the @@ -1205,8 +1131,7 @@ _free_internal_nolock (ptr) _heapindex = 0; /* Allocate new space for the info table and move its data. */ - newinfo = (malloc_info *) _malloc_internal_nolock (info_blocks - * BLOCKSIZE); + newinfo = _malloc_internal_nolock (info_blocks * BLOCKSIZE); PROTECT_MALLOC_STATE (0); memmove (newinfo, _heapinfo, info_blocks * BLOCKSIZE); _heapinfo = newinfo; @@ -1222,7 +1147,7 @@ _free_internal_nolock (ptr) /* Now see if we can return stuff to the system. */ if (block + blocks == _heaplimit && blocks >= lesscore_threshold) { - register __malloc_size_t bytes = blocks * BLOCKSIZE; + register size_t bytes = blocks * BLOCKSIZE; _heaplimit -= blocks; (*__morecore) (-bytes); _heapinfo[_heapinfo[block].free.prev].free.next @@ -1255,7 +1180,7 @@ _free_internal_nolock (ptr) /* If all fragments of this block are free, remove them from the fragment list and free the whole block. */ next = prev; - for (i = 1; i < (__malloc_size_t) (BLOCKSIZE >> type); ++i) + for (i = 1; i < (size_t) (BLOCKSIZE >> type); ++i) next = next->next; prev->prev->next = next; if (next != NULL) @@ -1280,7 +1205,7 @@ _free_internal_nolock (ptr) /* If some fragments of this block are free, link this fragment into the fragment list after the first free fragment of this block. */ - next = (struct list *) ptr; + next = ptr; next->next = prev->next; next->prev = prev; prev->next = next; @@ -1293,11 +1218,10 @@ _free_internal_nolock (ptr) /* 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; + prev = ptr; _heapinfo[block].busy.info.frag.nfree = 1; - _heapinfo[block].busy.info.frag.first = (unsigned long int) - ((unsigned long int) ((char *) ptr - (char *) NULL) - % BLOCKSIZE >> type); + _heapinfo[block].busy.info.frag.first = + (uintptr_t) ptr % BLOCKSIZE >> type; prev->next = _fraghead[type].next; prev->prev = &_fraghead[type]; prev->prev->next = prev; @@ -1313,8 +1237,7 @@ _free_internal_nolock (ptr) /* Return memory to the heap. Like `free' but don't call a __free_hook if there is one. */ void -_free_internal (ptr) - __ptr_t ptr; +_free_internal (void *ptr) { LOCK (); _free_internal_nolock (ptr); @@ -1324,10 +1247,9 @@ _free_internal (ptr) /* Return memory to the heap. */ void -free (ptr) - __ptr_t ptr; +free (void *ptr) { - void (*hook) (__ptr_t) = __free_hook; + void (*hook) (void *) = __free_hook; if (hook != NULL) (*hook) (ptr); @@ -1340,8 +1262,7 @@ free (ptr) weak_alias (free, cfree) #else void -cfree (ptr) - __ptr_t ptr; +cfree (void *ptr) { free (ptr); } @@ -1368,32 +1289,24 @@ Fifth Floor, Boston, MA 02110-1301, USA. The author may be reached (Email) at the address mike@ai.mit.edu, or (US mail) as Mike Haertel c/o Free Software Foundation. */ -#ifndef _MALLOC_INTERNAL -#define _MALLOC_INTERNAL -#include <malloc.h> -#endif - - #define min(A, B) ((A) < (B) ? (A) : (B)) /* On Cygwin the dumped emacs may try to realloc storage allocated in the static heap. We just malloc space in the new heap and copy the data. */ #ifdef CYGWIN -__ptr_t -special_realloc (ptr, size) - __ptr_t ptr; - __malloc_size_t size; +void * +special_realloc (void *ptr, size_t size) { - __ptr_t result; + void *result; int type; - __malloc_size_t block, oldsize; + size_t block, oldsize; block = ((char *) ptr - bss_sbrk_heapbase) / BLOCKSIZE + 1; type = bss_sbrk_heapinfo[block].busy.type; oldsize = type == 0 ? bss_sbrk_heapinfo[block].busy.info.size * BLOCKSIZE - : (__malloc_size_t) 1 << type; + : (size_t) 1 << type; result = _malloc_internal_nolock (size); if (result != NULL) memcpy (result, ptr, min (oldsize, size)); @@ -1402,7 +1315,7 @@ special_realloc (ptr, size) #endif /* Debugging hook for realloc. */ -__ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size)); +void *(*__realloc_hook) (void *ptr, size_t size); /* Resize the given region to the new size, returning a pointer to the (possibly moved) region. This is optimized for speed; @@ -1410,14 +1323,12 @@ __ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size)); achieved by unconditionally allocating and copying to a new region. This module has incestuous knowledge of the internals of both free and malloc. */ -__ptr_t -_realloc_internal_nolock (ptr, size) - __ptr_t ptr; - __malloc_size_t size; +void * +_realloc_internal_nolock (void *ptr, size_t size) { - __ptr_t result; + void *result; int type; - __malloc_size_t block, blocks, oldlimit; + size_t block, blocks, oldlimit; if (size == 0) { @@ -1428,7 +1339,7 @@ _realloc_internal_nolock (ptr, size) return _malloc_internal_nolock (size); #ifdef CYGWIN - if (ptr < _heapbase) + if ((char *) ptr < _heapbase) /* ptr points into the static heap */ return special_realloc (ptr, size); #endif @@ -1497,7 +1408,7 @@ _realloc_internal_nolock (ptr, size) (void) _malloc_internal_nolock (blocks * BLOCKSIZE); else { - __ptr_t previous + void *previous = _malloc_internal_nolock ((block - _heapindex) * BLOCKSIZE); (void) _malloc_internal_nolock (blocks * BLOCKSIZE); _free_internal_nolock (previous); @@ -1512,8 +1423,8 @@ _realloc_internal_nolock (ptr, size) default: /* Old size is a fragment; type is logarithm to base two of the fragment size. */ - if (size > (__malloc_size_t) (1 << (type - 1)) && - size <= (__malloc_size_t) (1 << type)) + if (size > (size_t) (1 << (type - 1)) && + size <= (size_t) (1 << type)) /* The new size is the same kind of fragment. */ result = ptr; else @@ -1523,7 +1434,7 @@ _realloc_internal_nolock (ptr, size) result = _malloc_internal_nolock (size); if (result == NULL) goto out; - memcpy (result, ptr, min (size, (__malloc_size_t) 1 << type)); + memcpy (result, ptr, min (size, (size_t) 1 << type)); _free_internal_nolock (ptr); } break; @@ -1534,12 +1445,10 @@ _realloc_internal_nolock (ptr, size) return result; } -__ptr_t -_realloc_internal (ptr, size) - __ptr_t ptr; - __malloc_size_t size; +void * +_realloc_internal (void *ptr, size_t size) { - __ptr_t result; + void *result; LOCK (); result = _realloc_internal_nolock (ptr, size); @@ -1548,12 +1457,10 @@ _realloc_internal (ptr, size) return result; } -__ptr_t -realloc (ptr, size) - __ptr_t ptr; - __malloc_size_t size; +void * +realloc (void *ptr, size_t size) { - __ptr_t (*hook) (__ptr_t, __malloc_size_t); + void *(*hook) (void *, size_t); if (!__malloc_initialized && !__malloc_initialize ()) return NULL; @@ -1581,19 +1488,12 @@ Fifth Floor, Boston, MA 02110-1301, USA. The author may be reached (Email) at the address mike@ai.mit.edu, or (US mail) as Mike Haertel c/o Free Software Foundation. */ -#ifndef _MALLOC_INTERNAL -#define _MALLOC_INTERNAL -#include <malloc.h> -#endif - /* Allocate an array of NMEMB elements each SIZE bytes long. The entire array is initialized to zeros. */ -__ptr_t -calloc (nmemb, size) - register __malloc_size_t nmemb; - register __malloc_size_t size; +void * +calloc (register size_t nmemb, register size_t size) { - register __ptr_t result = malloc (nmemb * size); + register void *result = malloc (nmemb * size); if (result != NULL) (void) memset (result, 0, nmemb * size); @@ -1618,11 +1518,6 @@ along with the GNU C Library; see the file COPYING. If not, write to the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#ifndef _MALLOC_INTERNAL -#define _MALLOC_INTERNAL -#include <malloc.h> -#endif - /* uClibc defines __GNU_LIBRARY__, but it is not completely compatible. */ #if !defined (__GNU_LIBRARY__) || defined (__UCLIBC__) @@ -1631,30 +1526,24 @@ MA 02110-1301, USA. */ /* It is best not to declare this and cast its result on foreign operating systems with potentially hostile include files. */ -#include <stddef.h> -extern __ptr_t __sbrk PP ((ptrdiff_t increment)); +extern void *__sbrk (ptrdiff_t increment); #endif /* __GNU_LIBRARY__ && ! defined (__UCLIBC__) */ -#ifndef NULL -#define NULL 0 -#endif - /* Allocate INCREMENT more bytes of data space, and return the start of data space, or NULL on errors. If INCREMENT is negative, shrink data space. */ -__ptr_t -__default_morecore (increment) - __malloc_ptrdiff_t increment; +void * +__default_morecore (ptrdiff_t increment) { - __ptr_t result; + void *result; #if defined (CYGWIN) if (!bss_sbrk_did_unexec) { return bss_sbrk (increment); } #endif - result = (__ptr_t) __sbrk (increment); - if (result == (__ptr_t) -1) + result = (void *) __sbrk (increment); + if (result == (void *) -1) return NULL; return result; } @@ -1675,22 +1564,14 @@ License along with this library; see the file COPYING. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#ifndef _MALLOC_INTERNAL -#define _MALLOC_INTERNAL -#include <malloc.h> -#endif - -__ptr_t (*__memalign_hook) PP ((__malloc_size_t __size, - __malloc_size_t __alignment)); +void *(*__memalign_hook) (size_t size, size_t alignment); -__ptr_t -memalign (alignment, size) - __malloc_size_t alignment; - __malloc_size_t size; +void * +memalign (size_t alignment, size_t size) { - __ptr_t result; - unsigned long int adj, lastadj; - __ptr_t (*hook) (__malloc_size_t, __malloc_size_t) = __memalign_hook; + void *result; + size_t adj, lastadj; + void *(*hook) (size_t, size_t) = __memalign_hook; if (hook) return (*hook) (alignment, size); @@ -1703,7 +1584,7 @@ memalign (alignment, size) /* Figure out how much we will need to pad this particular block to achieve the required alignment. */ - adj = (unsigned long int) ((char *) result - (char *) NULL) % alignment; + adj = (uintptr_t) result % alignment; do { @@ -1714,7 +1595,7 @@ memalign (alignment, size) return NULL; lastadj = adj; - adj = (unsigned long int) ((char *) result - (char *) NULL) % alignment; + adj = (uintptr_t) result % alignment; /* It's conceivable we might have been so unlucky as to get a different block with weaker alignment. If so, this block is too short to contain SIZE after alignment correction. So we must @@ -1735,7 +1616,7 @@ memalign (alignment, size) break; if (l == NULL) { - l = (struct alignlist *) malloc (sizeof (struct alignlist)); + l = malloc (sizeof *l); if (l != NULL) { l->next = _aligned_blocks; @@ -1767,15 +1648,12 @@ memalign (alignment, size) #endif int -posix_memalign (memptr, alignment, size) - __ptr_t *memptr; - __malloc_size_t alignment; - __malloc_size_t size; +posix_memalign (void **memptr, size_t alignment, size_t size) { - __ptr_t mem; + void *mem; if (alignment == 0 - || alignment % sizeof (__ptr_t) != 0 + || alignment % sizeof (void *) != 0 || (alignment & (alignment - 1)) != 0) return EINVAL; @@ -1809,49 +1687,26 @@ Fifth Floor, Boston, MA 02110-1301, 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. */ -#if defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC) - -/* Emacs defines GMALLOC_INHIBIT_VALLOC to avoid this definition - on MSDOS, where it conflicts with a system header file. */ - -#define ELIDE_VALLOC - -#endif - -#ifndef ELIDE_VALLOC - -#if defined (__GNU_LIBRARY__) || defined (_LIBC) -#include <stddef.h> -#include <sys/cdefs.h> -#if defined (__GLIBC__) && __GLIBC__ >= 2 -/* __getpagesize is already declared in <unistd.h> with return type int */ -#else -extern size_t __getpagesize PP ((void)); -#endif -#else -#include "getpagesize.h" -#define __getpagesize() getpagesize () -#endif +/* Allocate SIZE bytes on a page boundary. */ +extern void *valloc (size_t); -#ifndef _MALLOC_INTERNAL -#define _MALLOC_INTERNAL -#include <malloc.h> +#if defined _SC_PAGESIZE || !defined HAVE_GETPAGESIZE +# include "getpagesize.h" +#elif !defined getpagesize +extern int getpagesize (void); #endif -static __malloc_size_t pagesize; +static size_t pagesize; -__ptr_t -valloc (size) - __malloc_size_t size; +void * +valloc (size_t size) { if (pagesize == 0) - pagesize = __getpagesize (); + pagesize = getpagesize (); return memalign (pagesize, size); } -#endif /* Not ELIDE_VALLOC. */ - #ifdef GC_MCHECK /* Standard debugging hooks for `malloc'. @@ -1876,41 +1731,31 @@ Fifth Floor, Boston, MA 02110-1301, 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. */ -#ifdef emacs -#include <stdio.h> -#else -#ifndef _MALLOC_INTERNAL -#define _MALLOC_INTERNAL -#include <malloc.h> #include <stdio.h> -#endif -#endif /* Old hook values. */ -static void (*old_free_hook) (__ptr_t ptr); -static __ptr_t (*old_malloc_hook) (__malloc_size_t size); -static __ptr_t (*old_realloc_hook) (__ptr_t ptr, __malloc_size_t size); +static void (*old_free_hook) (void *ptr); +static void *(*old_malloc_hook) (size_t size); +static void *(*old_realloc_hook) (void *ptr, size_t size); /* Function to call when something awful happens. */ static void (*abortfunc) (enum mcheck_status); /* Arbitrary magical numbers. */ -#define MAGICWORD 0xfedabeeb -#define MAGICFREE 0xd8675309 +#define MAGICWORD (SIZE_MAX / 11 ^ SIZE_MAX / 13 << 3) +#define MAGICFREE (SIZE_MAX / 17 ^ SIZE_MAX / 19 << 4) #define MAGICBYTE ((char) 0xd7) #define MALLOCFLOOD ((char) 0x93) #define FREEFLOOD ((char) 0x95) struct hdr { - __malloc_size_t size; /* Exact size requested by user. */ - unsigned long int magic; /* Magic number to check header integrity. */ + size_t size; /* Exact size requested by user. */ + size_t magic; /* Magic number to check header integrity. */ }; -static enum mcheck_status checkhdr (const struct hdr *); static enum mcheck_status -checkhdr (hdr) - const struct hdr *hdr; +checkhdr (const struct hdr *hdr) { enum mcheck_status status; switch (hdr->magic) @@ -1933,10 +1778,8 @@ checkhdr (hdr) return status; } -static void freehook (__ptr_t); static void -freehook (ptr) - __ptr_t ptr; +freehook (void *ptr) { struct hdr *hdr; @@ -1955,15 +1798,13 @@ freehook (ptr) __free_hook = freehook; } -static __ptr_t mallochook (__malloc_size_t); -static __ptr_t -mallochook (size) - __malloc_size_t size; +static void * +mallochook (size_t size) { struct hdr *hdr; __malloc_hook = old_malloc_hook; - hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1); + hdr = malloc (sizeof *hdr + size + 1); __malloc_hook = mallochook; if (hdr == NULL) return NULL; @@ -1971,18 +1812,15 @@ mallochook (size) hdr->size = size; hdr->magic = MAGICWORD; ((char *) &hdr[1])[size] = MAGICBYTE; - memset ((__ptr_t) (hdr + 1), MALLOCFLOOD, size); - return (__ptr_t) (hdr + 1); + memset (hdr + 1, MALLOCFLOOD, size); + return hdr + 1; } -static __ptr_t reallochook (__ptr_t, __malloc_size_t); -static __ptr_t -reallochook (ptr, size) - __ptr_t ptr; - __malloc_size_t size; +static void * +reallochook (void *ptr, size_t size) { struct hdr *hdr = NULL; - __malloc_size_t osize = 0; + size_t osize = 0; if (ptr) { @@ -1997,7 +1835,7 @@ reallochook (ptr, size) __free_hook = old_free_hook; __malloc_hook = old_malloc_hook; __realloc_hook = old_realloc_hook; - hdr = (struct hdr *) realloc ((__ptr_t) hdr, sizeof (struct hdr) + size + 1); + hdr = realloc (hdr, sizeof *hdr + size + 1); __free_hook = freehook; __malloc_hook = mallochook; __realloc_hook = reallochook; @@ -2009,12 +1847,11 @@ reallochook (ptr, size) ((char *) &hdr[1])[size] = MAGICBYTE; if (size > osize) memset ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize); - return (__ptr_t) (hdr + 1); + return hdr + 1; } static void -mabort (status) - enum mcheck_status status; +mabort (enum mcheck_status status) { const char *msg; switch (status) @@ -2047,8 +1884,7 @@ mabort (status) static int mcheck_used = 0; int -mcheck (func) - void (*func) (enum mcheck_status); +mcheck (void (*func) (enum mcheck_status)) { abortfunc = (func != NULL) ? func : &mabort; @@ -2068,7 +1904,7 @@ mcheck (func) } enum mcheck_status -mprobe (__ptr_t ptr) +mprobe (void *ptr) { return mcheck_used ? checkhdr (ptr) : MCHECK_DISABLED; } |