X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/7be1c708c5abc7dea388d45454bd19bff07b7943..4458c2551b1a0bd89e5c299b009516e17f255c28:/src/gmalloc.c
diff --git a/src/gmalloc.c b/src/gmalloc.c
index 916bb300fe..8558169f7e 100644
--- a/src/gmalloc.c
+++ b/src/gmalloc.c
@@ -1,12 +1,6 @@
-/* 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.
+ Copyright (C) 1990-1993, 1995-1996, 1999, 2002-2007, 2013 Free
+ Software Foundation, Inc.
Written May 1989 by Mike Haertel.
This library is free software; you can redistribute it and/or
@@ -20,42 +14,29 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING. If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library. If not, see .
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
-#endif
#ifdef HAVE_PTHREAD
#define USE_PTHREAD
#endif
-#undef PP
-#define PP(args) args
-#undef __ptr_t
-#define __ptr_t void *
-
#include
#include
+#include
#include
#ifdef USE_PTHREAD
#include
#endif
-#endif /* _MALLOC_INTERNAL. */
-
+#ifdef WINDOWSNT
+#include /* for sbrk */
+#endif
#ifdef __cplusplus
extern "C"
@@ -63,46 +44,35 @@ extern "C"
#endif
#include
-#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,
and all fragments of a block are the same size. When all the
fragments in a block have been freed, the block itself is freed. */
-#define INT_BIT (CHAR_BIT * sizeof(int))
+#define INT_BIT (CHAR_BIT * sizeof (int))
#define BLOCKLOG (INT_BIT > 16 ? 12 : 9)
#define BLOCKSIZE (1 << BLOCKLOG)
#define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE)
@@ -128,22 +98,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 +125,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 +147,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 +198,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 +244,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.
@@ -338,28 +290,33 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING. If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library. If not, see .
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
-#endif
#include
-/* How to really get more memory. */
-#if defined(CYGWIN)
-extern __ptr_t bss_sbrk PP ((ptrdiff_t __size));
+/* On Cygwin there are two heaps. temacs uses the static heap
+ (defined in sheap.c and managed with bss_sbrk), and the dumped
+ emacs uses the Cygwin heap (managed with sbrk). When emacs starts
+ on Cygwin, it reinitializes malloc, and we save the old info for
+ use by free and realloc if they're called with a pointer into the
+ static heap.
+
+ Currently (2011-08-16) the Cygwin build doesn't use ralloc.c; if
+ this is changed in the future, we'll have to similarly deal with
+ reinitializing ralloc. */
+#ifdef CYGWIN
+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;
@@ -368,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
@@ -408,12 +365,11 @@ void (*__after_morecore_hook) PP ((void));
#include
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. */
@@ -434,7 +390,7 @@ protect_malloc_state (protect_p)
}
}
-#define PROTECT_MALLOC_STATE(PROT) protect_malloc_state(PROT)
+#define PROTECT_MALLOC_STATE(PROT) protect_malloc_state (PROT)
#else
#define PROTECT_MALLOC_STATE(PROT) /* empty */
@@ -442,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;
}
@@ -477,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,
@@ -511,10 +460,10 @@ get_contiguous_space (size, position)
/* This is called when `_heapinfo' and `heapsize' have just
been set to describe a new info table. Set up the table
to describe itself and account for it in the statistics. */
-static inline void
+static void
register_heapinfo (void)
{
- __malloc_size_t block, blocks;
+ size_t block, blocks;
block = BLOCK (_heapinfo);
blocks = BLOCKIFY (heapsize * sizeof (malloc_info));
@@ -537,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 ();
@@ -559,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;
@@ -578,17 +527,27 @@ malloc_enable_thread ()
#endif
static void
-malloc_initialize_1 ()
+malloc_initialize_1 (void)
{
#ifdef GC_MCHECK
mcheck (NULL);
#endif
+#ifdef CYGWIN
+ if (bss_sbrk_did_unexec)
+ /* we're reinitializing the dumped emacs */
+ {
+ bss_sbrk_heapbase = _heapbase;
+ bss_sbrk_heapinfo = _heapinfo;
+ memset (_fraghead, 0, BLOCKLOG * sizeof (struct list));
+ }
+#endif
+
if (__malloc_initialize_hook)
(*__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));
@@ -609,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;
@@ -623,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. */
@@ -643,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
@@ -652,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
@@ -668,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;
@@ -689,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)
@@ -700,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;
@@ -738,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
@@ -769,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;
@@ -782,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;
@@ -822,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;
@@ -856,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
@@ -938,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);
@@ -951,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;
@@ -977,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);
}
@@ -1015,21 +968,14 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING. If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library. If not, see .
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
-#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;
@@ -1037,15 +983,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;
@@ -1054,6 +999,12 @@ _free_internal_nolock (ptr)
if (ptr == NULL)
return;
+#ifdef CYGWIN
+ if ((char *) ptr < _heapbase)
+ /* We're being asked to free something in the static heap. */
+ return;
+#endif
+
PROTECT_MALLOC_STATE (0);
LOCK_ALIGNED_BLOCKS ();
@@ -1135,12 +1086,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
@@ -1163,7 +1114,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
@@ -1178,8 +1129,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;
@@ -1195,7 +1145,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
@@ -1228,7 +1178,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)
@@ -1253,7 +1203,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;
@@ -1266,11 +1216,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;
@@ -1286,8 +1235,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);
@@ -1297,10 +1245,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);
@@ -1313,8 +1260,7 @@ free (ptr)
weak_alias (free, cfree)
#else
void
-cfree (ptr)
- __ptr_t ptr;
+cfree (void *ptr)
{
free (ptr);
}
@@ -1334,23 +1280,40 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING. If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library. If not, see .
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
+#ifndef min
+#define min(A, B) ((A) < (B) ? (A) : (B))
#endif
+/* 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
+void *
+special_realloc (void *ptr, size_t size)
+{
+ void *result;
+ int type;
+ size_t block, oldsize;
-#define min(A, B) ((A) < (B) ? (A) : (B))
+ 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
+ : (size_t) 1 << type;
+ result = _malloc_internal_nolock (size);
+ if (result != NULL)
+ memcpy (result, ptr, min (oldsize, size));
+ return result;
+}
+#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;
@@ -1358,14 +1321,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)
{
@@ -1375,6 +1336,12 @@ _realloc_internal_nolock (ptr, size)
else if (ptr == NULL)
return _malloc_internal_nolock (size);
+#ifdef CYGWIN
+ if ((char *) ptr < _heapbase)
+ /* ptr points into the static heap */
+ return special_realloc (ptr, size);
+#endif
+
block = BLOCK (ptr);
PROTECT_MALLOC_STATE (0);
@@ -1439,7 +1406,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);
@@ -1454,8 +1421,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
@@ -1465,7 +1432,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;
@@ -1476,26 +1443,22 @@ _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();
+ LOCK ();
result = _realloc_internal_nolock (ptr, size);
UNLOCK ();
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;
@@ -1516,26 +1479,17 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING. If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library. If not, see .
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
-#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);
@@ -1556,47 +1510,34 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with 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
-#endif
+along with the GNU C Library. If not, see . */
/* uClibc defines __GNU_LIBRARY__, but it is not completely
compatible. */
-#if !defined(__GNU_LIBRARY__) || defined(__UCLIBC__)
+#if !defined (__GNU_LIBRARY__) || defined (__UCLIBC__)
#define __sbrk sbrk
#else /* __GNU_LIBRARY__ && ! defined (__UCLIBC__) */
/* It is best not to declare this and cast its result on foreign operating
systems with potentially hostile include files. */
-#include
-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;
-#if defined(CYGWIN)
+ 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;
}
@@ -1613,26 +1554,16 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
-License along with this 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
-#endif
+License along with this library. If not, see . */
-__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);
@@ -1645,7 +1576,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
{
@@ -1656,7 +1587,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
@@ -1677,7 +1608,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;
@@ -1709,15 +1640,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;
@@ -1744,56 +1672,31 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING. If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library. If not, see .
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
-#include
-#if defined (__GLIBC__) && __GLIBC__ >= 2
-/* __getpagesize is already declared in 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
+#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'.
@@ -1811,48 +1714,36 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING. If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library. If not, see .
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
-#else
-#ifndef _MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include
-#include
-#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)
@@ -1875,10 +1766,8 @@ checkhdr (hdr)
return status;
}
-static void freehook (__ptr_t);
static void
-freehook (ptr)
- __ptr_t ptr;
+freehook (void *ptr)
{
struct hdr *hdr;
@@ -1897,15 +1786,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;
@@ -1913,18 +1800,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)
{
@@ -1939,7 +1823,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;
@@ -1951,12 +1835,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)
@@ -1989,8 +1872,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;
@@ -2010,7 +1892,7 @@ mcheck (func)
}
enum mcheck_status
-mprobe (__ptr_t ptr)
+mprobe (void *ptr)
{
return mcheck_used ? checkhdr (ptr) : MCHECK_DISABLED;
}