#define USE_PTHREAD
#endif
+#include <stddef.h>
#include <string.h>
#include <limits.h>
#include <stdint.h>
#include <w32heap.h> /* for sbrk */
#endif
+#ifdef emacs
+# include "lisp.h"
+#endif
+
+#ifdef HAVE_MALLOC_H
+# if 4 < __GNUC__ + (2 <= __GNUC_MINOR__)
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+# endif
+# include <malloc.h>
+#endif
+#ifndef __MALLOC_HOOK_VOLATILE
+# define __MALLOC_HOOK_VOLATILE volatile
+#endif
+#ifndef HAVE_MALLOC_H
+extern void (*__MALLOC_HOOK_VOLATILE __after_morecore_hook) (void);
+extern void (*__MALLOC_HOOK_VOLATILE __malloc_initialize_hook) (void);
+extern void *(*__morecore) (ptrdiff_t);
+extern void *__default_morecore (ptrdiff_t);
+#endif
+
/* If HYBRID_MALLOC is defined, then temacs will use malloc,
realloc... as defined in this file (and renamed gmalloc,
grealloc... via the macros that follow). The dumped emacs,
#undef free
#define malloc gmalloc
#define realloc grealloc
-#define calloc gcalloc
+#define calloc do_not_call_me /* Emacs never calls calloc. */
#define aligned_alloc galigned_alloc
#define free gfree
+#define malloc_info gmalloc_info
#ifdef HYBRID_MALLOC
# include "sheap.h"
{
#endif
-#include <stddef.h>
-
-/* Underlying allocation function; successive calls should
- return contiguous pieces of memory. */
-extern void *(*__morecore) (ptrdiff_t size);
-
-/* Default value of `__morecore'. */
-extern void *__default_morecore (ptrdiff_t size);
-
#ifdef HYBRID_MALLOC
#define extern static
#endif
/* Re-allocate the previously allocated block
in ptr, making the new block SIZE bytes long. */
extern void *realloc (void *ptr, size_t size) ATTRIBUTE_ALLOC_SIZE ((2));
-/* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */
-extern void *calloc (size_t nmemb, size_t size) ATTRIBUTE_MALLOC_SIZE ((1,2));
-/* Free a block allocated by `malloc', `realloc' or `calloc'. */
+/* Free a block. */
extern void free (void *ptr);
/* Allocate SIZE bytes allocated to ALIGNMENT bytes. */
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 (void);
-#endif
-
/* The allocator divides the heap into blocks of fixed size; large
requests receive one or more whole blocks, and small requests
receive a fragment of a block. Fragment sizes are powers of two,
#define UNLOCK_ALIGNED_BLOCKS()
#endif
-/* If not NULL, this function is called after each time
- `__morecore' is called to increase the data size. */
-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 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 (void);
-/* Hooks for debugging versions. */
-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);
-
#ifdef GC_MCHECK
/* Return values for `mprobe': these are the kinds of inconsistencies that
/* Pick up the current statistics. */
extern struct mstats mstats (void);
-/* Call WARNFUN with a warning message when memory usage is high. */
-extern void memory_warnings (void *start, void (*warnfun) (const char *));
-
#endif
#undef extern
#include <errno.h>
-void *(*__morecore) (ptrdiff_t size) = __default_morecore;
+/* Debugging hook for 'malloc'. */
+static void *(*__MALLOC_HOOK_VOLATILE gmalloc_hook) (size_t);
#ifndef HYBRID_MALLOC
-/* Debugging hook for `malloc'. */
-void *(*__malloc_hook) (size_t size);
-
/* Pointer to the base of the first block. */
char *_heapbase;
/* Are you experienced? */
int __malloc_initialized;
-size_t __malloc_extra_blocks;
-
-void (*__malloc_initialize_hook) (void);
-void (*__after_morecore_hook) (void);
+void (*__MALLOC_HOOK_VOLATILE __malloc_initialize_hook) (void);
+void (*__MALLOC_HOOK_VOLATILE __after_morecore_hook) (void);
+void *(*__morecore) (ptrdiff_t);
#else
#endif /* HYBRID_MALLOC */
+/* Number of extra blocks to get each time we ask for more core.
+ This reduces the frequency of calling `(*__morecore)'. */
+#if defined DOUG_LEA_MALLOC || defined HYBRID_MALLOC || defined SYSTEM_MALLOC
+static
+#endif
+size_t __malloc_extra_blocks;
+
/* Number of info entries. */
static size_t heapsize;
if (!__malloc_initialized && !__malloc_initialize ())
return NULL;
- /* Copy the value of __malloc_hook to an automatic variable in case
- __malloc_hook is modified in another thread between its
+ /* Copy the value of gmalloc_hook to an automatic variable in case
+ gmalloc_hook is modified in another thread between its
NULL-check and the use.
Note: Strictly speaking, this is not a right solution. We should
use mutexes to access non-read-only variables that are shared
among multiple threads. We just leave it for compatibility with
- glibc malloc (i.e., assignments to __malloc_hook) for now. */
- hook = __malloc_hook;
+ glibc malloc (i.e., assignments to gmalloc_hook) for now. */
+ hook = gmalloc_hook;
return (hook != NULL ? *hook : _malloc_internal) (size);
}
\f
The author may be reached (Email) at the address mike@ai.mit.edu,
or (US mail) as Mike Haertel c/o Free Software Foundation. */
+/* Debugging hook for free. */
+static void (*__MALLOC_HOOK_VOLATILE gfree_hook) (void *);
#ifndef HYBRID_MALLOC
-/* Debugging hook for free. */
-void (*__free_hook) (void *__ptr);
/* List of blocks allocated by aligned_alloc. */
struct alignlist *_aligned_blocks = NULL;
}
/* Return memory to the heap.
- Like `free' but don't call a __free_hook if there is one. */
+ Like 'free' but don't call a hook if there is one. */
void
_free_internal (void *ptr)
{
void
free (void *ptr)
{
- void (*hook) (void *) = __free_hook;
+ void (*hook) (void *) = gfree_hook;
if (hook != NULL)
(*hook) (ptr);
#define min(a, b) ((a) < (b) ? (a) : (b))
#endif
-#ifndef HYBRID_MALLOC
/* Debugging hook for realloc. */
-void *(*__realloc_hook) (void *ptr, size_t size);
-#endif
+static void *(*grealloc_hook) (void *, size_t);
/* Resize the given region to the new size, returning a pointer
to the (possibly moved) region. This is optimized for speed;
if (!__malloc_initialized && !__malloc_initialize ())
return NULL;
- hook = __realloc_hook;
+ hook = grealloc_hook;
return (hook != NULL ? *hook : _realloc_internal) (ptr, size);
}
/* Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc.
/* Allocate an array of NMEMB elements each SIZE bytes long.
The entire array is initialized to zeros. */
+#ifndef calloc
void *
calloc (size_t nmemb, size_t size)
{
return memset (result, 0, bytes);
return result;
}
+#endif
/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
This file is part of the GNU C Library.
return NULL;
return result;
}
+
+void *(*__morecore) (ptrdiff_t) = __default_morecore;
+
/* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
This library is free software; you can redistribute it and/or
You should have received a copy of the GNU General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>. */
-#ifndef HYBRID_MALLOC
-void *(*__memalign_hook) (size_t size, size_t alignment);
-#endif
-
void *
aligned_alloc (size_t alignment, size_t size)
{
void *result;
size_t adj, lastadj;
- void *(*hook) (size_t, size_t) = __memalign_hook;
-
- if (hook)
- return (*hook) (alignment, size);
/* Allocate a block with enough extra space to pad the block with up to
(ALIGNMENT - 1) bytes if necessary. */
/* Declare system malloc and friends. */
extern void *malloc (size_t size);
extern void *realloc (void *ptr, size_t size);
-extern void *calloc (size_t nmemb, size_t size);
extern void free (void *ptr);
#ifdef HAVE_ALIGNED_ALLOC
extern void *aligned_alloc (size_t alignment, size_t size);
return gmalloc (size);
}
-void *
-hybrid_calloc (size_t nmemb, size_t size)
-{
- if (DUMPED)
- return calloc (nmemb, size);
- return gcalloc (nmemb, size);
-}
-
void
hybrid_free (void *ptr)
{
else
hdr = NULL;
- __free_hook = old_free_hook;
+ gfree_hook = old_free_hook;
free (hdr);
- __free_hook = freehook;
+ gfree_hook = freehook;
}
static void *
{
struct hdr *hdr;
- __malloc_hook = old_malloc_hook;
+ gmalloc_hook = old_malloc_hook;
hdr = malloc (sizeof *hdr + size + 1);
- __malloc_hook = mallochook;
+ gmalloc_hook = mallochook;
if (hdr == NULL)
return NULL;
memset ((char *) ptr + size, FREEFLOOD, osize - size);
}
- __free_hook = old_free_hook;
- __malloc_hook = old_malloc_hook;
- __realloc_hook = old_realloc_hook;
+ gfree_hook = old_free_hook;
+ gmalloc_hook = old_malloc_hook;
+ grealloc_hook = old_realloc_hook;
hdr = realloc (hdr, sizeof *hdr + size + 1);
- __free_hook = freehook;
- __malloc_hook = mallochook;
- __realloc_hook = reallochook;
+ gfree_hook = freehook;
+ gmalloc_hook = mallochook;
+ grealloc_hook = reallochook;
if (hdr == NULL)
return NULL;
/* These hooks may not be safely inserted if malloc is already in use. */
if (!__malloc_initialized && !mcheck_used)
{
- old_free_hook = __free_hook;
- __free_hook = freehook;
- old_malloc_hook = __malloc_hook;
- __malloc_hook = mallochook;
- old_realloc_hook = __realloc_hook;
- __realloc_hook = reallochook;
+ old_free_hook = gfree_hook;
+ gfree_hook = freehook;
+ old_malloc_hook = gmalloc_hook;
+ gmalloc_hook = mallochook;
+ old_realloc_hook = grealloc_hook;
+ grealloc_hook = reallochook;
mcheck_used = 1;
}