sdl-ios-xcode: src/stdlib/SDL_malloc.c comparison

comparison src/stdlib/SDL_malloc.c @ 1895:c121d94672cb

SDL 1.2 is moving to a branch, and SDL 1.3 is becoming the head.

author	Sam Lantinga <slouken@libsdl.org>
date	Mon, 10 Jul 2006 21:04:37 +0000
parents	8dfa9a6d69a5
children	55e987d8e1b5

comparison

equal deleted inserted replaced

-:c69cee13dd76
+:c121d94672cb
 */
 #ifndef WIN32
 #ifdef _WIN32
 #define WIN32 1
-#endif  /* _WIN32 */
+#endif /* _WIN32 */
-#endif  /* WIN32 */
+#endif /* WIN32 */
 #ifdef WIN32
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #define HAVE_MMAP 1
 #define HAVE_MORECORE 0
 #define LACKS_SYS_MMAN_H
 #define LACKS_STRING_H
 #define LACKS_STRINGS_H
 #define LACKS_SYS_TYPES_H
 #define LACKS_ERRNO_H
 #define LACKS_FCNTL_H
 #define MALLOC_FAILURE_ACTION
-#define MMAP_CLEARS 0 /* WINCE and some others apparently don't clear */
+#define MMAP_CLEARS 0           /* WINCE and some others apparently don't clear */
-#endif  /* WIN32 */
+#endif /* WIN32 */
 #if defined(DARWIN) || defined(_DARWIN)
 /* Mac OSX docs advise not to use sbrk; it seems better to use mmap */
 #ifndef HAVE_MORECORE
 #define HAVE_MORECORE 0
 #define HAVE_MMAP 1
-#endif  /* HAVE_MORECORE */
+#endif /* HAVE_MORECORE */
-#endif  /* DARWIN */
+#endif /* DARWIN */
 #ifndef LACKS_SYS_TYPES_H
-#include <sys/types.h>  /* For size_t */
+#include <sys/types.h>          /* For size_t */
-#endif  /* LACKS_SYS_TYPES_H */
+#endif /* LACKS_SYS_TYPES_H */
 /* The maximum possible size_t value has all bits set */
 #define MAX_SIZE_T           (~(size_t)0)
 #ifndef ONLY_MSPACES
 #define ONLY_MSPACES 0
-#endif  /* ONLY_MSPACES */
+#endif /* ONLY_MSPACES */
 #ifndef MSPACES
 #if ONLY_MSPACES
 #define MSPACES 1
-#else   /* ONLY_MSPACES */
+#else /* ONLY_MSPACES */
 #define MSPACES 0
-#endif  /* ONLY_MSPACES */
+#endif /* ONLY_MSPACES */
-#endif  /* MSPACES */
+#endif /* MSPACES */
 #ifndef MALLOC_ALIGNMENT
 #define MALLOC_ALIGNMENT ((size_t)8U)
-#endif  /* MALLOC_ALIGNMENT */
+#endif /* MALLOC_ALIGNMENT */
 #ifndef FOOTERS
 #define FOOTERS 0
-#endif  /* FOOTERS */
+#endif /* FOOTERS */
 #ifndef ABORT
 #define ABORT  abort()
-#endif  /* ABORT */
+#endif /* ABORT */
 #ifndef ABORT_ON_ASSERT_FAILURE
 #define ABORT_ON_ASSERT_FAILURE 1
-#endif  /* ABORT_ON_ASSERT_FAILURE */
+#endif /* ABORT_ON_ASSERT_FAILURE */
 #ifndef PROCEED_ON_ERROR
 #define PROCEED_ON_ERROR 0
-#endif  /* PROCEED_ON_ERROR */
+#endif /* PROCEED_ON_ERROR */
 #ifndef USE_LOCKS
 #define USE_LOCKS 0
-#endif  /* USE_LOCKS */
+#endif /* USE_LOCKS */
 #ifndef INSECURE
 #define INSECURE 0
-#endif  /* INSECURE */
+#endif /* INSECURE */
 #ifndef HAVE_MMAP
 #define HAVE_MMAP 1
-#endif  /* HAVE_MMAP */
+#endif /* HAVE_MMAP */
 #ifndef MMAP_CLEARS
 #define MMAP_CLEARS 1
-#endif  /* MMAP_CLEARS */
+#endif /* MMAP_CLEARS */
 #ifndef HAVE_MREMAP
 #ifdef linux
 #define HAVE_MREMAP 1
-#else   /* linux */
+#else /* linux */
 #define HAVE_MREMAP 0
-#endif  /* linux */
+#endif /* linux */
-#endif  /* HAVE_MREMAP */
+#endif /* HAVE_MREMAP */
 #ifndef MALLOC_FAILURE_ACTION
 #define MALLOC_FAILURE_ACTION  errno = ENOMEM;
-#endif  /* MALLOC_FAILURE_ACTION */
+#endif /* MALLOC_FAILURE_ACTION */
 #ifndef HAVE_MORECORE
 #if ONLY_MSPACES
 #define HAVE_MORECORE 0
-#else   /* ONLY_MSPACES */
+#else /* ONLY_MSPACES */
 #define HAVE_MORECORE 1
-#endif  /* ONLY_MSPACES */
+#endif /* ONLY_MSPACES */
-#endif  /* HAVE_MORECORE */
+#endif /* HAVE_MORECORE */
 #if !HAVE_MORECORE
 #define MORECORE_CONTIGUOUS 0
-#else   /* !HAVE_MORECORE */
+#else /* !HAVE_MORECORE */
 #ifndef MORECORE
 #define MORECORE sbrk
-#endif  /* MORECORE */
+#endif /* MORECORE */
 #ifndef MORECORE_CONTIGUOUS
 #define MORECORE_CONTIGUOUS 1
-#endif  /* MORECORE_CONTIGUOUS */
+#endif /* MORECORE_CONTIGUOUS */
-#endif  /* HAVE_MORECORE */
+#endif /* HAVE_MORECORE */
 #ifndef DEFAULT_GRANULARITY
 #if MORECORE_CONTIGUOUS
-#define DEFAULT_GRANULARITY (0)  /* 0 means to compute in init_mparams */
+#define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */
-#else   /* MORECORE_CONTIGUOUS */
+#else /* MORECORE_CONTIGUOUS */
 #define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)
-#endif  /* MORECORE_CONTIGUOUS */
+#endif /* MORECORE_CONTIGUOUS */
-#endif  /* DEFAULT_GRANULARITY */
+#endif /* DEFAULT_GRANULARITY */
 #ifndef DEFAULT_TRIM_THRESHOLD
 #ifndef MORECORE_CANNOT_TRIM
 #define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)
-#else   /* MORECORE_CANNOT_TRIM */
+#else /* MORECORE_CANNOT_TRIM */
 #define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T
-#endif  /* MORECORE_CANNOT_TRIM */
+#endif /* MORECORE_CANNOT_TRIM */
-#endif  /* DEFAULT_TRIM_THRESHOLD */
+#endif /* DEFAULT_TRIM_THRESHOLD */
 #ifndef DEFAULT_MMAP_THRESHOLD
 #if HAVE_MMAP
 #define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)
-#else   /* HAVE_MMAP */
+#else /* HAVE_MMAP */
 #define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T
-#endif  /* HAVE_MMAP */
+#endif /* HAVE_MMAP */
-#endif  /* DEFAULT_MMAP_THRESHOLD */
+#endif /* DEFAULT_MMAP_THRESHOLD */
 #ifndef USE_BUILTIN_FFS
 #define USE_BUILTIN_FFS 0
-#endif  /* USE_BUILTIN_FFS */
+#endif /* USE_BUILTIN_FFS */
 #ifndef USE_DEV_RANDOM
 #define USE_DEV_RANDOM 0
-#endif  /* USE_DEV_RANDOM */
+#endif /* USE_DEV_RANDOM */
 #ifndef NO_MALLINFO
 #define NO_MALLINFO 0
-#endif  /* NO_MALLINFO */
+#endif /* NO_MALLINFO */
 #ifndef MALLINFO_FIELD_TYPE
 #define MALLINFO_FIELD_TYPE size_t
-#endif  /* MALLINFO_FIELD_TYPE */
+#endif /* MALLINFO_FIELD_TYPE */
 #define memset	SDL_memset
 #define memcpy	SDL_memcpy
 #define malloc	SDL_malloc
 #define calloc	SDL_calloc
 #ifdef HAVE_USR_INCLUDE_MALLOC_H
 #include "/usr/include/malloc.h"
 #else /* HAVE_USR_INCLUDE_MALLOC_H */
-struct mallinfo {
+struct mallinfo
-MALLINFO_FIELD_TYPE arena;    /* non-mmapped space allocated from system */
+{
-MALLINFO_FIELD_TYPE ordblks;  /* number of free chunks */
+MALLINFO_FIELD_TYPE arena;  /* non-mmapped space allocated from system */
-MALLINFO_FIELD_TYPE smblks;   /* always 0 */
+MALLINFO_FIELD_TYPE ordblks;        /* number of free chunks */
-MALLINFO_FIELD_TYPE hblks;    /* always 0 */
+MALLINFO_FIELD_TYPE smblks; /* always 0 */
-MALLINFO_FIELD_TYPE hblkhd;   /* space in mmapped regions */
+MALLINFO_FIELD_TYPE hblks;  /* always 0 */
-MALLINFO_FIELD_TYPE usmblks;  /* maximum total allocated space */
+MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */
-MALLINFO_FIELD_TYPE fsmblks;  /* always 0 */
+MALLINFO_FIELD_TYPE usmblks;        /* maximum total allocated space */
-MALLINFO_FIELD_TYPE uordblks; /* total allocated space */
+MALLINFO_FIELD_TYPE fsmblks;        /* always 0 */
-MALLINFO_FIELD_TYPE fordblks; /* total free space */
+MALLINFO_FIELD_TYPE uordblks;       /* total allocated space */
-MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */
+MALLINFO_FIELD_TYPE fordblks;       /* total free space */
+MALLINFO_FIELD_TYPE keepcost;       /* releasable (via malloc_trim) space */
 };
 #endif /* HAVE_USR_INCLUDE_MALLOC_H */
 #endif /* NO_MALLINFO */
 #ifdef __cplusplus
-extern "C" {
+extern "C"
-#endif /* __cplusplus */
+{
+#endif                          /* __cplusplus */
 #if !ONLY_MSPACES
 /* ------------------- Declarations of public routines ------------------- */
 #define dlmalloc_usable_size   malloc_usable_size
 #define dlmalloc_footprint     malloc_footprint
 #define dlmalloc_max_footprint malloc_max_footprint
 #define dlindependent_calloc   independent_calloc
 #define dlindependent_comalloc independent_comalloc
-#endif /* USE_DL_PREFIX */
+#endif                          /* USE_DL_PREFIX */
 /*
 malloc(size_t n)
 Returns a pointer to a newly allocated chunk of at least n bytes, or
 arguments that would be negative if signed are interpreted as
 requests for huge amounts of space, which will often fail. The
 maximum supported value of n differs across systems, but is in all
 cases less than the maximum representable value of a size_t.
 */
-void* dlmalloc(size_t);
+void *dlmalloc(size_t);
 /*
 free(void* p)
 Releases the chunk of memory pointed to by p, that had been previously
 allocated using malloc or a related routine such as realloc.
 It has no effect if p is null. If p was not malloced or already
 freed, free(p) will by default cause the current program to abort.
 */
-void  dlfree(void*);
+void dlfree(void *);
 /*
 calloc(size_t n_elements, size_t element_size);
 Returns a pointer to n_elements * element_size bytes, with all locations
 set to zero.
 */
-void* dlcalloc(size_t, size_t);
+void *dlcalloc(size_t, size_t);
 /*
 realloc(void* p, size_t n)
 Returns a pointer to a chunk of size n that contains the same data
 as does chunk p up to the minimum of (n, p's size) bytes, or null
 The old unix realloc convention of allowing the last-free'd chunk
 to be used as an argument to realloc is not supported.
 */
-void* dlrealloc(void*, size_t);
+void *dlrealloc(void *, size_t);
 /*
 memalign(size_t alignment, size_t n);
 Returns a pointer to a newly allocated chunk of n bytes, aligned
 in accord with the alignment argument.
 8-byte alignment is guaranteed by normal malloc calls, so don't
 bother calling memalign with an argument of 8 or less.
 Overreliance on memalign is a sure way to fragment space.
 */
-void* dlmemalign(size_t, size_t);
+void *dlmemalign(size_t, size_t);
 /*
 valloc(size_t n);
 Equivalent to memalign(pagesize, n), where pagesize is the page
 size of the system. If the pagesize is unknown, 4096 is used.
 */
-void* dlvalloc(size_t);
+void *dlvalloc(size_t);
 /*
 mallopt(int parameter_number, int parameter_value)
 Sets tunable parameters The format is to provide a
 (parameter-number, parameter-value) pair.  mallopt then sets the
 Symbol            param #  default    allowed param values
 M_TRIM_THRESHOLD     -1   2*1024*1024   any   (MAX_SIZE_T disables)
 M_GRANULARITY        -2     page size   any power of 2 >= page size
 M_MMAP_THRESHOLD     -3      256*1024   any   (or 0 if no MMAP support)
 */
 int dlmallopt(int, int);
 /*
 malloc_footprint();
 Returns the number of bytes obtained from the system.  The total
 number of bytes allocated by malloc, realloc etc., is less than this
 value. Unlike mallinfo, this function returns only a precomputed
 result, so can be called frequently to monitor memory consumption.
 Even if locks are otherwise defined, this function does not use them,
 so results might not be up to date.
 */
 size_t dlmalloc_footprint(void);
 /*
 malloc_max_footprint();
 Returns the maximum number of bytes obtained from the system. This
 value will be greater than current footprint if deallocated space
 this function returns only a precomputed result, so can be called
 frequently to monitor memory consumption.  Even if locks are
 otherwise defined, this function does not use them, so results might
 not be up to date.
 */
 size_t dlmalloc_max_footprint(void);
 #if !NO_MALLINFO
 /*
 mallinfo()
 Returns (by copy) a struct containing various summary statistics:
 Because these fields are ints, but internal bookkeeping may
 be kept as longs, the reported values may wrap around zero and
 thus be inaccurate.
 */
 struct mallinfo dlmallinfo(void);
-#endif /* NO_MALLINFO */
+#endif                          /* NO_MALLINFO */
 /*
 independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);
 independent_calloc is similar to calloc, but instead of returning a
 pool[i]->next = pool[i+1];
 free(pool);     // Can now free the array (or not, if it is needed later)
 return first;
 }
 */
-void** dlindependent_calloc(size_t, size_t, void**);
+void **dlindependent_calloc(size_t, size_t, void **);
 /*
 independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);
 independent_comalloc allocates, all at once, a set of n_elements
 Overuse of independent_comalloc can increase overall memory usage,
 since it cannot reuse existing noncontiguous small chunks that
 might be available for some of the elements.
 */
-void** dlindependent_comalloc(size_t, size_t*, void**);
+void **dlindependent_comalloc(size_t, size_t *, void **);
 /*
 pvalloc(size_t n);
 Equivalent to valloc(minimum-page-that-holds(n)), that is,
 round up n to nearest pagesize.
 */
-void*  dlpvalloc(size_t);
+void *dlpvalloc(size_t);
 /*
 malloc_trim(size_t pad);
 If possible, gives memory back to the system (via negative arguments
 trailing space to service future expected allocations without having
 to re-obtain memory from the system.
 Malloc_trim returns 1 if it actually released any memory, else 0.
 */
-int  dlmalloc_trim(size_t);
+int dlmalloc_trim(size_t);
 /*
 malloc_usable_size(void* p);
 Returns the number of bytes you can actually use in
 debugging and assertions, for example:
 p = malloc(n);
 assert(malloc_usable_size(p) >= 256);
 */
-size_t dlmalloc_usable_size(void*);
+size_t dlmalloc_usable_size(void *);
 /*
 malloc_stats();
 Prints on stderr the amount of space obtained from the system (both
 via sbrk and mmap), the maximum amount (which may be more than
 (normally sbrk) outside of malloc.
 malloc_stats prints only the most commonly interesting statistics.
 More information can be obtained by calling mallinfo.
 */
-void  dlmalloc_stats(void);
+void dlmalloc_stats(void);
-#endif /* ONLY_MSPACES */
+#endif                          /* ONLY_MSPACES */
 #if MSPACES
 /*
 mspace is an opaque type representing an independent
 region of space that supports mspace_malloc, etc.
 */
-typedef void* mspace;
+typedef void *mspace;
 /*
 create_mspace creates and returns a new independent space with the
 given initial capacity, or, if 0, the default granularity size.  It
 returns null if there is no system memory available to create the
 dynamically as needed to service mspace_malloc requests.  You can
 control the sizes of incremental increases of this space by
 compiling with a different DEFAULT_GRANULARITY or dynamically
 setting with mallopt(M_GRANULARITY, value).
 */
 mspace create_mspace(size_t capacity, int locked);
 /*
 destroy_mspace destroys the given space, and attempts to return all
 of its memory back to the system, returning the total number of
 bytes freed. After destruction, the results of access to all memory
 used by the space become undefined.
 */
 size_t destroy_mspace(mspace msp);
 /*
 create_mspace_with_base uses the memory supplied as the initial base
 of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this
 space is used for bookkeeping, so the capacity must be at least this
 large. (Otherwise 0 is returned.) When this initial space is
 exhausted, additional memory will be obtained from the system.
 Destroying this space will deallocate all additionally allocated
 space (if possible) but not the initial base.
 */
-mspace create_mspace_with_base(void* base, size_t capacity, int locked);
+mspace create_mspace_with_base(void *base, size_t capacity, int locked);
 /*
 mspace_malloc behaves as malloc, but operates within
 the given space.
 */
-void* mspace_malloc(mspace msp, size_t bytes);
+void *mspace_malloc(mspace msp, size_t bytes);
 /*
 mspace_free behaves as free, but operates within
 the given space.
 If compiled with FOOTERS==1, mspace_free is not actually needed.
 free may be called instead of mspace_free because freed chunks from
 any space are handled by their originating spaces.
 */
-void mspace_free(mspace msp, void* mem);
+void mspace_free(mspace msp, void *mem);
 /*
 mspace_realloc behaves as realloc, but operates within
 the given space.
 If compiled with FOOTERS==1, mspace_realloc is not actually
 needed.  realloc may be called instead of mspace_realloc because
 realloced chunks from any space are handled by their originating
 spaces.
 */
-void* mspace_realloc(mspace msp, void* mem, size_t newsize);
+void *mspace_realloc(mspace msp, void *mem, size_t newsize);
 /*
 mspace_calloc behaves as calloc, but operates within
 the given space.
 */
-void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
+void *mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
 /*
 mspace_memalign behaves as memalign, but operates within
 the given space.
 */
-void* mspace_memalign(mspace msp, size_t alignment, size_t bytes);
+void *mspace_memalign(mspace msp, size_t alignment, size_t bytes);
 /*
 mspace_independent_calloc behaves as independent_calloc, but
 operates within the given space.
 */
-void** mspace_independent_calloc(mspace msp, size_t n_elements,
+void **mspace_independent_calloc(mspace msp, size_t n_elements,
-size_t elem_size, void* chunks[]);
+size_t elem_size, void *chunks[]);
 /*
 mspace_independent_comalloc behaves as independent_comalloc, but
 operates within the given space.
 */
-void** mspace_independent_comalloc(mspace msp, size_t n_elements,
+void **mspace_independent_comalloc(mspace msp, size_t n_elements,
-size_t sizes[], void* chunks[]);
+size_t sizes[], void *chunks[]);
 /*
 mspace_footprint() returns the number of bytes obtained from the
 system for this space.
 */
 size_t mspace_footprint(mspace msp);
 /*
 mspace_max_footprint() returns the peak number of bytes obtained from the
 system for this space.
 */
 size_t mspace_max_footprint(mspace msp);
 #if !NO_MALLINFO
 /*
 mspace_mallinfo behaves as mallinfo, but reports properties of
 the given space.
 */
 struct mallinfo mspace_mallinfo(mspace msp);
-#endif /* NO_MALLINFO */
+#endif                          /* NO_MALLINFO */
 /*
 mspace_malloc_stats behaves as malloc_stats, but reports
 properties of the given space.
 */
 void mspace_malloc_stats(mspace msp);
 /*
 mspace_trim behaves as malloc_trim, but
 operates within the given space.
 */
 int mspace_trim(mspace msp, size_t pad);
 /*
 An alias for mallopt.
 */
 int mspace_mallopt(int, int);
-#endif /* MSPACES */
+#endif                          /* MSPACES */
 #ifdef __cplusplus
-};  /* end of extern "C" */
+};                              /* end of extern "C" */
 #endif /* __cplusplus */
 /*
 ========================================================================
 To make a fully customizable malloc.h header file, cut everything
 /* #include "malloc.h" */
 /*------------------------------ internal #includes ---------------------- */
 #ifdef _MSC_VER
-#pragma warning( disable : 4146 ) /* no "unsigned" warnings */
+#pragma warning( disable : 4146 )       /* no "unsigned" warnings */
 #endif /* _MSC_VER */
 #ifndef LACKS_STDIO_H
-#include <stdio.h>       /* for printing in malloc_stats */
+#include <stdio.h>              /* for printing in malloc_stats */
 #endif
 #ifndef LACKS_ERRNO_H
-#include <errno.h>       /* for MALLOC_FAILURE_ACTION */
+#include <errno.h>              /* for MALLOC_FAILURE_ACTION */
 #endif /* LACKS_ERRNO_H */
 #if FOOTERS
-#include <time.h>        /* for magic initialization */
+#include <time.h>               /* for magic initialization */
 #endif /* FOOTERS */
 #ifndef LACKS_STDLIB_H
-#include <stdlib.h>      /* for abort() */
+#include <stdlib.h>             /* for abort() */
 #endif /* LACKS_STDLIB_H */
 #ifdef DEBUG
 #if ABORT_ON_ASSERT_FAILURE
 #define assert(x) if(!(x)) ABORT
 #else /* ABORT_ON_ASSERT_FAILURE */
 #include <assert.h>
 #endif /* ABORT_ON_ASSERT_FAILURE */
-#else  /* DEBUG */
+#else /* DEBUG */
 #define assert(x)
 #endif /* DEBUG */
 #ifndef LACKS_STRING_H
-#include <string.h>      /* for memset etc */
+#include <string.h>             /* for memset etc */
-#endif  /* LACKS_STRING_H */
+#endif /* LACKS_STRING_H */
 #if USE_BUILTIN_FFS
 #ifndef LACKS_STRINGS_H
-#include <strings.h>     /* for ffs */
+#include <strings.h>            /* for ffs */
 #endif /* LACKS_STRINGS_H */
 #endif /* USE_BUILTIN_FFS */
 #if HAVE_MMAP
 #ifndef LACKS_SYS_MMAN_H
-#include <sys/mman.h>    /* for mmap */
+#include <sys/mman.h>           /* for mmap */
 #endif /* LACKS_SYS_MMAN_H */
 #ifndef LACKS_FCNTL_H
 #include <fcntl.h>
 #endif /* LACKS_FCNTL_H */
 #endif /* HAVE_MMAP */
 #if HAVE_MORECORE
 #ifndef LACKS_UNISTD_H
-#include <unistd.h>     /* for sbrk */
+#include <unistd.h>             /* for sbrk */
 #else /* LACKS_UNISTD_H */
 #if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
-extern void*     sbrk(ptrdiff_t);
+extern void *sbrk(ptrdiff_t);
 #endif /* FreeBSD etc */
 #endif /* LACKS_UNISTD_H */
 #endif /* HAVE_MMAP */
 #ifndef WIN32
 #ifndef malloc_getpagesize
-#  ifdef _SC_PAGESIZE         /* some SVR4 systems omit an underscore */
+#  ifdef _SC_PAGESIZE           /* some SVR4 systems omit an underscore */
 #    ifndef _SC_PAGE_SIZE
 #      define _SC_PAGE_SIZE _SC_PAGESIZE
 #    endif
 #  endif
 #  ifdef _SC_PAGE_SIZE
 #    define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
 #  else
 #    if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
 extern size_t getpagesize();
 #      define malloc_getpagesize getpagesize()
 #    else
-#      ifdef WIN32 /* use supplied emulation of getpagesize */
+#      ifdef WIN32              /* use supplied emulation of getpagesize */
 #        define malloc_getpagesize getpagesize()
 #      else
 #        ifndef LACKS_SYS_PARAM_H
 #          include <sys/param.h>
 #        endif
 */
 /* MORECORE and MMAP must return MFAIL on failure */
 #define MFAIL                ((void*)(MAX_SIZE_T))
-#define CMFAIL               ((char*)(MFAIL)) /* defined for convenience */
+#define CMFAIL               ((char*)(MFAIL))   /* defined for convenience */
 #if !HAVE_MMAP
 #define IS_MMAPPED_BIT       (SIZE_T_ZERO)
 #define USE_MMAP_BIT         (SIZE_T_ZERO)
 #define CALL_MMAP(s)         MFAIL
 /*
 Nearly all versions of mmap support MAP_ANONYMOUS, so the following
 is unlikely to be needed, but is supplied just in case.
 */
 #define MMAP_FLAGS           (MAP_PRIVATE)
-static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
+static int dev_zero_fd = -1;    /* Cached file descriptor for /dev/zero. */
 #define CALL_MMAP(s) ((dev_zero_fd < 0) ? \
 (dev_zero_fd = open("/dev/zero", O_RDWR), \
 mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \
 mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0))
 #endif /* MAP_ANONYMOUS */
 #define DIRECT_MMAP(s)       CALL_MMAP(s)
 #else /* WIN32 */
 /* Win32 MMAP via VirtualAlloc */
-static void* win32mmap(size_t size) {
+static void *
-void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
+win32mmap(size_t size)
-return (ptr != 0)? ptr: MFAIL;
+{
+void *ptr =
+VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+return (ptr != 0) ? ptr : MFAIL;
 }
 /* For direct MMAP, use MEM_TOP_DOWN to minimize interference */
-static void* win32direct_mmap(size_t size) {
+static void *
-void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
+win32direct_mmap(size_t size)
-PAGE_READWRITE);
+{
-return (ptr != 0)? ptr: MFAIL;
+void *ptr = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
+PAGE_READWRITE);
+return (ptr != 0) ? ptr : MFAIL;
 }
 /* This function supports releasing coalesed segments */
-static int win32munmap(void* ptr, size_t size) {
+static int
-MEMORY_BASIC_INFORMATION minfo;
+win32munmap(void *ptr, size_t size)
-char* cptr = ptr;
+{
-while (size) {
+MEMORY_BASIC_INFORMATION minfo;
-if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
+char *cptr = ptr;
-return -1;
+while (size) {
-if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
+if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
-minfo.State != MEM_COMMIT || minfo.RegionSize > size)
+return -1;
-return -1;
+if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
-if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
+minfo.State != MEM_COMMIT || minfo.RegionSize > size)
 return -1;
-cptr += minfo.RegionSize;
+if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
-size -= minfo.RegionSize;
+return -1;
-}
+cptr += minfo.RegionSize;
-return 0;
+size -= minfo.RegionSize;
+}
+return 0;
 }
 #define CALL_MMAP(s)         win32mmap(s)
 #define CALL_MUNMAP(a, s)    win32munmap((a), (s))
 #define DIRECT_MMAP(s)       win32direct_mmap(s)
 #endif /* WIN32 */
 #endif /* HAVE_MMAP */
 #if HAVE_MMAP && HAVE_MREMAP
 #define CALL_MREMAP(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv))
-#else  /* HAVE_MMAP && HAVE_MREMAP */
+#else /* HAVE_MMAP && HAVE_MREMAP */
 #define CALL_MREMAP(addr, osz, nsz, mv) MFAIL
 #endif /* HAVE_MMAP && HAVE_MREMAP */
 #if HAVE_MORECORE
 #define CALL_MORECORE(S)     MORECORE(S)
-#else  /* HAVE_MORECORE */
+#else /* HAVE_MORECORE */
 #define CALL_MORECORE(S)     MFAIL
 #endif /* HAVE_MORECORE */
 /* mstate bit set if continguous morecore disabled or failed */
 #define USE_NONCONTIGUOUS_BIT (4U)
 Because lock-protected regions have bounded times, and there
 are no recursive lock calls, we can use simple spinlocks.
 */
 #define MLOCK_T long
-static int win32_acquire_lock (MLOCK_T *sl) {
+static int
-for (;;) {
+win32_acquire_lock(MLOCK_T * sl)
+{
+for (;;) {
 #ifdef InterlockedCompareExchangePointer
 if (!InterlockedCompareExchange(sl, 1, 0))
 return 0;
-#else  /* Use older void* version */
+#else /* Use older void* version */
-if (!InterlockedCompareExchange((void**)sl, (void*)1, (void*)0))
+if (!InterlockedCompareExchange((void **) sl, (void *) 1, (void *) 0))
 return 0;
 #endif /* InterlockedCompareExchangePointer */
-Sleep (0);
+Sleep(0);
 }
 }
-static void win32_release_lock (MLOCK_T *sl) {
+static void
-InterlockedExchange (sl, 0);
+win32_release_lock(MLOCK_T * sl)
+{
+InterlockedExchange(sl, 0);
 }
 #define INITIAL_LOCK(l)      *(l)=0
 #define ACQUIRE_LOCK(l)      win32_acquire_lock(l)
 #define RELEASE_LOCK(l)      win32_release_lock(l)
 #endif /* HAVE_MORECORE */
 static MLOCK_T magic_init_mutex;
 #endif /* WIN32 */
 #define USE_LOCK_BIT               (2U)
-#else  /* USE_LOCKS */
+#else /* USE_LOCKS */
 #define USE_LOCK_BIT               (0U)
 #define INITIAL_LOCK(l)
 #endif /* USE_LOCKS */
 #if USE_LOCKS && HAVE_MORECORE
 #endif /* USE_LOCKS && HAVE_MORECORE */
 #if USE_LOCKS
 #define ACQUIRE_MAGIC_INIT_LOCK()  ACQUIRE_LOCK(&magic_init_mutex);
 #define RELEASE_MAGIC_INIT_LOCK()  RELEASE_LOCK(&magic_init_mutex);
-#else  /* USE_LOCKS */
+#else /* USE_LOCKS */
 #define ACQUIRE_MAGIC_INIT_LOCK()
 #define RELEASE_MAGIC_INIT_LOCK()
 #endif /* USE_LOCKS */
 chunk is trailed by the first two fields of a fake next-chunk
 for sake of usage checks.
 */
-struct malloc_chunk {
+struct malloc_chunk
-size_t               prev_foot;  /* Size of previous chunk (if free).  */
+{
-size_t               head;       /* Size and inuse bits. */
+size_t prev_foot;           /* Size of previous chunk (if free).  */
-struct malloc_chunk* fd;         /* double links -- used only if free. */
+size_t head;                /* Size and inuse bits. */
-struct malloc_chunk* bk;
+struct malloc_chunk *fd;    /* double links -- used only if free. */
+struct malloc_chunk *bk;
 };
-typedef struct malloc_chunk  mchunk;
+typedef struct malloc_chunk mchunk;
-typedef struct malloc_chunk* mchunkptr;
+typedef struct malloc_chunk *mchunkptr;
-typedef struct malloc_chunk* sbinptr;  /* The type of bins of chunks */
+typedef struct malloc_chunk *sbinptr;   /* The type of bins of chunks */
-typedef size_t bindex_t;               /* Described below */
+typedef size_t bindex_t;        /* Described below */
-typedef unsigned int binmap_t;         /* Described below */
+typedef unsigned int binmap_t;  /* Described below */
-typedef unsigned int flag_t;           /* The type of various bit flag sets */
+typedef unsigned int flag_t;    /* The type of various bit flag sets */
 /* ------------------- Chunks sizes and alignments ----------------------- */
 #define MCHUNK_SIZE         (sizeof(mchunk))
 bins. Under current bin calculations, this ranges from 6 up to 21
 (for 32 bit sizes) or up to 53 (for 64 bit sizes). The typical case
 is of course much better.
 */
-struct malloc_tree_chunk {
+struct malloc_tree_chunk
-/* The first four fields must be compatible with malloc_chunk */
+{
-size_t                    prev_foot;
+/* The first four fields must be compatible with malloc_chunk */
-size_t                    head;
+size_t prev_foot;
-struct malloc_tree_chunk* fd;
+size_t head;
-struct malloc_tree_chunk* bk;
+struct malloc_tree_chunk *fd;
+struct malloc_tree_chunk *bk;
-struct malloc_tree_chunk* child[2];
-struct malloc_tree_chunk* parent;
+struct malloc_tree_chunk *child[2];
-bindex_t                  index;
+struct malloc_tree_chunk *parent;
+bindex_t index;
 };
-typedef struct malloc_tree_chunk  tchunk;
+typedef struct malloc_tree_chunk tchunk;
-typedef struct malloc_tree_chunk* tchunkptr;
+typedef struct malloc_tree_chunk *tchunkptr;
-typedef struct malloc_tree_chunk* tbinptr; /* The type of bins of trees */
+typedef struct malloc_tree_chunk *tbinptr;      /* The type of bins of trees */
 /* A little helper macro for trees */
 #define leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])
 /* ----------------------------- Segments -------------------------------- */
 * If neither bit is set, then the segment was obtained using
 MORECORE so can be merged with surrounding MORECORE'd segments
 and deallocated/trimmed using MORECORE with negative arguments.
 */
-struct malloc_segment {
+struct malloc_segment
-char*        base;             /* base address */
+{
-size_t       size;             /* allocated size */
+char *base;                 /* base address */
-struct malloc_segment* next;   /* ptr to next segment */
+size_t size;                /* allocated size */
-flag_t       sflags;           /* mmap and extern flag */
+struct malloc_segment *next;        /* ptr to next segment */
+flag_t sflags;              /* mmap and extern flag */
 };
 #define is_mmapped_segment(S)  ((S)->sflags & IS_MMAPPED_BIT)
 #define is_extern_segment(S)   ((S)->sflags & EXTERN_BIT)
-typedef struct malloc_segment  msegment;
+typedef struct malloc_segment msegment;
-typedef struct malloc_segment* msegmentptr;
+typedef struct malloc_segment *msegmentptr;
 /* ---------------------------- malloc_state ----------------------------- */
 /*
 A malloc_state holds all of the bookkeeping for a space.
 #define TREEBIN_SHIFT     (8U)
 #define MIN_LARGE_SIZE    (SIZE_T_ONE << TREEBIN_SHIFT)
 #define MAX_SMALL_SIZE    (MIN_LARGE_SIZE - SIZE_T_ONE)
 #define MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)
-struct malloc_state {
+struct malloc_state
-binmap_t   smallmap;
+{
-binmap_t   treemap;
+binmap_t smallmap;
-size_t     dvsize;
+binmap_t treemap;
-size_t     topsize;
+size_t dvsize;
-char*      least_addr;
+size_t topsize;
-mchunkptr  dv;
+char *least_addr;
-mchunkptr  top;
+mchunkptr dv;
-size_t     trim_check;
+mchunkptr top;
-size_t     magic;
+size_t trim_check;
-mchunkptr  smallbins[(NSMALLBINS+1)*2];
+size_t magic;
-tbinptr    treebins[NTREEBINS];
+mchunkptr smallbins[(NSMALLBINS + 1) * 2];
-size_t     footprint;
+tbinptr treebins[NTREEBINS];
-size_t     max_footprint;
+size_t footprint;
-flag_t     mflags;
+size_t max_footprint;
+flag_t mflags;
 #if USE_LOCKS
-MLOCK_T    mutex;     /* locate lock among fields that rarely change */
+MLOCK_T mutex;              /* locate lock among fields that rarely change */
-#endif /* USE_LOCKS */
+#endif                          /* USE_LOCKS */
-msegment   seg;
+msegment seg;
 };
-typedef struct malloc_state*    mstate;
+typedef struct malloc_state *mstate;
 /* ------------- Global malloc_state and malloc_params ------------------- */
 /*
 malloc_params holds global properties, including those that can be
 dynamically set using mallopt. There is a single instance, mparams,
 initialized in init_mparams.
 */
-struct malloc_params {
+struct malloc_params
-size_t magic;
+{
-size_t page_size;
+size_t magic;
-size_t granularity;
+size_t page_size;
-size_t mmap_threshold;
+size_t granularity;
-size_t trim_threshold;
+size_t mmap_threshold;
-flag_t default_mflags;
+size_t trim_threshold;
+flag_t default_mflags;
 };
 static struct malloc_params mparams;
 /* The global malloc_state used for all non-"mspace" calls */
 /*  True if segment S holds address A */
 #define segment_holds(S, A)\
 ((char*)(A) >= S->base && (char*)(A) < S->base + S->size)
 /* Return segment holding given address */
-static msegmentptr segment_holding(mstate m, char* addr) {
+static msegmentptr
-msegmentptr sp = &m->seg;
+segment_holding(mstate m, char *addr)
-for (;;) {
+{
-if (addr >= sp->base && addr < sp->base + sp->size)
+msegmentptr sp = &m->seg;
-return sp;
+for (;;) {
-if ((sp = sp->next) == 0)
+if (addr >= sp->base && addr < sp->base + sp->size)
-return 0;
+return sp;
-}
+if ((sp = sp->next) == 0)
+return 0;
+}
 }
 /* Return true if segment contains a segment link */
-static int has_segment_link(mstate m, msegmentptr ss) {
+static int
-msegmentptr sp = &m->seg;
+has_segment_link(mstate m, msegmentptr ss)
-for (;;) {
+{
-if ((char*)sp >= ss->base && (char*)sp < ss->base + ss->size)
+msegmentptr sp = &m->seg;
-return 1;
+for (;;) {
-if ((sp = sp->next) == 0)
+if ((char *) sp >= ss->base && (char *) sp < ss->base + ss->size)
-return 0;
+return 1;
-}
+if ((sp = sp->next) == 0)
+return 0;
+}
 }
 #ifndef MORECORE_CANNOT_TRIM
 #define should_trim(M,s)  ((s) > (M)->trim_check)
-#else  /* MORECORE_CANNOT_TRIM */
+#else /* MORECORE_CANNOT_TRIM */
 #define should_trim(M,s)  (0)
 #endif /* MORECORE_CANNOT_TRIM */
 /*
 TOP_FOOT_SIZE is padding at the end of a segment, including space
 #define POSTACTION(M) { if (use_lock(M)) RELEASE_LOCK(&(M)->mutex); }
 #else /* USE_LOCKS */
 #ifndef PREACTION
 #define PREACTION(M) (0)
-#endif  /* PREACTION */
+#endif /* PREACTION */
 #ifndef POSTACTION
 #define POSTACTION(M)
-#endif  /* POSTACTION */
+#endif /* POSTACTION */
 #endif /* USE_LOCKS */
 /*
 CORRUPTION_ERROR_ACTION is triggered upon detected bad addresses.
 #define check_top_chunk(M,P)        do_check_top_chunk(M,P)
 #define check_malloced_chunk(M,P,N) do_check_malloced_chunk(M,P,N)
 #define check_mmapped_chunk(M,P)    do_check_mmapped_chunk(M,P)
 #define check_malloc_state(M)       do_check_malloc_state(M)
-static void   do_check_any_chunk(mstate m, mchunkptr p);
+static void do_check_any_chunk(mstate m, mchunkptr p);
-static void   do_check_top_chunk(mstate m, mchunkptr p);
+static void do_check_top_chunk(mstate m, mchunkptr p);
-static void   do_check_mmapped_chunk(mstate m, mchunkptr p);
+static void do_check_mmapped_chunk(mstate m, mchunkptr p);
-static void   do_check_inuse_chunk(mstate m, mchunkptr p);
+static void do_check_inuse_chunk(mstate m, mchunkptr p);
-static void   do_check_free_chunk(mstate m, mchunkptr p);
+static void do_check_free_chunk(mstate m, mchunkptr p);
-static void   do_check_malloced_chunk(mstate m, void* mem, size_t s);
+static void do_check_malloced_chunk(mstate m, void *mem, size_t s);
-static void   do_check_tree(mstate m, tchunkptr t);
+static void do_check_tree(mstate m, tchunkptr t);
-static void   do_check_treebin(mstate m, bindex_t i);
+static void do_check_treebin(mstate m, bindex_t i);
-static void   do_check_smallbin(mstate m, bindex_t i);
+static void do_check_smallbin(mstate m, bindex_t i);
-static void   do_check_malloc_state(mstate m);
+static void do_check_malloc_state(mstate m);
-static int    bin_find(mstate m, mchunkptr x);
+static int bin_find(mstate m, mchunkptr x);
 static size_t traverse_and_check(mstate m);
 #endif /* DEBUG */
 /* ---------------------------- Indexing Bins ---------------------------- */
 #endif /* !INSECURE */
 #if (FOOTERS && !INSECURE)
 /* Check if (alleged) mstate m has expected magic field */
 #define ok_magic(M)      ((M)->magic == mparams.magic)
-#else  /* (FOOTERS && !INSECURE) */
+#else /* (FOOTERS && !INSECURE) */
 #define ok_magic(M)      (1)
 #endif /* (FOOTERS && !INSECURE) */
 /* In gcc, use __builtin_expect to minimize impact of checks */
 #endif /* !FOOTERS */
 /* ---------------------------- setting mparams -------------------------- */
 /* Initialize mparams */
-static int init_mparams(void) {
+static int
-if (mparams.page_size == 0) {
+init_mparams(void)
-size_t s;
+{
+if (mparams.page_size == 0) {
-mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
+size_t s;
-mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD;
+mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
+mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD;
 #if MORECORE_CONTIGUOUS
-mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT;
+mparams.default_mflags = USE_LOCK_BIT | USE_MMAP_BIT;
-#else  /* MORECORE_CONTIGUOUS */
+#else /* MORECORE_CONTIGUOUS */
-mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT|USE_NONCONTIGUOUS_BIT;
+mparams.default_mflags =
+USE_LOCK_BIT | USE_MMAP_BIT | USE_NONCONTIGUOUS_BIT;
 #endif /* MORECORE_CONTIGUOUS */
 #if (FOOTERS && !INSECURE)
 {
 #if USE_DEV_RANDOM
 int fd;
 unsigned char buf[sizeof(size_t)];
 /* Try to use /dev/urandom, else fall back on using time */
 if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 &&
 read(fd, buf, sizeof(buf)) == sizeof(buf)) {
 s = *((size_t *) buf);
 close(fd);
-}
+} else
-else
 #endif /* USE_DEV_RANDOM */
-s = (size_t)(time(0) ^ (size_t)0x55555555U);
+s = (size_t) (time(0) ^ (size_t) 0x55555555U);
-s |= (size_t)8U;    /* ensure nonzero */
+s |= (size_t) 8U;   /* ensure nonzero */
-s &= ~(size_t)7U;   /* improve chances of fault for bad values */
+s &= ~(size_t) 7U;  /* improve chances of fault for bad values */
 }
 #else /* (FOOTERS && !INSECURE) */
-s = (size_t)0x58585858U;
+s = (size_t) 0x58585858U;
 #endif /* (FOOTERS && !INSECURE) */
 ACQUIRE_MAGIC_INIT_LOCK();
 if (mparams.magic == 0) {
 mparams.magic = s;
 /* Set up lock for main malloc area */
 INITIAL_LOCK(&gm->mutex);
 gm->mflags = mparams.default_mflags;
 }
 RELEASE_MAGIC_INIT_LOCK();
 #ifndef WIN32
 mparams.page_size = malloc_getpagesize;
-mparams.granularity = ((DEFAULT_GRANULARITY != 0)?
+mparams.granularity = ((DEFAULT_GRANULARITY != 0) ?
 DEFAULT_GRANULARITY : mparams.page_size);
 #else /* WIN32 */
 {
 SYSTEM_INFO system_info;
 GetSystemInfo(&system_info);
 mparams.page_size = system_info.dwPageSize;
 mparams.granularity = system_info.dwAllocationGranularity;
 }
 #endif /* WIN32 */
 /* Sanity-check configuration:
 size_t must be unsigned and as wide as pointer type.
 ints must be at least 4 bytes.
 alignment must be at least 8.
 Alignment, min chunk size, and page size must all be powers of 2.
 */
-if ((sizeof(size_t) != sizeof(char*)) ||
+if ((sizeof(size_t) != sizeof(char *)) ||
-(MAX_SIZE_T < MIN_CHUNK_SIZE)  ||
+(MAX_SIZE_T < MIN_CHUNK_SIZE) ||
-(sizeof(int) < 4)  ||
+(sizeof(int) < 4) ||
-(MALLOC_ALIGNMENT < (size_t)8U) ||
+(MALLOC_ALIGNMENT < (size_t) 8U) ||
-((MALLOC_ALIGNMENT    & (MALLOC_ALIGNMENT-SIZE_T_ONE))    != 0) ||
+((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT - SIZE_T_ONE)) != 0) ||
-((MCHUNK_SIZE         & (MCHUNK_SIZE-SIZE_T_ONE))         != 0) ||
+((MCHUNK_SIZE & (MCHUNK_SIZE - SIZE_T_ONE)) != 0) ||
-((mparams.granularity & (mparams.granularity-SIZE_T_ONE)) != 0) ||
+((mparams.granularity & (mparams.granularity - SIZE_T_ONE)) != 0)
-((mparams.page_size   & (mparams.page_size-SIZE_T_ONE))   != 0))
+|| ((mparams.page_size & (mparams.page_size - SIZE_T_ONE)) != 0))
 ABORT;
 }
 return 0;
 }
 /* support for mallopt */
-static int change_mparam(int param_number, int value) {
+static int
-size_t val = (size_t)value;
+change_mparam(int param_number, int value)
-init_mparams();
+{
-switch(param_number) {
+size_t val = (size_t) value;
-case M_TRIM_THRESHOLD:
+init_mparams();
-mparams.trim_threshold = val;
+switch (param_number) {
-return 1;
+case M_TRIM_THRESHOLD:
-case M_GRANULARITY:
+mparams.trim_threshold = val;
-if (val >= mparams.page_size && ((val & (val-1)) == 0)) {
+return 1;
-mparams.granularity = val;
+case M_GRANULARITY:
-return 1;
+if (val >= mparams.page_size && ((val & (val - 1)) == 0)) {
-}
+mparams.granularity = val;
-else
+return 1;
-return 0;
+} else
-case M_MMAP_THRESHOLD:
+return 0;
-mparams.mmap_threshold = val;
+case M_MMAP_THRESHOLD:
-return 1;
+mparams.mmap_threshold = val;
-default:
+return 1;
-return 0;
+default:
-}
+return 0;
+}
 }
 #if DEBUG
 /* ------------------------- Debugging Support --------------------------- */
 /* Check properties of any chunk, whether free, inuse, mmapped etc  */
-static void do_check_any_chunk(mstate m, mchunkptr p) {
+static void
-assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+do_check_any_chunk(mstate m, mchunkptr p)
-assert(ok_address(m, p));
+{
+assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+assert(ok_address(m, p));
 }
 /* Check properties of top chunk */
-static void do_check_top_chunk(mstate m, mchunkptr p) {
+static void
-msegmentptr sp = segment_holding(m, (char*)p);
+do_check_top_chunk(mstate m, mchunkptr p)
-size_t  sz = chunksize(p);
+{
-assert(sp != 0);
+msegmentptr sp = segment_holding(m, (char *) p);
-assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+size_t sz = chunksize(p);
-assert(ok_address(m, p));
+assert(sp != 0);
-assert(sz == m->topsize);
+assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
-assert(sz > 0);
+assert(ok_address(m, p));
-assert(sz == ((sp->base + sp->size) - (char*)p) - TOP_FOOT_SIZE);
+assert(sz == m->topsize);
-assert(pinuse(p));
+assert(sz > 0);
-assert(!next_pinuse(p));
+assert(sz == ((sp->base + sp->size) - (char *) p) - TOP_FOOT_SIZE);
+assert(pinuse(p));
+assert(!next_pinuse(p));
 }
 /* Check properties of (inuse) mmapped chunks */
-static void do_check_mmapped_chunk(mstate m, mchunkptr p) {
+static void
-size_t  sz = chunksize(p);
+do_check_mmapped_chunk(mstate m, mchunkptr p)
-size_t len = (sz + (p->prev_foot & ~IS_MMAPPED_BIT) + MMAP_FOOT_PAD);
+{
-assert(is_mmapped(p));
+size_t sz = chunksize(p);
-assert(use_mmap(m));
+size_t len = (sz + (p->prev_foot & ~IS_MMAPPED_BIT) + MMAP_FOOT_PAD);
-assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+assert(is_mmapped(p));
-assert(ok_address(m, p));
+assert(use_mmap(m));
-assert(!is_small(sz));
+assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
-assert((len & (mparams.page_size-SIZE_T_ONE)) == 0);
+assert(ok_address(m, p));
-assert(chunk_plus_offset(p, sz)->head == FENCEPOST_HEAD);
+assert(!is_small(sz));
-assert(chunk_plus_offset(p, sz+SIZE_T_SIZE)->head == 0);
+assert((len & (mparams.page_size - SIZE_T_ONE)) == 0);
+assert(chunk_plus_offset(p, sz)->head == FENCEPOST_HEAD);
+assert(chunk_plus_offset(p, sz + SIZE_T_SIZE)->head == 0);
 }
 /* Check properties of inuse chunks */
-static void do_check_inuse_chunk(mstate m, mchunkptr p) {
+static void
-do_check_any_chunk(m, p);
+do_check_inuse_chunk(mstate m, mchunkptr p)
-assert(cinuse(p));
+{
-assert(next_pinuse(p));
+do_check_any_chunk(m, p);
-/* If not pinuse and not mmapped, previous chunk has OK offset */
+assert(cinuse(p));
-assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p);
+assert(next_pinuse(p));
-if (is_mmapped(p))
+/* If not pinuse and not mmapped, previous chunk has OK offset */
-do_check_mmapped_chunk(m, p);
+assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p);
+if (is_mmapped(p))
+do_check_mmapped_chunk(m, p);
 }
 /* Check properties of free chunks */
-static void do_check_free_chunk(mstate m, mchunkptr p) {
+static void
-size_t sz = p->head & ~(PINUSE_BIT|CINUSE_BIT);
+do_check_free_chunk(mstate m, mchunkptr p)
-mchunkptr next = chunk_plus_offset(p, sz);
+{
-do_check_any_chunk(m, p);
+size_t sz = p->head & ~(PINUSE_BIT | CINUSE_BIT);
-assert(!cinuse(p));
+mchunkptr next = chunk_plus_offset(p, sz);
-assert(!next_pinuse(p));
+do_check_any_chunk(m, p);
-assert (!is_mmapped(p));
+assert(!cinuse(p));
-if (p != m->dv && p != m->top) {
+assert(!next_pinuse(p));
-if (sz >= MIN_CHUNK_SIZE) {
+assert(!is_mmapped(p));
-assert((sz & CHUNK_ALIGN_MASK) == 0);
+if (p != m->dv && p != m->top) {
-assert(is_aligned(chunk2mem(p)));
+if (sz >= MIN_CHUNK_SIZE) {
-assert(next->prev_foot == sz);
+assert((sz & CHUNK_ALIGN_MASK) == 0);
-assert(pinuse(p));
+assert(is_aligned(chunk2mem(p)));
-assert (next == m->top || cinuse(next));
+assert(next->prev_foot == sz);
-assert(p->fd->bk == p);
+assert(pinuse(p));
-assert(p->bk->fd == p);
+assert(next == m->top || cinuse(next));
-}
+assert(p->fd->bk == p);
-else  /* markers are always of size SIZE_T_SIZE */
+assert(p->bk->fd == p);
-assert(sz == SIZE_T_SIZE);
+} else                  /* markers are always of size SIZE_T_SIZE */
-}
+assert(sz == SIZE_T_SIZE);
+}
 }
 /* Check properties of malloced chunks at the point they are malloced */
-static void do_check_malloced_chunk(mstate m, void* mem, size_t s) {
+static void
-if (mem != 0) {
+do_check_malloced_chunk(mstate m, void *mem, size_t s)
-mchunkptr p = mem2chunk(mem);
+{
-size_t sz = p->head & ~(PINUSE_BIT|CINUSE_BIT);
+if (mem != 0) {
-do_check_inuse_chunk(m, p);
+mchunkptr p = mem2chunk(mem);
-assert((sz & CHUNK_ALIGN_MASK) == 0);
+size_t sz = p->head & ~(PINUSE_BIT | CINUSE_BIT);
-assert(sz >= MIN_CHUNK_SIZE);
+do_check_inuse_chunk(m, p);
-assert(sz >= s);
+assert((sz & CHUNK_ALIGN_MASK) == 0);
-/* unless mmapped, size is less than MIN_CHUNK_SIZE more than request */
+assert(sz >= MIN_CHUNK_SIZE);
-assert(is_mmapped(p) || sz < (s + MIN_CHUNK_SIZE));
+assert(sz >= s);
-}
+/* unless mmapped, size is less than MIN_CHUNK_SIZE more than request */
+assert(is_mmapped(p) || sz < (s + MIN_CHUNK_SIZE));
+}
 }
 /* Check a tree and its subtrees.  */
-static void do_check_tree(mstate m, tchunkptr t) {
+static void
-tchunkptr head = 0;
+do_check_tree(mstate m, tchunkptr t)
-tchunkptr u = t;
+{
-bindex_t tindex = t->index;
+tchunkptr head = 0;
-size_t tsize = chunksize(t);
+tchunkptr u = t;
-bindex_t idx;
+bindex_t tindex = t->index;
-compute_tree_index(tsize, idx);
+size_t tsize = chunksize(t);
-assert(tindex == idx);
+bindex_t idx;
-assert(tsize >= MIN_LARGE_SIZE);
+compute_tree_index(tsize, idx);
-assert(tsize >= minsize_for_tree_index(idx));
+assert(tindex == idx);
-assert((idx == NTREEBINS-1) || (tsize < minsize_for_tree_index((idx+1))));
+assert(tsize >= MIN_LARGE_SIZE);
+assert(tsize >= minsize_for_tree_index(idx));
-do { /* traverse through chain of same-sized nodes */
+assert((idx == NTREEBINS - 1)
-do_check_any_chunk(m, ((mchunkptr)u));
+|| (tsize < minsize_for_tree_index((idx + 1))));
-assert(u->index == tindex);
-assert(chunksize(u) == tsize);
+do {                        /* traverse through chain of same-sized nodes */
-assert(!cinuse(u));
+do_check_any_chunk(m, ((mchunkptr) u));
-assert(!next_pinuse(u));
+assert(u->index == tindex);
-assert(u->fd->bk == u);
+assert(chunksize(u) == tsize);
-assert(u->bk->fd == u);
+assert(!cinuse(u));
-if (u->parent == 0) {
+assert(!next_pinuse(u));
-assert(u->child[0] == 0);
+assert(u->fd->bk == u);
-assert(u->child[1] == 0);
+assert(u->bk->fd == u);
-}
+if (u->parent == 0) {
-else {
+assert(u->child[0] == 0);
-assert(head == 0); /* only one node on chain has parent */
+assert(u->child[1] == 0);
-head = u;
+} else {
-assert(u->parent != u);
+assert(head == 0);  /* only one node on chain has parent */
-assert (u->parent->child[0] == u ||
+head = u;
-u->parent->child[1] == u ||
+assert(u->parent != u);
-*((tbinptr*)(u->parent)) == u);
+assert(u->parent->child[0] == u ||
-if (u->child[0] != 0) {
+u->parent->child[1] == u ||
-assert(u->child[0]->parent == u);
+*((tbinptr *) (u->parent)) == u);
-assert(u->child[0] != u);
+if (u->child[0] != 0) {
-do_check_tree(m, u->child[0]);
+assert(u->child[0]->parent == u);
-}
+assert(u->child[0] != u);
-if (u->child[1] != 0) {
+do_check_tree(m, u->child[0]);
-assert(u->child[1]->parent == u);
+}
-assert(u->child[1] != u);
+if (u->child[1] != 0) {
-do_check_tree(m, u->child[1]);
+assert(u->child[1]->parent == u);
-}
+assert(u->child[1] != u);
-if (u->child[0] != 0 && u->child[1] != 0) {
+do_check_tree(m, u->child[1]);
-assert(chunksize(u->child[0]) < chunksize(u->child[1]));
+}
-}
+if (u->child[0] != 0 && u->child[1] != 0) {
-}
+assert(chunksize(u->child[0]) < chunksize(u->child[1]));
-u = u->fd;
+}
-} while (u != t);
+}
-assert(head != 0);
+u = u->fd;
+}
+while (u != t);
+assert(head != 0);
 }
 /*  Check all the chunks in a treebin.  */
-static void do_check_treebin(mstate m, bindex_t i) {
+static void
-tbinptr* tb = treebin_at(m, i);
+do_check_treebin(mstate m, bindex_t i)
-tchunkptr t = *tb;
+{
-int empty = (m->treemap & (1U << i)) == 0;
+tbinptr *tb = treebin_at(m, i);
-if (t == 0)
+tchunkptr t = *tb;
-assert(empty);
+int empty = (m->treemap & (1U << i)) == 0;
-if (!empty)
+if (t == 0)
-do_check_tree(m, t);
+assert(empty);
+if (!empty)
+do_check_tree(m, t);
 }
 /*  Check all the chunks in a smallbin.  */
-static void do_check_smallbin(mstate m, bindex_t i) {
+static void
-sbinptr b = smallbin_at(m, i);
+do_check_smallbin(mstate m, bindex_t i)
-mchunkptr p = b->bk;
+{
-unsigned int empty = (m->smallmap & (1U << i)) == 0;
+sbinptr b = smallbin_at(m, i);
-if (p == b)
+mchunkptr p = b->bk;
-assert(empty);
+unsigned int empty = (m->smallmap & (1U << i)) == 0;
-if (!empty) {
+if (p == b)
-for (; p != b; p = p->bk) {
+assert(empty);
-size_t size = chunksize(p);
+if (!empty) {
-mchunkptr q;
+for (; p != b; p = p->bk) {
-/* each chunk claims to be free */
+size_t size = chunksize(p);
-do_check_free_chunk(m, p);
+mchunkptr q;
-/* chunk belongs in bin */
+/* each chunk claims to be free */
-assert(small_index(size) == i);
+do_check_free_chunk(m, p);
-assert(p->bk == b || chunksize(p->bk) == chunksize(p));
+/* chunk belongs in bin */
-/* chunk is followed by an inuse chunk */
+assert(small_index(size) == i);
-q = next_chunk(p);
+assert(p->bk == b || chunksize(p->bk) == chunksize(p));
-if (q->head != FENCEPOST_HEAD)
+/* chunk is followed by an inuse chunk */
-do_check_inuse_chunk(m, q);
+q = next_chunk(p);
-}
+if (q->head != FENCEPOST_HEAD)
-}
+do_check_inuse_chunk(m, q);
+}
+}
 }
 /* Find x in a bin. Used in other check functions. */
-static int bin_find(mstate m, mchunkptr x) {
+static int
-size_t size = chunksize(x);
+bin_find(mstate m, mchunkptr x)
-if (is_small(size)) {
+{
-bindex_t sidx = small_index(size);
+size_t size = chunksize(x);
-sbinptr b = smallbin_at(m, sidx);
+if (is_small(size)) {
-if (smallmap_is_marked(m, sidx)) {
+bindex_t sidx = small_index(size);
-mchunkptr p = b;
+sbinptr b = smallbin_at(m, sidx);
-do {
+if (smallmap_is_marked(m, sidx)) {
-if (p == x)
+mchunkptr p = b;
-return 1;
+do {
-} while ((p = p->fd) != b);
+if (p == x)
-}
+return 1;
 }
-else {
+while ((p = p->fd) != b);
-bindex_t tidx;
+}
-compute_tree_index(size, tidx);
+} else {
-if (treemap_is_marked(m, tidx)) {
+bindex_t tidx;
-tchunkptr t = *treebin_at(m, tidx);
+compute_tree_index(size, tidx);
-size_t sizebits = size << leftshift_for_tree_index(tidx);
+if (treemap_is_marked(m, tidx)) {
-while (t != 0 && chunksize(t) != size) {
+tchunkptr t = *treebin_at(m, tidx);
-t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];
+size_t sizebits = size << leftshift_for_tree_index(tidx);
-sizebits <<= 1;
+while (t != 0 && chunksize(t) != size) {
-}
+t = t->child[(sizebits >> (SIZE_T_BITSIZE - SIZE_T_ONE)) & 1];
-if (t != 0) {
+sizebits <<= 1;
-tchunkptr u = t;
+}
-do {
+if (t != 0) {
-if (u == (tchunkptr)x)
+tchunkptr u = t;
-return 1;
+do {
-} while ((u = u->fd) != t);
+if (u == (tchunkptr) x)
-}
+return 1;
 }
-}
+while ((u = u->fd) != t);
-return 0;
+}
+}
+}
+return 0;
 }
 /* Traverse each chunk and check it; return total */
-static size_t traverse_and_check(mstate m) {
+static size_t
-size_t sum = 0;
+traverse_and_check(mstate m)
-if (is_initialized(m)) {
+{
-msegmentptr s = &m->seg;
+size_t sum = 0;
-sum += m->topsize + TOP_FOOT_SIZE;
+if (is_initialized(m)) {
-while (s != 0) {
+msegmentptr s = &m->seg;
-mchunkptr q = align_as_chunk(s->base);
+sum += m->topsize + TOP_FOOT_SIZE;
-mchunkptr lastq = 0;
+while (s != 0) {
-assert(pinuse(q));
+mchunkptr q = align_as_chunk(s->base);
-while (segment_holds(s, q) &&
+mchunkptr lastq = 0;
-q != m->top && q->head != FENCEPOST_HEAD) {
+assert(pinuse(q));
-sum += chunksize(q);
+while (segment_holds(s, q) &&
-if (cinuse(q)) {
+q != m->top && q->head != FENCEPOST_HEAD) {
-assert(!bin_find(m, q));
+sum += chunksize(q);
-do_check_inuse_chunk(m, q);
+if (cinuse(q)) {
+assert(!bin_find(m, q));
+do_check_inuse_chunk(m, q);
+} else {
+assert(q == m->dv || bin_find(m, q));
+assert(lastq == 0 || cinuse(lastq));        /* Not 2 consecutive free */
+do_check_free_chunk(m, q);
+}
+lastq = q;
+q = next_chunk(q);
+}
+s = s->next;
 }
-else {
+}
-assert(q == m->dv || bin_find(m, q));
+return sum;
-assert(lastq == 0 || cinuse(lastq)); /* Not 2 consecutive free */
+}
-do_check_free_chunk(m, q);
+/* Check all properties of malloc_state. */
+static void
+do_check_malloc_state(mstate m)
+{
+bindex_t i;
+size_t total;
+/* check bins */
+for (i = 0; i < NSMALLBINS; ++i)
+do_check_smallbin(m, i);
+for (i = 0; i < NTREEBINS; ++i)
+do_check_treebin(m, i);
+if (m->dvsize != 0) {       /* check dv chunk */
+do_check_any_chunk(m, m->dv);
+assert(m->dvsize == chunksize(m->dv));
+assert(m->dvsize >= MIN_CHUNK_SIZE);
+assert(bin_find(m, m->dv) == 0);
+}
+if (m->top != 0) {          /* check top chunk */
+do_check_top_chunk(m, m->top);
+assert(m->topsize == chunksize(m->top));
+assert(m->topsize > 0);
+assert(bin_find(m, m->top) == 0);
+}
+total = traverse_and_check(m);
+assert(total <= m->footprint);
+assert(m->footprint <= m->max_footprint);
+}
+#endif /* DEBUG */
+/* ----------------------------- statistics ------------------------------ */
+#if !NO_MALLINFO
+static struct mallinfo
+internal_mallinfo(mstate m)
+{
+struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+if (!PREACTION(m)) {
+check_malloc_state(m);
+if (is_initialized(m)) {
+size_t nfree = SIZE_T_ONE;  /* top always free */
+size_t mfree = m->topsize + TOP_FOOT_SIZE;
+size_t sum = mfree;
+msegmentptr s = &m->seg;
+while (s != 0) {
+mchunkptr q = align_as_chunk(s->base);
+while (segment_holds(s, q) &&
+q != m->top && q->head != FENCEPOST_HEAD) {
+size_t sz = chunksize(q);
+sum += sz;
+if (!cinuse(q)) {
+mfree += sz;
+++nfree;
+}
+q = next_chunk(q);
+}
+s = s->next;
+}
+nm.arena = sum;
+nm.ordblks = nfree;
+nm.hblkhd = m->footprint - sum;
+nm.usmblks = m->max_footprint;
+nm.uordblks = m->footprint - mfree;
+nm.fordblks = mfree;
+nm.keepcost = m->topsize;
 }
-lastq = q;
-q = next_chunk(q);
+POSTACTION(m);
 }
-s = s->next;
+return nm;
 }
-}
+#endif /* !NO_MALLINFO */
-return sum;
-}
+static void
+internal_malloc_stats(mstate m)
-/* Check all properties of malloc_state. */
+{
-static void do_check_malloc_state(mstate m) {
+if (!PREACTION(m)) {
-bindex_t i;
+size_t maxfp = 0;
-size_t total;
+size_t fp = 0;
-/* check bins */
+size_t used = 0;
-for (i = 0; i < NSMALLBINS; ++i)
+check_malloc_state(m);
-do_check_smallbin(m, i);
+if (is_initialized(m)) {
-for (i = 0; i < NTREEBINS; ++i)
+msegmentptr s = &m->seg;
-do_check_treebin(m, i);
+maxfp = m->max_footprint;
+fp = m->footprint;
-if (m->dvsize != 0) { /* check dv chunk */
+used = fp - (m->topsize + TOP_FOOT_SIZE);
-do_check_any_chunk(m, m->dv);
-assert(m->dvsize == chunksize(m->dv));
+while (s != 0) {
-assert(m->dvsize >= MIN_CHUNK_SIZE);
+mchunkptr q = align_as_chunk(s->base);
-assert(bin_find(m, m->dv) == 0);
+while (segment_holds(s, q) &&
-}
+q != m->top && q->head != FENCEPOST_HEAD) {
+if (!cinuse(q))
-if (m->top != 0) {   /* check top chunk */
+used -= chunksize(q);
-do_check_top_chunk(m, m->top);
+q = next_chunk(q);
-assert(m->topsize == chunksize(m->top));
+}
-assert(m->topsize > 0);
+s = s->next;
-assert(bin_find(m, m->top) == 0);
+}
-}
-total = traverse_and_check(m);
-assert(total <= m->footprint);
-assert(m->footprint <= m->max_footprint);
-}
-#endif /* DEBUG */
-/* ----------------------------- statistics ------------------------------ */
-#if !NO_MALLINFO
-static struct mallinfo internal_mallinfo(mstate m) {
-struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-if (!PREACTION(m)) {
-check_malloc_state(m);
-if (is_initialized(m)) {
-size_t nfree = SIZE_T_ONE; /* top always free */
-size_t mfree = m->topsize + TOP_FOOT_SIZE;
-size_t sum = mfree;
-msegmentptr s = &m->seg;
-while (s != 0) {
-mchunkptr q = align_as_chunk(s->base);
-while (segment_holds(s, q) &&
-q != m->top && q->head != FENCEPOST_HEAD) {
-size_t sz = chunksize(q);
-sum += sz;
-if (!cinuse(q)) {
-mfree += sz;
-++nfree;
-}
-q = next_chunk(q);
 }
-s = s->next;
-}
-nm.arena    = sum;
-nm.ordblks  = nfree;
-nm.hblkhd   = m->footprint - sum;
-nm.usmblks  = m->max_footprint;
-nm.uordblks = m->footprint - mfree;
-nm.fordblks = mfree;
-nm.keepcost = m->topsize;
-}
-POSTACTION(m);
-}
-return nm;
-}
-#endif /* !NO_MALLINFO */
-static void internal_malloc_stats(mstate m) {
-if (!PREACTION(m)) {
-size_t maxfp = 0;
-size_t fp = 0;
-size_t used = 0;
-check_malloc_state(m);
-if (is_initialized(m)) {
-msegmentptr s = &m->seg;
-maxfp = m->max_footprint;
-fp = m->footprint;
-used = fp - (m->topsize + TOP_FOOT_SIZE);
-while (s != 0) {
-mchunkptr q = align_as_chunk(s->base);
-while (segment_holds(s, q) &&
-q != m->top && q->head != FENCEPOST_HEAD) {
-if (!cinuse(q))
-used -= chunksize(q);
-q = next_chunk(q);
-}
-s = s->next;
-}
-}
 #ifndef LACKS_STDIO_H
-fprintf(stderr, "max system bytes = %10lu\n", (unsigned long)(maxfp));
+fprintf(stderr, "max system bytes = %10lu\n",
-fprintf(stderr, "system bytes     = %10lu\n", (unsigned long)(fp));
+(unsigned long) (maxfp));
-fprintf(stderr, "in use bytes     = %10lu\n", (unsigned long)(used));
+fprintf(stderr, "system bytes     = %10lu\n", (unsigned long) (fp));
+fprintf(stderr, "in use bytes     = %10lu\n", (unsigned long) (used));
 #endif
 POSTACTION(m);
 }
 }
 /* ----------------------- Operations on smallbins ----------------------- */
 /*
 allocated to hold a fake next chunk of size SIZE_T_SIZE to maintain
 the PINUSE bit so frees can be checked.
 */
 /* Malloc using mmap */
-static void* mmap_alloc(mstate m, size_t nb) {
+static void *
-size_t mmsize = granularity_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+mmap_alloc(mstate m, size_t nb)
-if (mmsize > nb) {     /* Check for wrap around 0 */
+{
-char* mm = (char*)(DIRECT_MMAP(mmsize));
+size_t mmsize =
-if (mm != CMFAIL) {
+granularity_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
-size_t offset = align_offset(chunk2mem(mm));
+if (mmsize > nb) {          /* Check for wrap around 0 */
-size_t psize = mmsize - offset - MMAP_FOOT_PAD;
+char *mm = (char *) (DIRECT_MMAP(mmsize));
-mchunkptr p = (mchunkptr)(mm + offset);
+if (mm != CMFAIL) {
-p->prev_foot = offset | IS_MMAPPED_BIT;
+size_t offset = align_offset(chunk2mem(mm));
-(p)->head = (psize|CINUSE_BIT);
+size_t psize = mmsize - offset - MMAP_FOOT_PAD;
-mark_inuse_foot(m, p, psize);
+mchunkptr p = (mchunkptr) (mm + offset);
-chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD;
+p->prev_foot = offset | IS_MMAPPED_BIT;
-chunk_plus_offset(p, psize+SIZE_T_SIZE)->head = 0;
+(p)->head = (psize | CINUSE_BIT);
+mark_inuse_foot(m, p, psize);
-if (mm < m->least_addr)
+chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD;
-m->least_addr = mm;
+chunk_plus_offset(p, psize + SIZE_T_SIZE)->head = 0;
-if ((m->footprint += mmsize) > m->max_footprint)
-m->max_footprint = m->footprint;
+if (mm < m->least_addr)
-assert(is_aligned(chunk2mem(p)));
+m->least_addr = mm;
-check_mmapped_chunk(m, p);
+if ((m->footprint += mmsize) > m->max_footprint)
-return chunk2mem(p);
+m->max_footprint = m->footprint;
-}
+assert(is_aligned(chunk2mem(p)));
-}
+check_mmapped_chunk(m, p);
-return 0;
+return chunk2mem(p);
+}
+}
+return 0;
 }
 /* Realloc using mmap */
-static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb) {
+static mchunkptr
-size_t oldsize = chunksize(oldp);
+mmap_resize(mstate m, mchunkptr oldp, size_t nb)
-if (is_small(nb)) /* Can't shrink mmap regions below small size */
+{
+size_t oldsize = chunksize(oldp);
+if (is_small(nb))           /* Can't shrink mmap regions below small size */
+return 0;
+/* Keep old chunk if big enough but not too big */
+if (oldsize >= nb + SIZE_T_SIZE &&
+(oldsize - nb) <= (mparams.granularity << 1))
+return oldp;
+else {
+size_t offset = oldp->prev_foot & ~IS_MMAPPED_BIT;
+size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
+size_t newmmsize = granularity_align(nb + SIX_SIZE_T_SIZES +
+CHUNK_ALIGN_MASK);
+char *cp = (char *) CALL_MREMAP((char *) oldp - offset,
+oldmmsize, newmmsize, 1);
+if (cp != CMFAIL) {
+mchunkptr newp = (mchunkptr) (cp + offset);
+size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
+newp->head = (psize | CINUSE_BIT);
+mark_inuse_foot(m, newp, psize);
+chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
+chunk_plus_offset(newp, psize + SIZE_T_SIZE)->head = 0;
+if (cp < m->least_addr)
+m->least_addr = cp;
+if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint)
+m->max_footprint = m->footprint;
+check_mmapped_chunk(m, newp);
+return newp;
+}
+}
 return 0;
-/* Keep old chunk if big enough but not too big */
-if (oldsize >= nb + SIZE_T_SIZE &&
-(oldsize - nb) <= (mparams.granularity << 1))
-return oldp;
-else {
-size_t offset = oldp->prev_foot & ~IS_MMAPPED_BIT;
-size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
-size_t newmmsize = granularity_align(nb + SIX_SIZE_T_SIZES +
-CHUNK_ALIGN_MASK);
-char* cp = (char*)CALL_MREMAP((char*)oldp - offset,
-oldmmsize, newmmsize, 1);
-if (cp != CMFAIL) {
-mchunkptr newp = (mchunkptr)(cp + offset);
-size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
-newp->head = (psize|CINUSE_BIT);
-mark_inuse_foot(m, newp, psize);
-chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
-chunk_plus_offset(newp, psize+SIZE_T_SIZE)->head = 0;
-if (cp < m->least_addr)
-m->least_addr = cp;
-if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint)
-m->max_footprint = m->footprint;
-check_mmapped_chunk(m, newp);
-return newp;
-}
-}
-return 0;
 }
 /* -------------------------- mspace management -------------------------- */
 /* Initialize top chunk and its size */
-static void init_top(mstate m, mchunkptr p, size_t psize) {
+static void
-/* Ensure alignment */
+init_top(mstate m, mchunkptr p, size_t psize)
-size_t offset = align_offset(chunk2mem(p));
+{
-p = (mchunkptr)((char*)p + offset);
+/* Ensure alignment */
-psize -= offset;
+size_t offset = align_offset(chunk2mem(p));
+p = (mchunkptr) ((char *) p + offset);
-m->top = p;
+psize -= offset;
-m->topsize = psize;
-p->head = psize | PINUSE_BIT;
+m->top = p;
-/* set size of fake trailing chunk holding overhead space only once */
+m->topsize = psize;
-chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE;
+p->head = psize | PINUSE_BIT;
-m->trim_check = mparams.trim_threshold; /* reset on each update */
+/* set size of fake trailing chunk holding overhead space only once */
+chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE;
+m->trim_check = mparams.trim_threshold;     /* reset on each update */
 }
 /* Initialize bins for a new mstate that is otherwise zeroed out */
-static void init_bins(mstate m) {
+static void
-/* Establish circular links for smallbins */
+init_bins(mstate m)
-bindex_t i;
+{
-for (i = 0; i < NSMALLBINS; ++i) {
+/* Establish circular links for smallbins */
-sbinptr bin = smallbin_at(m,i);
+bindex_t i;
-bin->fd = bin->bk = bin;
+for (i = 0; i < NSMALLBINS; ++i) {
-}
+sbinptr bin = smallbin_at(m, i);
+bin->fd = bin->bk = bin;
+}
 }
 #if PROCEED_ON_ERROR
 /* default corruption action */
-static void reset_on_error(mstate m) {
+static void
-int i;
+reset_on_error(mstate m)
-++malloc_corruption_error_count;
+{
-/* Reinitialize fields to forget about all memory */
+int i;
-m->smallbins = m->treebins = 0;
+++malloc_corruption_error_count;
-m->dvsize = m->topsize = 0;
+/* Reinitialize fields to forget about all memory */
-m->seg.base = 0;
+m->smallbins = m->treebins = 0;
-m->seg.size = 0;
+m->dvsize = m->topsize = 0;
-m->seg.next = 0;
+m->seg.base = 0;
-m->top = m->dv = 0;
+m->seg.size = 0;
-for (i = 0; i < NTREEBINS; ++i)
+m->seg.next = 0;
-*treebin_at(m, i) = 0;
+m->top = m->dv = 0;
-init_bins(m);
+for (i = 0; i < NTREEBINS; ++i)
+*treebin_at(m, i) = 0;
+init_bins(m);
 }
 #endif /* PROCEED_ON_ERROR */
 /* Allocate chunk and prepend remainder with chunk in successor base. */
-static void* prepend_alloc(mstate m, char* newbase, char* oldbase,
+static void *
-size_t nb) {
+prepend_alloc(mstate m, char *newbase, char *oldbase, size_t nb)
-mchunkptr p = align_as_chunk(newbase);
+{
-mchunkptr oldfirst = align_as_chunk(oldbase);
+mchunkptr p = align_as_chunk(newbase);
-size_t psize = (char*)oldfirst - (char*)p;
+mchunkptr oldfirst = align_as_chunk(oldbase);
-mchunkptr q = chunk_plus_offset(p, nb);
+size_t psize = (char *) oldfirst - (char *) p;
-size_t qsize = psize - nb;
+mchunkptr q = chunk_plus_offset(p, nb);
-set_size_and_pinuse_of_inuse_chunk(m, p, nb);
+size_t qsize = psize - nb;
+set_size_and_pinuse_of_inuse_chunk(m, p, nb);
-assert((char*)oldfirst > (char*)q);
-assert(pinuse(oldfirst));
+assert((char *) oldfirst > (char *) q);
-assert(qsize >= MIN_CHUNK_SIZE);
+assert(pinuse(oldfirst));
+assert(qsize >= MIN_CHUNK_SIZE);
-/* consolidate remainder with first chunk of old base */
-if (oldfirst == m->top) {
+/* consolidate remainder with first chunk of old base */
-size_t tsize = m->topsize += qsize;
+if (oldfirst == m->top) {
-m->top = q;
+size_t tsize = m->topsize += qsize;
-q->head = tsize | PINUSE_BIT;
+m->top = q;
-check_top_chunk(m, q);
+q->head = tsize | PINUSE_BIT;
-}
+check_top_chunk(m, q);
-else if (oldfirst == m->dv) {
+} else if (oldfirst == m->dv) {
 size_t dsize = m->dvsize += qsize;
 m->dv = q;
 set_size_and_pinuse_of_free_chunk(q, dsize);
-}
+} else {
-else {
+if (!cinuse(oldfirst)) {
-if (!cinuse(oldfirst)) {
+size_t nsize = chunksize(oldfirst);
-size_t nsize = chunksize(oldfirst);
+unlink_chunk(m, oldfirst, nsize);
-unlink_chunk(m, oldfirst, nsize);
+oldfirst = chunk_plus_offset(oldfirst, nsize);
-oldfirst = chunk_plus_offset(oldfirst, nsize);
+qsize += nsize;
-qsize += nsize;
+}
-}
+set_free_with_pinuse(q, qsize, oldfirst);
-set_free_with_pinuse(q, qsize, oldfirst);
+insert_chunk(m, q, qsize);
-insert_chunk(m, q, qsize);
+check_free_chunk(m, q);
-check_free_chunk(m, q);
+}
-}
+check_malloced_chunk(m, chunk2mem(p), nb);
-check_malloced_chunk(m, chunk2mem(p), nb);
+return chunk2mem(p);
-return chunk2mem(p);
 }
 /* Add a segment to hold a new noncontiguous region */
-static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) {
+static void
-/* Determine locations and sizes of segment, fenceposts, old top */
+add_segment(mstate m, char *tbase, size_t tsize, flag_t mmapped)
-char* old_top = (char*)m->top;
+{
-msegmentptr oldsp = segment_holding(m, old_top);
+/* Determine locations and sizes of segment, fenceposts, old top */
-char* old_end = oldsp->base + oldsp->size;
+char *old_top = (char *) m->top;
-size_t ssize = pad_request(sizeof(struct malloc_segment));
+msegmentptr oldsp = segment_holding(m, old_top);
-char* rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+char *old_end = oldsp->base + oldsp->size;
-size_t offset = align_offset(chunk2mem(rawsp));
+size_t ssize = pad_request(sizeof(struct malloc_segment));
-char* asp = rawsp + offset;
+char *rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
-char* csp = (asp < (old_top + MIN_CHUNK_SIZE))? old_top : asp;
+size_t offset = align_offset(chunk2mem(rawsp));
-mchunkptr sp = (mchunkptr)csp;
+char *asp = rawsp + offset;
-msegmentptr ss = (msegmentptr)(chunk2mem(sp));
+char *csp = (asp < (old_top + MIN_CHUNK_SIZE)) ? old_top : asp;
-mchunkptr tnext = chunk_plus_offset(sp, ssize);
+mchunkptr sp = (mchunkptr) csp;
-mchunkptr p = tnext;
+msegmentptr ss = (msegmentptr) (chunk2mem(sp));
-int nfences = 0;
+mchunkptr tnext = chunk_plus_offset(sp, ssize);
+mchunkptr p = tnext;
-/* reset top to new space */
+int nfences = 0;
-init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE);
+/* reset top to new space */
-/* Set up segment record */
+init_top(m, (mchunkptr) tbase, tsize - TOP_FOOT_SIZE);
-assert(is_aligned(ss));
-set_size_and_pinuse_of_inuse_chunk(m, sp, ssize);
+/* Set up segment record */
-*ss = m->seg; /* Push current record */
+assert(is_aligned(ss));
-m->seg.base = tbase;
+set_size_and_pinuse_of_inuse_chunk(m, sp, ssize);
-m->seg.size = tsize;
+*ss = m->seg;               /* Push current record */
-m->seg.sflags = mmapped;
+m->seg.base = tbase;
-m->seg.next = ss;
+m->seg.size = tsize;
+m->seg.sflags = mmapped;
-/* Insert trailing fenceposts */
+m->seg.next = ss;
-for (;;) {
-mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE);
+/* Insert trailing fenceposts */
-p->head = FENCEPOST_HEAD;
+for (;;) {
-++nfences;
+mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE);
-if ((char*)(&(nextp->head)) < old_end)
+p->head = FENCEPOST_HEAD;
-p = nextp;
+++nfences;
-else
+if ((char *) (&(nextp->head)) < old_end)
-break;
+p = nextp;
-}
+else
-assert(nfences >= 2);
+break;
+}
-/* Insert the rest of old top into a bin as an ordinary free chunk */
+assert(nfences >= 2);
-if (csp != old_top) {
-mchunkptr q = (mchunkptr)old_top;
+/* Insert the rest of old top into a bin as an ordinary free chunk */
-size_t psize = csp - old_top;
+if (csp != old_top) {
-mchunkptr tn = chunk_plus_offset(q, psize);
+mchunkptr q = (mchunkptr) old_top;
-set_free_with_pinuse(q, psize, tn);
+size_t psize = csp - old_top;
-insert_chunk(m, q, psize);
+mchunkptr tn = chunk_plus_offset(q, psize);
-}
+set_free_with_pinuse(q, psize, tn);
+insert_chunk(m, q, psize);
-check_top_chunk(m, m->top);
+}
+check_top_chunk(m, m->top);
 }
 /* -------------------------- System allocation -------------------------- */
 /* Get memory from system using MORECORE or MMAP */
-static void* sys_alloc(mstate m, size_t nb) {
+static void *
-char* tbase = CMFAIL;
+sys_alloc(mstate m, size_t nb)
-size_t tsize = 0;
+{
-flag_t mmap_flag = 0;
+char *tbase = CMFAIL;
+size_t tsize = 0;
-init_mparams();
+flag_t mmap_flag = 0;
-/* Directly map large chunks */
+init_mparams();
-if (use_mmap(m) && nb >= mparams.mmap_threshold) {
-void* mem = mmap_alloc(m, nb);
+/* Directly map large chunks */
-if (mem != 0)
+if (use_mmap(m) && nb >= mparams.mmap_threshold) {
-return mem;
+void *mem = mmap_alloc(m, nb);
-}
+if (mem != 0)
+return mem;
-/*
+}
-Try getting memory in any of three ways (in most-preferred to
-least-preferred order):
+/*
-1. A call to MORECORE that can normally contiguously extend memory.
+Try getting memory in any of three ways (in most-preferred to
+least-preferred order):
+1. A call to MORECORE that can normally contiguously extend memory.
 (disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or
 or main space is mmapped or a previous contiguous call failed)
 2. A call to MMAP new space (disabled if not HAVE_MMAP).
 Note that under the default settings, if MORECORE is unable to
 fulfill a request, and HAVE_MMAP is true, then mmap is
 used as a noncontiguous system allocator. This is a useful backup
 strategy for systems with holes in address spaces -- in this case
 sbrk cannot contiguously expand the heap, but mmap may be able to
 find space.
 3. A call to MORECORE that cannot usually contiguously extend memory.
 (disabled if not HAVE_MORECORE)
 */
 if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) {
-char* br = CMFAIL;
+char *br = CMFAIL;
-msegmentptr ss = (m->top == 0)? 0 : segment_holding(m, (char*)m->top);
+msegmentptr ss =
-size_t asize = 0;
+(m->top == 0) ? 0 : segment_holding(m, (char *) m->top);
-ACQUIRE_MORECORE_LOCK();
+size_t asize = 0;
+ACQUIRE_MORECORE_LOCK();
-if (ss == 0) {  /* First time through or recovery */
-char* base = (char*)CALL_MORECORE(0);
+if (ss == 0) {          /* First time through or recovery */
-if (base != CMFAIL) {
+char *base = (char *) CALL_MORECORE(0);
-asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE);
+if (base != CMFAIL) {
-/* Adjust to end on a page boundary */
+asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE);
-if (!is_page_aligned(base))
+/* Adjust to end on a page boundary */
-asize += (page_align((size_t)base) - (size_t)base);
+if (!is_page_aligned(base))
-/* Can't call MORECORE if size is negative when treated as signed */
+asize += (page_align((size_t) base) - (size_t) base);
-if (asize < HALF_MAX_SIZE_T &&
+/* Can't call MORECORE if size is negative when treated as signed */
-(br = (char*)(CALL_MORECORE(asize))) == base) {
+if (asize < HALF_MAX_SIZE_T &&
-tbase = base;
+(br = (char *) (CALL_MORECORE(asize))) == base) {
-tsize = asize;
+tbase = base;
+tsize = asize;
+}
+}
+} else {
+/* Subtract out existing available top space from MORECORE request. */
+asize =
+granularity_align(nb - m->topsize + TOP_FOOT_SIZE +
+SIZE_T_ONE);
+/* Use mem here only if it did continuously extend old space */
+if (asize < HALF_MAX_SIZE_T &&
+(br =
+(char *) (CALL_MORECORE(asize))) == ss->base + ss->size) {
+tbase = br;
+tsize = asize;
+}
 }
-}
-}
+if (tbase == CMFAIL) {  /* Cope with partial failure */
-else {
+if (br != CMFAIL) { /* Try to use/extend the space we did get */
-/* Subtract out existing available top space from MORECORE request. */
+if (asize < HALF_MAX_SIZE_T &&
-asize = granularity_align(nb - m->topsize + TOP_FOOT_SIZE + SIZE_T_ONE);
+asize < nb + TOP_FOOT_SIZE + SIZE_T_ONE) {
-/* Use mem here only if it did continuously extend old space */
+size_t esize =
-if (asize < HALF_MAX_SIZE_T &&
+granularity_align(nb + TOP_FOOT_SIZE +
-(br = (char*)(CALL_MORECORE(asize))) == ss->base+ss->size) {
+SIZE_T_ONE - asize);
-tbase = br;
+if (esize < HALF_MAX_SIZE_T) {
-tsize = asize;
+char *end = (char *) CALL_MORECORE(esize);
-}
+if (end != CMFAIL)
-}
+asize += esize;
+else {  /* Can't use; try to release */
-if (tbase == CMFAIL) {    /* Cope with partial failure */
+end = (char *) CALL_MORECORE(-asize);
-if (br != CMFAIL) {    /* Try to use/extend the space we did get */
+br = CMFAIL;
-if (asize < HALF_MAX_SIZE_T &&
+}
-asize < nb + TOP_FOOT_SIZE + SIZE_T_ONE) {
+}
-size_t esize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE - asize);
+}
-if (esize < HALF_MAX_SIZE_T) {
-char* end = (char*)CALL_MORECORE(esize);
-if (end != CMFAIL)
-asize += esize;
-else {            /* Can't use; try to release */
-end = (char*)CALL_MORECORE(-asize);
-br = CMFAIL;
 }
-}
+if (br != CMFAIL) { /* Use the space we did get */
+tbase = br;
+tsize = asize;
+} else
+disable_contiguous(m);  /* Don't try contiguous path in the future */
 }
-}
-if (br != CMFAIL) {    /* Use the space we did get */
+RELEASE_MORECORE_LOCK();
-tbase = br;
+}
-tsize = asize;
-}
+if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */
-else
+size_t req = nb + TOP_FOOT_SIZE + SIZE_T_ONE;
-disable_contiguous(m); /* Don't try contiguous path in the future */
+size_t rsize = granularity_align(req);
-}
+if (rsize > nb) {       /* Fail if wraps around zero */
+char *mp = (char *) (CALL_MMAP(rsize));
-RELEASE_MORECORE_LOCK();
+if (mp != CMFAIL) {
-}
+tbase = mp;
+tsize = rsize;
-if (HAVE_MMAP && tbase == CMFAIL) {  /* Try MMAP */
+mmap_flag = IS_MMAPPED_BIT;
-size_t req = nb + TOP_FOOT_SIZE + SIZE_T_ONE;
+}
-size_t rsize = granularity_align(req);
-if (rsize > nb) { /* Fail if wraps around zero */
-char* mp = (char*)(CALL_MMAP(rsize));
-if (mp != CMFAIL) {
-tbase = mp;
-tsize = rsize;
-mmap_flag = IS_MMAPPED_BIT;
-}
-}
-}
-if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */
-size_t asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE);
-if (asize < HALF_MAX_SIZE_T) {
-char* br = CMFAIL;
-char* end = CMFAIL;
-ACQUIRE_MORECORE_LOCK();
-br = (char*)(CALL_MORECORE(asize));
-end = (char*)(CALL_MORECORE(0));
-RELEASE_MORECORE_LOCK();
-if (br != CMFAIL && end != CMFAIL && br < end) {
-size_t ssize = end - br;
-if (ssize > nb + TOP_FOOT_SIZE) {
-tbase = br;
-tsize = ssize;
 }
 }
-}
-}
+if (HAVE_MORECORE && tbase == CMFAIL) {     /* Try noncontiguous MORECORE */
+size_t asize = granularity_align(nb + TOP_FOOT_SIZE + SIZE_T_ONE);
-if (tbase != CMFAIL) {
+if (asize < HALF_MAX_SIZE_T) {
+char *br = CMFAIL;
-if ((m->footprint += tsize) > m->max_footprint)
+char *end = CMFAIL;
-m->max_footprint = m->footprint;
+ACQUIRE_MORECORE_LOCK();
+br = (char *) (CALL_MORECORE(asize));
-if (!is_initialized(m)) { /* first-time initialization */
+end = (char *) (CALL_MORECORE(0));
-m->seg.base = m->least_addr = tbase;
+RELEASE_MORECORE_LOCK();
-m->seg.size = tsize;
+if (br != CMFAIL && end != CMFAIL && br < end) {
-m->seg.sflags = mmap_flag;
+size_t ssize = end - br;
-m->magic = mparams.magic;
+if (ssize > nb + TOP_FOOT_SIZE) {
-init_bins(m);
+tbase = br;
-if (is_global(m))
+tsize = ssize;
-init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE);
+}
-else {
+}
-/* Offset top by embedded malloc_state */
-mchunkptr mn = next_chunk(mem2chunk(m));
-init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) -TOP_FOOT_SIZE);
-}
-}
-else {
-/* Try to merge with an existing segment */
-msegmentptr sp = &m->seg;
-while (sp != 0 && tbase != sp->base + sp->size)
-sp = sp->next;
-if (sp != 0 &&
-!is_extern_segment(sp) &&
-(sp->sflags & IS_MMAPPED_BIT) == mmap_flag &&
-segment_holds(sp, m->top)) { /* append */
-sp->size += tsize;
-init_top(m, m->top, m->topsize + tsize);
-}
-else {
-if (tbase < m->least_addr)
-m->least_addr = tbase;
-sp = &m->seg;
-while (sp != 0 && sp->base != tbase + tsize)
-sp = sp->next;
-if (sp != 0 &&
-!is_extern_segment(sp) &&
-(sp->sflags & IS_MMAPPED_BIT) == mmap_flag) {
-char* oldbase = sp->base;
-sp->base = tbase;
-sp->size += tsize;
-return prepend_alloc(m, tbase, oldbase, nb);
 }
-else
+}
-add_segment(m, tbase, tsize, mmap_flag);
-}
+if (tbase != CMFAIL) {
-}
+if ((m->footprint += tsize) > m->max_footprint)
-if (nb < m->topsize) { /* Allocate from new or extended top space */
+m->max_footprint = m->footprint;
-size_t rsize = m->topsize -= nb;
-mchunkptr p = m->top;
+if (!is_initialized(m)) {       /* first-time initialization */
-mchunkptr r = m->top = chunk_plus_offset(p, nb);
+m->seg.base = m->least_addr = tbase;
-r->head = rsize | PINUSE_BIT;
+m->seg.size = tsize;
-set_size_and_pinuse_of_inuse_chunk(m, p, nb);
+m->seg.sflags = mmap_flag;
-check_top_chunk(m, m->top);
+m->magic = mparams.magic;
-check_malloced_chunk(m, chunk2mem(p), nb);
+init_bins(m);
-return chunk2mem(p);
+if (is_global(m))
-}
+init_top(m, (mchunkptr) tbase, tsize - TOP_FOOT_SIZE);
-}
+else {
+/* Offset top by embedded malloc_state */
-MALLOC_FAILURE_ACTION;
+mchunkptr mn = next_chunk(mem2chunk(m));
-return 0;
+init_top(m, mn,
-}
+(size_t) ((tbase + tsize) - (char *) mn) -
+TOP_FOOT_SIZE);
-/* -----------------------  system deallocation -------------------------- */
+}
-/* Unmap and unlink any mmapped segments that don't contain used chunks */
-static size_t release_unused_segments(mstate m) {
-size_t released = 0;
-msegmentptr pred = &m->seg;
-msegmentptr sp = pred->next;
-while (sp != 0) {
-char* base = sp->base;
-size_t size = sp->size;
-msegmentptr next = sp->next;
-if (is_mmapped_segment(sp) && !is_extern_segment(sp)) {
-mchunkptr p = align_as_chunk(base);
-size_t psize = chunksize(p);
-/* Can unmap if first chunk holds entire segment and not pinned */
-if (!cinuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) {
-tchunkptr tp = (tchunkptr)p;
-assert(segment_holds(sp, (char*)sp));
-if (p == m->dv) {
-m->dv = 0;
-m->dvsize = 0;
 }
 else {
-unlink_large_chunk(m, tp);
+/* Try to merge with an existing segment */
+msegmentptr sp = &m->seg;
+while (sp != 0 && tbase != sp->base + sp->size)
+sp = sp->next;
+if (sp != 0 && !is_extern_segment(sp) && (sp->sflags & IS_MMAPPED_BIT) == mmap_flag && segment_holds(sp, m->top)) { /* append */
+sp->size += tsize;
+init_top(m, m->top, m->topsize + tsize);
+} else {
+if (tbase < m->least_addr)
+m->least_addr = tbase;
+sp = &m->seg;
+while (sp != 0 && sp->base != tbase + tsize)
+sp = sp->next;
+if (sp != 0 &&
+!is_extern_segment(sp) &&
+(sp->sflags & IS_MMAPPED_BIT) == mmap_flag) {
+char *oldbase = sp->base;
+sp->base = tbase;
+sp->size += tsize;
+return prepend_alloc(m, tbase, oldbase, nb);
+} else
+add_segment(m, tbase, tsize, mmap_flag);
+}
 }
-if (CALL_MUNMAP(base, size) == 0) {
-released += size;
+if (nb < m->topsize) {  /* Allocate from new or extended top space */
-m->footprint -= size;
+size_t rsize = m->topsize -= nb;
-/* unlink obsoleted record */
+mchunkptr p = m->top;
-sp = pred;
+mchunkptr r = m->top = chunk_plus_offset(p, nb);
-sp->next = next;
+r->head = rsize | PINUSE_BIT;
+set_size_and_pinuse_of_inuse_chunk(m, p, nb);
+check_top_chunk(m, m->top);
+check_malloced_chunk(m, chunk2mem(p), nb);
+return chunk2mem(p);
 }
-else { /* back out if cannot unmap */
+}
-insert_large_chunk(m, tp, psize);
-}
-}
-}
-pred = sp;
-sp = next;
-}
-return released;
-}
-static int sys_trim(mstate m, size_t pad) {
-size_t released = 0;
-if (pad < MAX_REQUEST && is_initialized(m)) {
-pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
-if (m->topsize > pad) {
-/* Shrink top space in granularity-size units, keeping at least one */
-size_t unit = mparams.granularity;
-size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
-SIZE_T_ONE) * unit;
-msegmentptr sp = segment_holding(m, (char*)m->top);
-if (!is_extern_segment(sp)) {
-if (is_mmapped_segment(sp)) {
-if (HAVE_MMAP &&
-sp->size >= extra &&
-!has_segment_link(m, sp)) { /* can't shrink if pinned */
-size_t newsize = sp->size - extra;
-/* Prefer mremap, fall back to munmap */
-if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL) ||
-(CALL_MUNMAP(sp->base + newsize, extra) == 0)) {
-released = extra;
-}
-}
-}
-else if (HAVE_MORECORE) {
-if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */
-extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit;
-ACQUIRE_MORECORE_LOCK();
-{
-/* Make sure end of memory is where we last set it. */
-char* old_br = (char*)(CALL_MORECORE(0));
-if (old_br == sp->base + sp->size) {
-char* rel_br = (char*)(CALL_MORECORE(-extra));
-char* new_br = (char*)(CALL_MORECORE(0));
-if (rel_br != CMFAIL && new_br < old_br)
-released = old_br - new_br;
-}
-}
-RELEASE_MORECORE_LOCK();
-}
-}
-if (released != 0) {
-sp->size -= released;
-m->footprint -= released;
-init_top(m, m->top, m->topsize - released);
-check_top_chunk(m, m->top);
-}
-}
-/* Unmap any unused mmapped segments */
-if (HAVE_MMAP)
-released += release_unused_segments(m);
-/* On failure, disable autotrim to avoid repeated failed future calls */
-if (released == 0)
-m->trim_check = MAX_SIZE_T;
-}
-return (released != 0)? 1 : 0;
-}
-/* ---------------------------- malloc support --------------------------- */
-/* allocate a large request from the best fitting chunk in a treebin */
-static void* tmalloc_large(mstate m, size_t nb) {
-tchunkptr v = 0;
-size_t rsize = -nb; /* Unsigned negation */
-tchunkptr t;
-bindex_t idx;
-compute_tree_index(nb, idx);
-if ((t = *treebin_at(m, idx)) != 0) {
-/* Traverse tree for this bin looking for node with size == nb */
-size_t sizebits = nb << leftshift_for_tree_index(idx);
-tchunkptr rst = 0;  /* The deepest untaken right subtree */
-for (;;) {
-tchunkptr rt;
-size_t trem = chunksize(t) - nb;
-if (trem < rsize) {
-v = t;
-if ((rsize = trem) == 0)
-break;
-}
-rt = t->child[1];
-t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];
-if (rt != 0 && rt != t)
-rst = rt;
-if (t == 0) {
-t = rst; /* set t to least subtree holding sizes > nb */
-break;
-}
-sizebits <<= 1;
-}
-}
-if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */
-binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap;
-if (leftbits != 0) {
-bindex_t i;
-binmap_t leastbit = least_bit(leftbits);
-compute_bit2idx(leastbit, i);
-t = *treebin_at(m, i);
-}
-}
-while (t != 0) { /* find smallest of tree or subtree */
-size_t trem = chunksize(t) - nb;
-if (trem < rsize) {
-rsize = trem;
-v = t;
-}
-t = leftmost_child(t);
-}
-/*  If dv is a better fit, return 0 so malloc will use it */
-if (v != 0 && rsize < (size_t)(m->dvsize - nb)) {
-if (RTCHECK(ok_address(m, v))) { /* split */
-mchunkptr r = chunk_plus_offset(v, nb);
-assert(chunksize(v) == rsize + nb);
-if (RTCHECK(ok_next(v, r))) {
-unlink_large_chunk(m, v);
-if (rsize < MIN_CHUNK_SIZE)
-set_inuse_and_pinuse(m, v, (rsize + nb));
-else {
-set_size_and_pinuse_of_inuse_chunk(m, v, nb);
-set_size_and_pinuse_of_free_chunk(r, rsize);
-insert_chunk(m, r, rsize);
-}
-return chunk2mem(v);
-}
-}
-CORRUPTION_ERROR_ACTION(m);
-}
-return 0;
-}
-/* allocate a small request from the best fitting chunk in a treebin */
-static void* tmalloc_small(mstate m, size_t nb) {
-tchunkptr t, v;
-size_t rsize;
-bindex_t i;
-binmap_t leastbit = least_bit(m->treemap);
-compute_bit2idx(leastbit, i);
-v = t = *treebin_at(m, i);
-rsize = chunksize(t) - nb;
-while ((t = leftmost_child(t)) != 0) {
-size_t trem = chunksize(t) - nb;
-if (trem < rsize) {
-rsize = trem;
-v = t;
-}
-}
-if (RTCHECK(ok_address(m, v))) {
-mchunkptr r = chunk_plus_offset(v, nb);
-assert(chunksize(v) == rsize + nb);
-if (RTCHECK(ok_next(v, r))) {
-unlink_large_chunk(m, v);
-if (rsize < MIN_CHUNK_SIZE)
-set_inuse_and_pinuse(m, v, (rsize + nb));
-else {
-set_size_and_pinuse_of_inuse_chunk(m, v, nb);
-set_size_and_pinuse_of_free_chunk(r, rsize);
-replace_dv(m, r, rsize);
-}
-return chunk2mem(v);
-}
-}
-CORRUPTION_ERROR_ACTION(m);
-return 0;
-}
-/* --------------------------- realloc support --------------------------- */
-static void* internal_realloc(mstate m, void* oldmem, size_t bytes) {
-if (bytes >= MAX_REQUEST) {
 MALLOC_FAILURE_ACTION;
 return 0;
 }
-if (!PREACTION(m)) {
-mchunkptr oldp = mem2chunk(oldmem);
+/* -----------------------  system deallocation -------------------------- */
-size_t oldsize = chunksize(oldp);
-mchunkptr next = chunk_plus_offset(oldp, oldsize);
+/* Unmap and unlink any mmapped segments that don't contain used chunks */
-mchunkptr newp = 0;
+static size_t
-void* extra = 0;
+release_unused_segments(mstate m)
+{
-/* Try to either shrink or extend into top. Else malloc-copy-free */
+size_t released = 0;
+msegmentptr pred = &m->seg;
-if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) &&
+msegmentptr sp = pred->next;
-ok_next(oldp, next) && ok_pinuse(next))) {
+while (sp != 0) {
-size_t nb = request2size(bytes);
+char *base = sp->base;
-if (is_mmapped(oldp))
+size_t size = sp->size;
-newp = mmap_resize(m, oldp, nb);
+msegmentptr next = sp->next;
-else if (oldsize >= nb) { /* already big enough */
+if (is_mmapped_segment(sp) && !is_extern_segment(sp)) {
-size_t rsize = oldsize - nb;
+mchunkptr p = align_as_chunk(base);
-newp = oldp;
+size_t psize = chunksize(p);
-if (rsize >= MIN_CHUNK_SIZE) {
+/* Can unmap if first chunk holds entire segment and not pinned */
-mchunkptr remainder = chunk_plus_offset(newp, nb);
+if (!cinuse(p)
-set_inuse(m, newp, nb);
+&& (char *) p + psize >= base + size - TOP_FOOT_SIZE) {
-set_inuse(m, remainder, rsize);
+tchunkptr tp = (tchunkptr) p;
-extra = chunk2mem(remainder);
+assert(segment_holds(sp, (char *) sp));
+if (p == m->dv) {
+m->dv = 0;
+m->dvsize = 0;
+} else {
+unlink_large_chunk(m, tp);
+}
+if (CALL_MUNMAP(base, size) == 0) {
+released += size;
+m->footprint -= size;
+/* unlink obsoleted record */
+sp = pred;
+sp->next = next;
+} else {        /* back out if cannot unmap */
+insert_large_chunk(m, tp, psize);
+}
+}
 }
-}
+pred = sp;
-else if (next == m->top && oldsize + m->topsize > nb) {
+sp = next;
-/* Expand into top */
+}
-size_t newsize = oldsize + m->topsize;
+return released;
-size_t newtopsize = newsize - nb;
+}
-mchunkptr newtop = chunk_plus_offset(oldp, nb);
-set_inuse(m, oldp, nb);
+static int
-newtop->head = newtopsize |PINUSE_BIT;
+sys_trim(mstate m, size_t pad)
-m->top = newtop;
+{
-m->topsize = newtopsize;
+size_t released = 0;
-newp = oldp;
+if (pad < MAX_REQUEST && is_initialized(m)) {
-}
+pad += TOP_FOOT_SIZE;   /* ensure enough room for segment overhead */
-}
-else {
+if (m->topsize > pad) {
-USAGE_ERROR_ACTION(m, oldmem);
+/* Shrink top space in granularity-size units, keeping at least one */
-POSTACTION(m);
+size_t unit = mparams.granularity;
-return 0;
+size_t extra =
-}
+((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
+SIZE_T_ONE) * unit;
+msegmentptr sp = segment_holding(m, (char *) m->top);
+if (!is_extern_segment(sp)) {
+if (is_mmapped_segment(sp)) {
+if (HAVE_MMAP && sp->size >= extra && !has_segment_link(m, sp)) {   /* can't shrink if pinned */
+size_t newsize = sp->size - extra;
+/* Prefer mremap, fall back to munmap */
+if ((CALL_MREMAP
+(sp->base, sp->size, newsize, 0) != MFAIL)
+|| (CALL_MUNMAP(sp->base + newsize, extra)
+== 0)) {
+released = extra;
+}
+}
+} else if (HAVE_MORECORE) {
+if (extra >= HALF_MAX_SIZE_T)       /* Avoid wrapping negative */
+extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit;
+ACQUIRE_MORECORE_LOCK();
+{
+/* Make sure end of memory is where we last set it. */
+char *old_br = (char *) (CALL_MORECORE(0));
+if (old_br == sp->base + sp->size) {
+char *rel_br = (char *) (CALL_MORECORE(-extra));
+char *new_br = (char *) (CALL_MORECORE(0));
+if (rel_br != CMFAIL && new_br < old_br)
+released = old_br - new_br;
+}
+}
+RELEASE_MORECORE_LOCK();
+}
+}
+if (released != 0) {
+sp->size -= released;
+m->footprint -= released;
+init_top(m, m->top, m->topsize - released);
+check_top_chunk(m, m->top);
+}
+}
+/* Unmap any unused mmapped segments */
+if (HAVE_MMAP)
+released += release_unused_segments(m);
+/* On failure, disable autotrim to avoid repeated failed future calls */
+if (released == 0)
+m->trim_check = MAX_SIZE_T;
+}
+return (released != 0) ? 1 : 0;
+}
+/* ---------------------------- malloc support --------------------------- */
+/* allocate a large request from the best fitting chunk in a treebin */
+static void *
+tmalloc_large(mstate m, size_t nb)
+{
+tchunkptr v = 0;
+size_t rsize = -nb;         /* Unsigned negation */
+tchunkptr t;
+bindex_t idx;
+compute_tree_index(nb, idx);
+if ((t = *treebin_at(m, idx)) != 0) {
+/* Traverse tree for this bin looking for node with size == nb */
+size_t sizebits = nb << leftshift_for_tree_index(idx);
+tchunkptr rst = 0;      /* The deepest untaken right subtree */
+for (;;) {
+tchunkptr rt;
+size_t trem = chunksize(t) - nb;
+if (trem < rsize) {
+v = t;
+if ((rsize = trem) == 0)
+break;
+}
+rt = t->child[1];
+t = t->child[(sizebits >> (SIZE_T_BITSIZE - SIZE_T_ONE)) & 1];
+if (rt != 0 && rt != t)
+rst = rt;
+if (t == 0) {
+t = rst;        /* set t to least subtree holding sizes > nb */
+break;
+}
+sizebits <<= 1;
+}
+}
+if (t == 0 && v == 0) {     /* set t to root of next non-empty treebin */
+binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap;
+if (leftbits != 0) {
+bindex_t i;
+binmap_t leastbit = least_bit(leftbits);
+compute_bit2idx(leastbit, i);
+t = *treebin_at(m, i);
+}
+}
+while (t != 0) {            /* find smallest of tree or subtree */
+size_t trem = chunksize(t) - nb;
+if (trem < rsize) {
+rsize = trem;
+v = t;
+}
+t = leftmost_child(t);
+}
+/*  If dv is a better fit, return 0 so malloc will use it */
+if (v != 0 && rsize < (size_t) (m->dvsize - nb)) {
+if (RTCHECK(ok_address(m, v))) {        /* split */
+mchunkptr r = chunk_plus_offset(v, nb);
+assert(chunksize(v) == rsize + nb);
+if (RTCHECK(ok_next(v, r))) {
+unlink_large_chunk(m, v);
+if (rsize < MIN_CHUNK_SIZE)
+set_inuse_and_pinuse(m, v, (rsize + nb));
+else {
+set_size_and_pinuse_of_inuse_chunk(m, v, nb);
+set_size_and_pinuse_of_free_chunk(r, rsize);
+insert_chunk(m, r, rsize);
+}
+return chunk2mem(v);
+}
+}
+CORRUPTION_ERROR_ACTION(m);
+}
+return 0;
+}
+/* allocate a small request from the best fitting chunk in a treebin */
+static void *
+tmalloc_small(mstate m, size_t nb)
+{
+tchunkptr t, v;
+size_t rsize;
+bindex_t i;
+binmap_t leastbit = least_bit(m->treemap);
+compute_bit2idx(leastbit, i);
+v = t = *treebin_at(m, i);
+rsize = chunksize(t) - nb;
+while ((t = leftmost_child(t)) != 0) {
+size_t trem = chunksize(t) - nb;
+if (trem < rsize) {
+rsize = trem;
+v = t;
+}
+}
+if (RTCHECK(ok_address(m, v))) {
+mchunkptr r = chunk_plus_offset(v, nb);
+assert(chunksize(v) == rsize + nb);
+if (RTCHECK(ok_next(v, r))) {
+unlink_large_chunk(m, v);
+if (rsize < MIN_CHUNK_SIZE)
+set_inuse_and_pinuse(m, v, (rsize + nb));
+else {
+set_size_and_pinuse_of_inuse_chunk(m, v, nb);
+set_size_and_pinuse_of_free_chunk(r, rsize);
+replace_dv(m, r, rsize);
+}
+return chunk2mem(v);
+}
+}
+CORRUPTION_ERROR_ACTION(m);
+return 0;
+}
+/* --------------------------- realloc support --------------------------- */
+static void *
+internal_realloc(mstate m, void *oldmem, size_t bytes)
+{
+if (bytes >= MAX_REQUEST) {
+MALLOC_FAILURE_ACTION;
+return 0;
+}
+if (!PREACTION(m)) {
+mchunkptr oldp = mem2chunk(oldmem);
+size_t oldsize = chunksize(oldp);
+mchunkptr next = chunk_plus_offset(oldp, oldsize);
+mchunkptr newp = 0;
+void *extra = 0;
+/* Try to either shrink or extend into top. Else malloc-copy-free */
+if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) &&
+ok_next(oldp, next) && ok_pinuse(next))) {
+size_t nb = request2size(bytes);
+if (is_mmapped(oldp))
+newp = mmap_resize(m, oldp, nb);
+else if (oldsize >= nb) {   /* already big enough */
+size_t rsize = oldsize - nb;
+newp = oldp;
+if (rsize >= MIN_CHUNK_SIZE) {
+mchunkptr remainder = chunk_plus_offset(newp, nb);
+set_inuse(m, newp, nb);
+set_inuse(m, remainder, rsize);
+extra = chunk2mem(remainder);
+}
+} else if (next == m->top && oldsize + m->topsize > nb) {
+/* Expand into top */
+size_t newsize = oldsize + m->topsize;
+size_t newtopsize = newsize - nb;
+mchunkptr newtop = chunk_plus_offset(oldp, nb);
+set_inuse(m, oldp, nb);
+newtop->head = newtopsize | PINUSE_BIT;
+m->top = newtop;
+m->topsize = newtopsize;
+newp = oldp;
+}
+} else {
+USAGE_ERROR_ACTION(m, oldmem);
+POSTACTION(m);
+return 0;
+}
+POSTACTION(m);
+if (newp != 0) {
+if (extra != 0) {
+internal_free(m, extra);
+}
+check_inuse_chunk(m, newp);
+return chunk2mem(newp);
+} else {
+void *newmem = internal_malloc(m, bytes);
+if (newmem != 0) {
+size_t oc = oldsize - overhead_for(oldp);
+memcpy(newmem, oldmem, (oc < bytes) ? oc : bytes);
+internal_free(m, oldmem);
+}
+return newmem;
+}
+}
+return 0;
+}
+/* --------------------------- memalign support -------------------------- */
+static void *
+internal_memalign(mstate m, size_t alignment, size_t bytes)
+{
+if (alignment <= MALLOC_ALIGNMENT)  /* Can just use malloc */
+return internal_malloc(m, bytes);
+if (alignment < MIN_CHUNK_SIZE)     /* must be at least a minimum chunk size */
+alignment = MIN_CHUNK_SIZE;
+if ((alignment & (alignment - SIZE_T_ONE)) != 0) {  /* Ensure a power of 2 */
+size_t a = MALLOC_ALIGNMENT << 1;
+while (a < alignment)
+a <<= 1;
+alignment = a;
+}
+if (bytes >= MAX_REQUEST - alignment) {
+if (m != 0) {           /* Test isn't needed but avoids compiler warning */
+MALLOC_FAILURE_ACTION;
+}
+} else {
+size_t nb = request2size(bytes);
+size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
+char *mem = (char *) internal_malloc(m, req);
+if (mem != 0) {
+void *leader = 0;
+void *trailer = 0;
+mchunkptr p = mem2chunk(mem);
+if (PREACTION(m))
+return 0;
+if ((((size_t) (mem)) % alignment) != 0) {  /* misaligned */
+/*
+Find an aligned spot inside chunk.  Since we need to give
+back leading space in a chunk of at least MIN_CHUNK_SIZE, if
+the first calculation places us at a spot with less than
+MIN_CHUNK_SIZE leader, we can move to the next aligned spot.
+We've allocated enough total room so that this is always
+possible.
+*/
+char *br = (char *)
+mem2chunk((size_t)
+(((size_t)
+(mem + alignment -
+SIZE_T_ONE)) & -alignment));
+char *pos =
+((size_t) (br - (char *) (p)) >=
+MIN_CHUNK_SIZE) ? br : br + alignment;
+mchunkptr newp = (mchunkptr) pos;
+size_t leadsize = pos - (char *) (p);
+size_t newsize = chunksize(p) - leadsize;
+if (is_mmapped(p)) {    /* For mmapped chunks, just adjust offset */
+newp->prev_foot = p->prev_foot + leadsize;
+newp->head = (newsize | CINUSE_BIT);
+} else {        /* Otherwise, give back leader, use the rest */
+set_inuse(m, newp, newsize);
+set_inuse(m, p, leadsize);
+leader = chunk2mem(p);
+}
+p = newp;
+}
+/* Give back spare room at the end */
+if (!is_mmapped(p)) {
+size_t size = chunksize(p);
+if (size > nb + MIN_CHUNK_SIZE) {
+size_t remainder_size = size - nb;
+mchunkptr remainder = chunk_plus_offset(p, nb);
+set_inuse(m, p, nb);
+set_inuse(m, remainder, remainder_size);
+trailer = chunk2mem(remainder);
+}
+}
+assert(chunksize(p) >= nb);
+assert((((size_t) (chunk2mem(p))) % alignment) == 0);
+check_inuse_chunk(m, p);
+POSTACTION(m);
+if (leader != 0) {
+internal_free(m, leader);
+}
+if (trailer != 0) {
+internal_free(m, trailer);
+}
+return chunk2mem(p);
+}
+}
+return 0;
+}
+/* ------------------------ comalloc/coalloc support --------------------- */
+static void **
+ialloc(mstate m, size_t n_elements, size_t * sizes, int opts, void *chunks[])
+{
+/*
+This provides common support for independent_X routines, handling
+all of the combinations that can result.
+The opts arg has:
+bit 0 set if all elements are same size (using sizes[0])
+bit 1 set if elements should be zeroed
+*/
+size_t element_size;        /* chunksize of each element, if all same */
+size_t contents_size;       /* total size of elements */
+size_t array_size;          /* request size of pointer array */
+void *mem;                  /* malloced aggregate space */
+mchunkptr p;                /* corresponding chunk */
+size_t remainder_size;      /* remaining bytes while splitting */
+void **marray;              /* either "chunks" or malloced ptr array */
+mchunkptr array_chunk;      /* chunk for malloced ptr array */
+flag_t was_enabled;         /* to disable mmap */
+size_t size;
+size_t i;
+/* compute array length, if needed */
+if (chunks != 0) {
+if (n_elements == 0)
+return chunks;      /* nothing to do */
+marray = chunks;
+array_size = 0;
+} else {
+/* if empty req, must still return chunk representing empty array */
+if (n_elements == 0)
+return (void **) internal_malloc(m, 0);
+marray = 0;
+array_size = request2size(n_elements * (sizeof(void *)));
+}
+/* compute total element size */
+if (opts & 0x1) {           /* all-same-size */
+element_size = request2size(*sizes);
+contents_size = n_elements * element_size;
+} else {                    /* add up all the sizes */
+element_size = 0;
+contents_size = 0;
+for (i = 0; i != n_elements; ++i)
+contents_size += request2size(sizes[i]);
+}
+size = contents_size + array_size;
+/*
+Allocate the aggregate chunk.  First disable direct-mmapping so
+malloc won't use it, since we would not be able to later
+free/realloc space internal to a segregated mmap region.
+*/
+was_enabled = use_mmap(m);
+disable_mmap(m);
+mem = internal_malloc(m, size - CHUNK_OVERHEAD);
+if (was_enabled)
+enable_mmap(m);
+if (mem == 0)
+return 0;
+if (PREACTION(m))
+return 0;
+p = mem2chunk(mem);
+remainder_size = chunksize(p);
+assert(!is_mmapped(p));
+if (opts & 0x2) {           /* optionally clear the elements */
+memset((size_t *) mem, 0, remainder_size - SIZE_T_SIZE - array_size);
+}
+/* If not provided, allocate the pointer array as final part of chunk */
+if (marray == 0) {
+size_t array_chunk_size;
+array_chunk = chunk_plus_offset(p, contents_size);
+array_chunk_size = remainder_size - contents_size;
+marray = (void **) (chunk2mem(array_chunk));
+set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
+remainder_size = contents_size;
+}
+/* split out elements */
+for (i = 0;; ++i) {
+marray[i] = chunk2mem(p);
+if (i != n_elements - 1) {
+if (element_size != 0)
+size = element_size;
+else
+size = request2size(sizes[i]);
+remainder_size -= size;
+set_size_and_pinuse_of_inuse_chunk(m, p, size);
+p = chunk_plus_offset(p, size);
+} else {                /* the final element absorbs any overallocation slop */
+set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
+break;
+}
+}
+#if DEBUG
+if (marray != chunks) {
+/* final element must have exactly exhausted chunk */
+if (element_size != 0) {
+assert(remainder_size == element_size);
+} else {
+assert(remainder_size == request2size(sizes[i]));
+}
+check_inuse_chunk(m, mem2chunk(marray));
+}
+for (i = 0; i != n_elements; ++i)
+check_inuse_chunk(m, mem2chunk(marray[i]));
+#endif /* DEBUG */
 POSTACTION(m);
+return marray;
-if (newp != 0) {
-if (extra != 0) {
-internal_free(m, extra);
-}
-check_inuse_chunk(m, newp);
-return chunk2mem(newp);
-}
-else {
-void* newmem = internal_malloc(m, bytes);
-if (newmem != 0) {
-size_t oc = oldsize - overhead_for(oldp);
-memcpy(newmem, oldmem, (oc < bytes)? oc : bytes);
-internal_free(m, oldmem);
-}
-return newmem;
-}
-}
-return 0;
-}
-/* --------------------------- memalign support -------------------------- */
-static void* internal_memalign(mstate m, size_t alignment, size_t bytes) {
-if (alignment <= MALLOC_ALIGNMENT)    /* Can just use malloc */
-return internal_malloc(m, bytes);
-if (alignment <  MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */
-alignment = MIN_CHUNK_SIZE;
-if ((alignment & (alignment-SIZE_T_ONE)) != 0) {/* Ensure a power of 2 */
-size_t a = MALLOC_ALIGNMENT << 1;
-while (a < alignment) a <<= 1;
-alignment = a;
-}
-if (bytes >= MAX_REQUEST - alignment) {
-if (m != 0)  { /* Test isn't needed but avoids compiler warning */
-MALLOC_FAILURE_ACTION;
-}
-}
-else {
-size_t nb = request2size(bytes);
-size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
-char* mem = (char*)internal_malloc(m, req);
-if (mem != 0) {
-void* leader = 0;
-void* trailer = 0;
-mchunkptr p = mem2chunk(mem);
-if (PREACTION(m)) return 0;
-if ((((size_t)(mem)) % alignment) != 0) { /* misaligned */
-/*
-Find an aligned spot inside chunk.  Since we need to give
-back leading space in a chunk of at least MIN_CHUNK_SIZE, if
-the first calculation places us at a spot with less than
-MIN_CHUNK_SIZE leader, we can move to the next aligned spot.
-We've allocated enough total room so that this is always
-possible.
-*/
-char* br = (char*)mem2chunk((size_t)(((size_t)(mem +
-alignment -
-SIZE_T_ONE)) &
--alignment));
-char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE)?
-br : br+alignment;
-mchunkptr newp = (mchunkptr)pos;
-size_t leadsize = pos - (char*)(p);
-size_t newsize = chunksize(p) - leadsize;
-if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */
-newp->prev_foot = p->prev_foot + leadsize;
-newp->head = (newsize|CINUSE_BIT);
-}
-else { /* Otherwise, give back leader, use the rest */
-set_inuse(m, newp, newsize);
-set_inuse(m, p, leadsize);
-leader = chunk2mem(p);
-}
-p = newp;
-}
-/* Give back spare room at the end */
-if (!is_mmapped(p)) {
-size_t size = chunksize(p);
-if (size > nb + MIN_CHUNK_SIZE) {
-size_t remainder_size = size - nb;
-mchunkptr remainder = chunk_plus_offset(p, nb);
-set_inuse(m, p, nb);
-set_inuse(m, remainder, remainder_size);
-trailer = chunk2mem(remainder);
-}
-}
-assert (chunksize(p) >= nb);
-assert((((size_t)(chunk2mem(p))) % alignment) == 0);
-check_inuse_chunk(m, p);
-POSTACTION(m);
-if (leader != 0) {
-internal_free(m, leader);
-}
-if (trailer != 0) {
-internal_free(m, trailer);
-}
-return chunk2mem(p);
-}
-}
-return 0;
-}
-/* ------------------------ comalloc/coalloc support --------------------- */
-static void** ialloc(mstate m,
-size_t n_elements,
-size_t* sizes,
-int opts,
-void* chunks[]) {
-/*
-This provides common support for independent_X routines, handling
-all of the combinations that can result.
-The opts arg has:
-bit 0 set if all elements are same size (using sizes[0])
-bit 1 set if elements should be zeroed
-*/
-size_t    element_size;   /* chunksize of each element, if all same */
-size_t    contents_size;  /* total size of elements */
-size_t    array_size;     /* request size of pointer array */
-void*     mem;            /* malloced aggregate space */
-mchunkptr p;              /* corresponding chunk */
-size_t    remainder_size; /* remaining bytes while splitting */
-void**    marray;         /* either "chunks" or malloced ptr array */
-mchunkptr array_chunk;    /* chunk for malloced ptr array */
-flag_t    was_enabled;    /* to disable mmap */
-size_t    size;
-size_t    i;
-/* compute array length, if needed */
-if (chunks != 0) {
-if (n_elements == 0)
-return chunks; /* nothing to do */
-marray = chunks;
-array_size = 0;
-}
-else {
-/* if empty req, must still return chunk representing empty array */
-if (n_elements == 0)
-return (void**)internal_malloc(m, 0);
-marray = 0;
-array_size = request2size(n_elements * (sizeof(void*)));
-}
-/* compute total element size */
-if (opts & 0x1) { /* all-same-size */
-element_size = request2size(*sizes);
-contents_size = n_elements * element_size;
-}
-else { /* add up all the sizes */
-element_size = 0;
-contents_size = 0;
-for (i = 0; i != n_elements; ++i)
-contents_size += request2size(sizes[i]);
-}
-size = contents_size + array_size;
-/*
-Allocate the aggregate chunk.  First disable direct-mmapping so
-malloc won't use it, since we would not be able to later
-free/realloc space internal to a segregated mmap region.
-*/
-was_enabled = use_mmap(m);
-disable_mmap(m);
-mem = internal_malloc(m, size - CHUNK_OVERHEAD);
-if (was_enabled)
-enable_mmap(m);
-if (mem == 0)
-return 0;
-if (PREACTION(m)) return 0;
-p = mem2chunk(mem);
-remainder_size = chunksize(p);
-assert(!is_mmapped(p));
-if (opts & 0x2) {       /* optionally clear the elements */
-memset((size_t*)mem, 0, remainder_size - SIZE_T_SIZE - array_size);
-}
-/* If not provided, allocate the pointer array as final part of chunk */
-if (marray == 0) {
-size_t  array_chunk_size;
-array_chunk = chunk_plus_offset(p, contents_size);
-array_chunk_size = remainder_size - contents_size;
-marray = (void**) (chunk2mem(array_chunk));
-set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
-remainder_size = contents_size;
-}
-/* split out elements */
-for (i = 0; ; ++i) {
-marray[i] = chunk2mem(p);
-if (i != n_elements-1) {
-if (element_size != 0)
-size = element_size;
-else
-size = request2size(sizes[i]);
-remainder_size -= size;
-set_size_and_pinuse_of_inuse_chunk(m, p, size);
-p = chunk_plus_offset(p, size);
-}
-else { /* the final element absorbs any overallocation slop */
-set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
-break;
-}
-}
-#if DEBUG
-if (marray != chunks) {
-/* final element must have exactly exhausted chunk */
-if (element_size != 0) {
-assert(remainder_size == element_size);
-}
-else {
-assert(remainder_size == request2size(sizes[i]));
-}
-check_inuse_chunk(m, mem2chunk(marray));
-}
-for (i = 0; i != n_elements; ++i)
-check_inuse_chunk(m, mem2chunk(marray[i]));
-#endif /* DEBUG */
-POSTACTION(m);
-return marray;
 }
 /* -------------------------- public routines ---------------------------- */
 #if !ONLY_MSPACES
-void* dlmalloc(size_t bytes) {
+void *
-/*
+dlmalloc(size_t bytes)
-Basic algorithm:
+{
-If a small request (< 256 bytes minus per-chunk overhead):
+/*
+Basic algorithm:
+If a small request (< 256 bytes minus per-chunk overhead):
 1. If one exists, use a remainderless chunk in associated smallbin.
 (Remainderless means that there are too few excess bytes to
 represent as a chunk.)
 2. If it is big enough, use the dv chunk, which is normally the
 chunk adjacent to the one used for the most recent small request.
 3. If one exists, split the smallest available chunk in a bin,
 saving remainder in dv.
 4. If it is big enough, use the top chunk.
 5. If available, get memory from system and use it
 Otherwise, for a large request:
 1. Find the smallest available binned chunk that fits, and use it
 if it is better fitting than dv chunk, splitting if necessary.
 2. If better fitting than any binned chunk, use the dv chunk.
 3. If it is big enough, use the top chunk.
 4. If request size >= mmap threshold, try to directly mmap this chunk.
 5. If available, get memory from system and use it
 The ugly goto's here ensure that postaction occurs along all paths.
 */
 if (!PREACTION(gm)) {
-void* mem;
+void *mem;
 size_t nb;
 if (bytes <= MAX_SMALL_REQUEST) {
 bindex_t idx;
 binmap_t smallbits;
-nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
+nb = (bytes < MIN_REQUEST) ? MIN_CHUNK_SIZE : pad_request(bytes);
 idx = small_index(nb);
 smallbits = gm->smallmap >> idx;
-if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
+if ((smallbits & 0x3U) != 0) {      /* Remainderless fit to a smallbin. */
 mchunkptr b, p;
-idx += ~smallbits & 1;       /* Uses next bin if idx empty */
+idx += ~smallbits & 1;  /* Uses next bin if idx empty */
 b = smallbin_at(gm, idx);
 p = b->fd;
 assert(chunksize(p) == small_index2size(idx));
 unlink_first_small_chunk(gm, b, p, idx);
 set_inuse_and_pinuse(gm, p, small_index2size(idx));
 mem = chunk2mem(p);
 check_malloced_chunk(gm, mem, nb);
 goto postaction;
 }
 else if (nb > gm->dvsize) {
-if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
+if (smallbits != 0) {   /* Use chunk in next nonempty smallbin */
 mchunkptr b, p, r;
 size_t rsize;
 bindex_t i;
-binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
+binmap_t leftbits =
-binmap_t leastbit = least_bit(leftbits);
+(smallbits << idx) & left_bits(idx2bit(idx));
-compute_bit2idx(leastbit, i);
+binmap_t leastbit = least_bit(leftbits);
-b = smallbin_at(gm, i);
+compute_bit2idx(leastbit, i);
-p = b->fd;
+b = smallbin_at(gm, i);
-assert(chunksize(p) == small_index2size(i));
+p = b->fd;
-unlink_first_small_chunk(gm, b, p, i);
+assert(chunksize(p) == small_index2size(i));
-rsize = small_index2size(i) - nb;
+unlink_first_small_chunk(gm, b, p, i);
-/* Fit here cannot be remainderless if 4byte sizes */
+rsize = small_index2size(i) - nb;
-if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
+/* Fit here cannot be remainderless if 4byte sizes */
-set_inuse_and_pinuse(gm, p, small_index2size(i));
+if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
-else {
+set_inuse_and_pinuse(gm, p, small_index2size(i));
+else {
+set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
+r = chunk_plus_offset(p, nb);
+set_size_and_pinuse_of_free_chunk(r, rsize);
+replace_dv(gm, r, rsize);
+}
+mem = chunk2mem(p);
+check_malloced_chunk(gm, mem, nb);
+goto postaction;
+}
+else if (gm->treemap != 0
+&& (mem = tmalloc_small(gm, nb)) != 0) {
+check_malloced_chunk(gm, mem, nb);
+goto postaction;
+}
+}
+} else if (bytes >= MAX_REQUEST)
+nb = MAX_SIZE_T;    /* Too big to allocate. Force failure (in sys alloc) */
+else {
+nb = pad_request(bytes);
+if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) {
+check_malloced_chunk(gm, mem, nb);
+goto postaction;
+}
+}
+if (nb <= gm->dvsize) {
+size_t rsize = gm->dvsize - nb;
+mchunkptr p = gm->dv;
+if (rsize >= MIN_CHUNK_SIZE) {      /* split dv */
+mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
+gm->dvsize = rsize;
+set_size_and_pinuse_of_free_chunk(r, rsize);
+set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
+} else {            /* exhaust dv */
+size_t dvs = gm->dvsize;
+gm->dvsize = 0;
+gm->dv = 0;
+set_inuse_and_pinuse(gm, p, dvs);
+}
+mem = chunk2mem(p);
+check_malloced_chunk(gm, mem, nb);
+goto postaction;
+}
+else if (nb < gm->topsize) {    /* Split top */
+size_t rsize = gm->topsize -= nb;
+mchunkptr p = gm->top;
+mchunkptr r = gm->top = chunk_plus_offset(p, nb);
+r->head = rsize | PINUSE_BIT;
 set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
-r = chunk_plus_offset(p, nb);
+mem = chunk2mem(p);
-set_size_and_pinuse_of_free_chunk(r, rsize);
+check_top_chunk(gm, gm->top);
-replace_dv(gm, r, rsize);
+check_malloced_chunk(gm, mem, nb);
-}
+goto postaction;
-mem = chunk2mem(p);
-check_malloced_chunk(gm, mem, nb);
-goto postaction;
 }
-else if (gm->treemap != 0 && (mem = tmalloc_small(gm, nb)) != 0) {
+mem = sys_alloc(gm, nb);
-check_malloced_chunk(gm, mem, nb);
-goto postaction;
+postaction:
+POSTACTION(gm);
+return mem;
+}
+return 0;
+}
+void
+dlfree(void *mem)
+{
+/*
+Consolidate freed chunks with preceeding or succeeding bordering
+free chunks, if they exist, and then place in a bin.  Intermixed
+with special cases for top, dv, mmapped chunks, and usage errors.
+*/
+if (mem != 0) {
+mchunkptr p = mem2chunk(mem);
+#if FOOTERS
+mstate fm = get_mstate_for(p);
+if (!ok_magic(fm)) {
+USAGE_ERROR_ACTION(fm, p);
+return;
 }
-}
-}
-else if (bytes >= MAX_REQUEST)
-nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
-else {
-nb = pad_request(bytes);
-if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) {
-check_malloced_chunk(gm, mem, nb);
-goto postaction;
-}
-}
-if (nb <= gm->dvsize) {
-size_t rsize = gm->dvsize - nb;
-mchunkptr p = gm->dv;
-if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
-mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
-gm->dvsize = rsize;
-set_size_and_pinuse_of_free_chunk(r, rsize);
-set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
-}
-else { /* exhaust dv */
-size_t dvs = gm->dvsize;
-gm->dvsize = 0;
-gm->dv = 0;
-set_inuse_and_pinuse(gm, p, dvs);
-}
-mem = chunk2mem(p);
-check_malloced_chunk(gm, mem, nb);
-goto postaction;
-}
-else if (nb < gm->topsize) { /* Split top */
-size_t rsize = gm->topsize -= nb;
-mchunkptr p = gm->top;
-mchunkptr r = gm->top = chunk_plus_offset(p, nb);
-r->head = rsize | PINUSE_BIT;
-set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
-mem = chunk2mem(p);
-check_top_chunk(gm, gm->top);
-check_malloced_chunk(gm, mem, nb);
-goto postaction;
-}
-mem = sys_alloc(gm, nb);
-postaction:
-POSTACTION(gm);
-return mem;
-}
-return 0;
-}
-void dlfree(void* mem) {
-/*
-Consolidate freed chunks with preceeding or succeeding bordering
-free chunks, if they exist, and then place in a bin.  Intermixed
-with special cases for top, dv, mmapped chunks, and usage errors.
-*/
-if (mem != 0) {
-mchunkptr p  = mem2chunk(mem);
-#if FOOTERS
-mstate fm = get_mstate_for(p);
-if (!ok_magic(fm)) {
-USAGE_ERROR_ACTION(fm, p);
-return;
-}
 #else /* FOOTERS */
 #define fm gm
 #endif /* FOOTERS */
 if (!PREACTION(fm)) {
 check_inuse_chunk(fm, p);
 if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
 size_t psize = chunksize(p);
 mchunkptr next = chunk_plus_offset(p, psize);
 if (!pinuse(p)) {
 size_t prevsize = p->prev_foot;
 if ((prevsize & IS_MMAPPED_BIT) != 0) {
 prevsize &= ~IS_MMAPPED_BIT;
 psize += prevsize + MMAP_FOOT_PAD;
-if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
+if (CALL_MUNMAP((char *) p - prevsize, psize) == 0)
 fm->footprint -= psize;
 goto postaction;
-}
+} else {
-else {
+mchunkptr prev = chunk_minus_offset(p, prevsize);
-mchunkptr prev = chunk_minus_offset(p, prevsize);
+psize += prevsize;
-psize += prevsize;
+p = prev;
-p = prev;
+if (RTCHECK(ok_address(fm, prev))) {    /* consolidate backward */
-if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
+if (p != fm->dv) {
-if (p != fm->dv) {
+unlink_chunk(fm, p, prevsize);
-unlink_chunk(fm, p, prevsize);
+} else if ((next->head & INUSE_BITS) ==
-}
+INUSE_BITS) {
-else if ((next->head & INUSE_BITS) == INUSE_BITS) {
+fm->dvsize = psize;
-fm->dvsize = psize;
+set_free_with_pinuse(p, psize, next);
-set_free_with_pinuse(p, psize, next);
+goto postaction;
-goto postaction;
+}
-}
+} else
+goto erroraction;
+}
+}
+if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
+if (!cinuse(next)) {        /* consolidate forward */
+if (next == fm->top) {
+size_t tsize = fm->topsize += psize;
+fm->top = p;
+p->head = tsize | PINUSE_BIT;
+if (p == fm->dv) {
+fm->dv = 0;
+fm->dvsize = 0;
+}
+if (should_trim(fm, tsize))
+sys_trim(fm, 0);
+goto postaction;
+} else if (next == fm->dv) {
+size_t dsize = fm->dvsize += psize;
+fm->dv = p;
+set_size_and_pinuse_of_free_chunk(p, dsize);
+goto postaction;
+} else {
+size_t nsize = chunksize(next);
+psize += nsize;
+unlink_chunk(fm, next, nsize);
+set_size_and_pinuse_of_free_chunk(p, psize);
+if (p == fm->dv) {
+fm->dvsize = psize;
+goto postaction;
+}
+}
+} else
+set_free_with_pinuse(p, psize, next);
+insert_chunk(fm, p, psize);
+check_free_chunk(fm, p);
+goto postaction;
+}
 }
-else
+erroraction:
-goto erroraction;
+USAGE_ERROR_ACTION(fm, p);
-}
+postaction:
+POSTACTION(fm);
 }
+}
-if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
-if (!cinuse(next)) {  /* consolidate forward */
-if (next == fm->top) {
-size_t tsize = fm->topsize += psize;
-fm->top = p;
-p->head = tsize | PINUSE_BIT;
-if (p == fm->dv) {
-fm->dv = 0;
-fm->dvsize = 0;
-}
-if (should_trim(fm, tsize))
-sys_trim(fm, 0);
-goto postaction;
-}
-else if (next == fm->dv) {
-size_t dsize = fm->dvsize += psize;
-fm->dv = p;
-set_size_and_pinuse_of_free_chunk(p, dsize);
-goto postaction;
-}
-else {
-size_t nsize = chunksize(next);
-psize += nsize;
-unlink_chunk(fm, next, nsize);
-set_size_and_pinuse_of_free_chunk(p, psize);
-if (p == fm->dv) {
-fm->dvsize = psize;
-goto postaction;
-}
-}
-}
-else
-set_free_with_pinuse(p, psize, next);
-insert_chunk(fm, p, psize);
-check_free_chunk(fm, p);
-goto postaction;
-}
-}
-erroraction:
-USAGE_ERROR_ACTION(fm, p);
-postaction:
-POSTACTION(fm);
-}
-}
 #if !FOOTERS
 #undef fm
 #endif /* FOOTERS */
 }
-void* dlcalloc(size_t n_elements, size_t elem_size) {
+void *
-void* mem;
+dlcalloc(size_t n_elements, size_t elem_size)
-size_t req = 0;
+{
-if (n_elements != 0) {
+void *mem;
-req = n_elements * elem_size;
+size_t req = 0;
-if (((n_elements | elem_size) & ~(size_t)0xffff) &&
+if (n_elements != 0) {
-(req / n_elements != elem_size))
+req = n_elements * elem_size;
-req = MAX_SIZE_T; /* force downstream failure on overflow */
+if (((n_elements | elem_size) & ~(size_t) 0xffff) &&
-}
+(req / n_elements != elem_size))
-mem = dlmalloc(req);
+req = MAX_SIZE_T;   /* force downstream failure on overflow */
-if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
+}
-memset(mem, 0, req);
+mem = dlmalloc(req);
-return mem;
+if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
-}
+memset(mem, 0, req);
+return mem;
-void* dlrealloc(void* oldmem, size_t bytes) {
+}
-if (oldmem == 0)
-return dlmalloc(bytes);
+void *
+dlrealloc(void *oldmem, size_t bytes)
+{
+if (oldmem == 0)
+return dlmalloc(bytes);
 #ifdef REALLOC_ZERO_BYTES_FREES
 if (bytes == 0) {
 dlfree(oldmem);
+return 0;
+}
+#endif /* REALLOC_ZERO_BYTES_FREES */
+else {
+#if ! FOOTERS
+mstate m = gm;
+#else /* FOOTERS */
+mstate m = get_mstate_for(mem2chunk(oldmem));
+if (!ok_magic(m)) {
+USAGE_ERROR_ACTION(m, oldmem);
+return 0;
+}
+#endif /* FOOTERS */
+return internal_realloc(m, oldmem, bytes);
+}
+}
+void *
+dlmemalign(size_t alignment, size_t bytes)
+{
+return internal_memalign(gm, alignment, bytes);
+}
+void **
+dlindependent_calloc(size_t n_elements, size_t elem_size, void *chunks[])
+{
+size_t sz = elem_size;      /* serves as 1-element array */
+return ialloc(gm, n_elements, &sz, 3, chunks);
+}
+void **
+dlindependent_comalloc(size_t n_elements, size_t sizes[], void *chunks[])
+{
+return ialloc(gm, n_elements, sizes, 0, chunks);
+}
+void *
+dlvalloc(size_t bytes)
+{
+size_t pagesz;
+init_mparams();
+pagesz = mparams.page_size;
+return dlmemalign(pagesz, bytes);
+}
+void *
+dlpvalloc(size_t bytes)
+{
+size_t pagesz;
+init_mparams();
+pagesz = mparams.page_size;
+return dlmemalign(pagesz,
+(bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
+}
+int
+dlmalloc_trim(size_t pad)
+{
+int result = 0;
+if (!PREACTION(gm)) {
+result = sys_trim(gm, pad);
+POSTACTION(gm);
+}
+return result;
+}
+size_t
+dlmalloc_footprint(void)
+{
+return gm->footprint;
+}
+size_t
+dlmalloc_max_footprint(void)
+{
+return gm->max_footprint;
+}
+#if !NO_MALLINFO
+struct mallinfo
+dlmallinfo(void)
+{
+return internal_mallinfo(gm);
+}
+#endif /* NO_MALLINFO */
+void
+dlmalloc_stats()
+{
+internal_malloc_stats(gm);
+}
+size_t
+dlmalloc_usable_size(void *mem)
+{
+if (mem != 0) {
+mchunkptr p = mem2chunk(mem);
+if (cinuse(p))
+return chunksize(p) - overhead_for(p);
+}
 return 0;
 }
-#endif /* REALLOC_ZERO_BYTES_FREES */
-else {
+int
-#if ! FOOTERS
+dlmallopt(int param_number, int value)
-mstate m = gm;
+{
-#else /* FOOTERS */
+return change_mparam(param_number, value);
-mstate m = get_mstate_for(mem2chunk(oldmem));
-if (!ok_magic(m)) {
-USAGE_ERROR_ACTION(m, oldmem);
-return 0;
-}
-#endif /* FOOTERS */
-return internal_realloc(m, oldmem, bytes);
-}
-}
-void* dlmemalign(size_t alignment, size_t bytes) {
-return internal_memalign(gm, alignment, bytes);
-}
-void** dlindependent_calloc(size_t n_elements, size_t elem_size,
-void* chunks[]) {
-size_t sz = elem_size; /* serves as 1-element array */
-return ialloc(gm, n_elements, &sz, 3, chunks);
-}
-void** dlindependent_comalloc(size_t n_elements, size_t sizes[],
-void* chunks[]) {
-return ialloc(gm, n_elements, sizes, 0, chunks);
-}
-void* dlvalloc(size_t bytes) {
-size_t pagesz;
-init_mparams();
-pagesz = mparams.page_size;
-return dlmemalign(pagesz, bytes);
-}
-void* dlpvalloc(size_t bytes) {
-size_t pagesz;
-init_mparams();
-pagesz = mparams.page_size;
-return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
-}
-int dlmalloc_trim(size_t pad) {
-int result = 0;
-if (!PREACTION(gm)) {
-result = sys_trim(gm, pad);
-POSTACTION(gm);
-}
-return result;
-}
-size_t dlmalloc_footprint(void) {
-return gm->footprint;
-}
-size_t dlmalloc_max_footprint(void) {
-return gm->max_footprint;
-}
-#if !NO_MALLINFO
-struct mallinfo dlmallinfo(void) {
-return internal_mallinfo(gm);
-}
-#endif /* NO_MALLINFO */
-void dlmalloc_stats() {
-internal_malloc_stats(gm);
-}
-size_t dlmalloc_usable_size(void* mem) {
-if (mem != 0) {
-mchunkptr p = mem2chunk(mem);
-if (cinuse(p))
-return chunksize(p) - overhead_for(p);
-}
-return 0;
-}
-int dlmallopt(int param_number, int value) {
-return change_mparam(param_number, value);
 }
 #endif /* !ONLY_MSPACES */
 /* ----------------------------- user mspaces ---------------------------- */
 #if MSPACES
-static mstate init_user_mstate(char* tbase, size_t tsize) {
+static mstate
-size_t msize = pad_request(sizeof(struct malloc_state));
+init_user_mstate(char *tbase, size_t tsize)
-mchunkptr mn;
+{
-mchunkptr msp = align_as_chunk(tbase);
+size_t msize = pad_request(sizeof(struct malloc_state));
-mstate m = (mstate)(chunk2mem(msp));
+mchunkptr mn;
-memset(m, 0, msize);
+mchunkptr msp = align_as_chunk(tbase);
-INITIAL_LOCK(&m->mutex);
+mstate m = (mstate) (chunk2mem(msp));
-msp->head = (msize|PINUSE_BIT|CINUSE_BIT);
+memset(m, 0, msize);
-m->seg.base = m->least_addr = tbase;
+INITIAL_LOCK(&m->mutex);
-m->seg.size = m->footprint = m->max_footprint = tsize;
+msp->head = (msize | PINUSE_BIT | CINUSE_BIT);
-m->magic = mparams.magic;
+m->seg.base = m->least_addr = tbase;
-m->mflags = mparams.default_mflags;
+m->seg.size = m->footprint = m->max_footprint = tsize;
-disable_contiguous(m);
+m->magic = mparams.magic;
-init_bins(m);
+m->mflags = mparams.default_mflags;
-mn = next_chunk(mem2chunk(m));
+disable_contiguous(m);
-init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE);
+init_bins(m);
-check_top_chunk(m, m->top);
+mn = next_chunk(mem2chunk(m));
-return m;
+init_top(m, mn, (size_t) ((tbase + tsize) - (char *) mn) - TOP_FOOT_SIZE);
-}
+check_top_chunk(m, m->top);
+return m;
-mspace create_mspace(size_t capacity, int locked) {
+}
-mstate m = 0;
-size_t msize = pad_request(sizeof(struct malloc_state));
+mspace
-init_mparams(); /* Ensure pagesize etc initialized */
+create_mspace(size_t capacity, int locked)
+{
-if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
+mstate m = 0;
-size_t rs = ((capacity == 0)? mparams.granularity :
+size_t msize = pad_request(sizeof(struct malloc_state));
-(capacity + TOP_FOOT_SIZE + msize));
+init_mparams();             /* Ensure pagesize etc initialized */
-size_t tsize = granularity_align(rs);
-char* tbase = (char*)(CALL_MMAP(tsize));
+if (capacity < (size_t) - (msize + TOP_FOOT_SIZE + mparams.page_size)) {
-if (tbase != CMFAIL) {
+size_t rs = ((capacity == 0) ? mparams.granularity :
-m = init_user_mstate(tbase, tsize);
+(capacity + TOP_FOOT_SIZE + msize));
-m->seg.sflags = IS_MMAPPED_BIT;
+size_t tsize = granularity_align(rs);
-set_lock(m, locked);
+char *tbase = (char *) (CALL_MMAP(tsize));
-}
+if (tbase != CMFAIL) {
-}
+m = init_user_mstate(tbase, tsize);
-return (mspace)m;
+m->seg.sflags = IS_MMAPPED_BIT;
-}
+set_lock(m, locked);
+}
-mspace create_mspace_with_base(void* base, size_t capacity, int locked) {
+}
-mstate m = 0;
+return (mspace) m;
-size_t msize = pad_request(sizeof(struct malloc_state));
+}
-init_mparams(); /* Ensure pagesize etc initialized */
+mspace
-if (capacity > msize + TOP_FOOT_SIZE &&
+create_mspace_with_base(void *base, size_t capacity, int locked)
-capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
+{
-m = init_user_mstate((char*)base, capacity);
+mstate m = 0;
-m->seg.sflags = EXTERN_BIT;
+size_t msize = pad_request(sizeof(struct malloc_state));
-set_lock(m, locked);
+init_mparams();             /* Ensure pagesize etc initialized */
-}
-return (mspace)m;
+if (capacity > msize + TOP_FOOT_SIZE &&
-}
+capacity < (size_t) - (msize + TOP_FOOT_SIZE + mparams.page_size)) {
+m = init_user_mstate((char *) base, capacity);
-size_t destroy_mspace(mspace msp) {
+m->seg.sflags = EXTERN_BIT;
-size_t freed = 0;
+set_lock(m, locked);
-mstate ms = (mstate)msp;
+}
-if (ok_magic(ms)) {
+return (mspace) m;
-msegmentptr sp = &ms->seg;
+}
-while (sp != 0) {
-char* base = sp->base;
+size_t
-size_t size = sp->size;
+destroy_mspace(mspace msp)
-flag_t flag = sp->sflags;
+{
-sp = sp->next;
+size_t freed = 0;
-if ((flag & IS_MMAPPED_BIT) && !(flag & EXTERN_BIT) &&
+mstate ms = (mstate) msp;
-CALL_MUNMAP(base, size) == 0)
+if (ok_magic(ms)) {
-freed += size;
+msegmentptr sp = &ms->seg;
-}
+while (sp != 0) {
-}
+char *base = sp->base;
-else {
+size_t size = sp->size;
-USAGE_ERROR_ACTION(ms,ms);
+flag_t flag = sp->sflags;
-}
+sp = sp->next;
-return freed;
+if ((flag & IS_MMAPPED_BIT) && !(flag & EXTERN_BIT) &&
+CALL_MUNMAP(base, size) == 0)
+freed += size;
+}
+} else {
+USAGE_ERROR_ACTION(ms, ms);
+}
+return freed;
 }
 /*
 mspace versions of routines are near-clones of the global
 versions. This is not so nice but better than the alternatives.
 */
-void* mspace_malloc(mspace msp, size_t bytes) {
+void *
-mstate ms = (mstate)msp;
+mspace_malloc(mspace msp, size_t bytes)
-if (!ok_magic(ms)) {
+{
-USAGE_ERROR_ACTION(ms,ms);
+mstate ms = (mstate) msp;
+if (!ok_magic(ms)) {
+USAGE_ERROR_ACTION(ms, ms);
+return 0;
+}
+if (!PREACTION(ms)) {
+void *mem;
+size_t nb;
+if (bytes <= MAX_SMALL_REQUEST) {
+bindex_t idx;
+binmap_t smallbits;
+nb = (bytes < MIN_REQUEST) ? MIN_CHUNK_SIZE : pad_request(bytes);
+idx = small_index(nb);
+smallbits = ms->smallmap >> idx;
+if ((smallbits & 0x3U) != 0) {      /* Remainderless fit to a smallbin. */
+mchunkptr b, p;
+idx += ~smallbits & 1;  /* Uses next bin if idx empty */
+b = smallbin_at(ms, idx);
+p = b->fd;
+assert(chunksize(p) == small_index2size(idx));
+unlink_first_small_chunk(ms, b, p, idx);
+set_inuse_and_pinuse(ms, p, small_index2size(idx));
+mem = chunk2mem(p);
+check_malloced_chunk(ms, mem, nb);
+goto postaction;
+}
+else if (nb > ms->dvsize) {
+if (smallbits != 0) {   /* Use chunk in next nonempty smallbin */
+mchunkptr b, p, r;
+size_t rsize;
+bindex_t i;
+binmap_t leftbits =
+(smallbits << idx) & left_bits(idx2bit(idx));
+binmap_t leastbit = least_bit(leftbits);
+compute_bit2idx(leastbit, i);
+b = smallbin_at(ms, i);
+p = b->fd;
+assert(chunksize(p) == small_index2size(i));
+unlink_first_small_chunk(ms, b, p, i);
+rsize = small_index2size(i) - nb;
+/* Fit here cannot be remainderless if 4byte sizes */
+if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
+set_inuse_and_pinuse(ms, p, small_index2size(i));
+else {
+set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+r = chunk_plus_offset(p, nb);
+set_size_and_pinuse_of_free_chunk(r, rsize);
+replace_dv(ms, r, rsize);
+}
+mem = chunk2mem(p);
+check_malloced_chunk(ms, mem, nb);
+goto postaction;
+}
+else if (ms->treemap != 0
+&& (mem = tmalloc_small(ms, nb)) != 0) {
+check_malloced_chunk(ms, mem, nb);
+goto postaction;
+}
+}
+} else if (bytes >= MAX_REQUEST)
+nb = MAX_SIZE_T;    /* Too big to allocate. Force failure (in sys alloc) */
+else {
+nb = pad_request(bytes);
+if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) {
+check_malloced_chunk(ms, mem, nb);
+goto postaction;
+}
+}
+if (nb <= ms->dvsize) {
+size_t rsize = ms->dvsize - nb;
+mchunkptr p = ms->dv;
+if (rsize >= MIN_CHUNK_SIZE) {      /* split dv */
+mchunkptr r = ms->dv = chunk_plus_offset(p, nb);
+ms->dvsize = rsize;
+set_size_and_pinuse_of_free_chunk(r, rsize);
+set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+} else {            /* exhaust dv */
+size_t dvs = ms->dvsize;
+ms->dvsize = 0;
+ms->dv = 0;
+set_inuse_and_pinuse(ms, p, dvs);
+}
+mem = chunk2mem(p);
+check_malloced_chunk(ms, mem, nb);
+goto postaction;
+}
+else if (nb < ms->topsize) {    /* Split top */
+size_t rsize = ms->topsize -= nb;
+mchunkptr p = ms->top;
+mchunkptr r = ms->top = chunk_plus_offset(p, nb);
+r->head = rsize | PINUSE_BIT;
+set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+mem = chunk2mem(p);
+check_top_chunk(ms, ms->top);
+check_malloced_chunk(ms, mem, nb);
+goto postaction;
+}
+mem = sys_alloc(ms, nb);
+postaction:
+POSTACTION(ms);
+return mem;
+}
 return 0;
 }
-if (!PREACTION(ms)) {
-void* mem;
+void
-size_t nb;
+mspace_free(mspace msp, void *mem)
-if (bytes <= MAX_SMALL_REQUEST) {
+{
-bindex_t idx;
+if (mem != 0) {
-binmap_t smallbits;
+mchunkptr p = mem2chunk(mem);
-nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
+#if FOOTERS
-idx = small_index(nb);
+mstate fm = get_mstate_for(p);
-smallbits = ms->smallmap >> idx;
+#else /* FOOTERS */
+mstate fm = (mstate) msp;
-if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
+#endif /* FOOTERS */
-mchunkptr b, p;
+if (!ok_magic(fm)) {
-idx += ~smallbits & 1;       /* Uses next bin if idx empty */
+USAGE_ERROR_ACTION(fm, p);
-b = smallbin_at(ms, idx);
+return;
-p = b->fd;
-assert(chunksize(p) == small_index2size(idx));
-unlink_first_small_chunk(ms, b, p, idx);
-set_inuse_and_pinuse(ms, p, small_index2size(idx));
-mem = chunk2mem(p);
-check_malloced_chunk(ms, mem, nb);
-goto postaction;
-}
-else if (nb > ms->dvsize) {
-if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
-mchunkptr b, p, r;
-size_t rsize;
-bindex_t i;
-binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
-binmap_t leastbit = least_bit(leftbits);
-compute_bit2idx(leastbit, i);
-b = smallbin_at(ms, i);
-p = b->fd;
-assert(chunksize(p) == small_index2size(i));
-unlink_first_small_chunk(ms, b, p, i);
-rsize = small_index2size(i) - nb;
-/* Fit here cannot be remainderless if 4byte sizes */
-if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
-set_inuse_and_pinuse(ms, p, small_index2size(i));
-else {
-set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
-r = chunk_plus_offset(p, nb);
-set_size_and_pinuse_of_free_chunk(r, rsize);
-replace_dv(ms, r, rsize);
-}
-mem = chunk2mem(p);
-check_malloced_chunk(ms, mem, nb);
-goto postaction;
 }
+if (!PREACTION(fm)) {
-else if (ms->treemap != 0 && (mem = tmalloc_small(ms, nb)) != 0) {
+check_inuse_chunk(fm, p);
-check_malloced_chunk(ms, mem, nb);
+if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
-goto postaction;
+size_t psize = chunksize(p);
+mchunkptr next = chunk_plus_offset(p, psize);
+if (!pinuse(p)) {
+size_t prevsize = p->prev_foot;
+if ((prevsize & IS_MMAPPED_BIT) != 0) {
+prevsize &= ~IS_MMAPPED_BIT;
+psize += prevsize + MMAP_FOOT_PAD;
+if (CALL_MUNMAP((char *) p - prevsize, psize) == 0)
+fm->footprint -= psize;
+goto postaction;
+} else {
+mchunkptr prev = chunk_minus_offset(p, prevsize);
+psize += prevsize;
+p = prev;
+if (RTCHECK(ok_address(fm, prev))) {    /* consolidate backward */
+if (p != fm->dv) {
+unlink_chunk(fm, p, prevsize);
+} else if ((next->head & INUSE_BITS) ==
+INUSE_BITS) {
+fm->dvsize = psize;
+set_free_with_pinuse(p, psize, next);
+goto postaction;
+}
+} else
+goto erroraction;
+}
+}
+if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
+if (!cinuse(next)) {        /* consolidate forward */
+if (next == fm->top) {
+size_t tsize = fm->topsize += psize;
+fm->top = p;
+p->head = tsize | PINUSE_BIT;
+if (p == fm->dv) {
+fm->dv = 0;
+fm->dvsize = 0;
+}
+if (should_trim(fm, tsize))
+sys_trim(fm, 0);
+goto postaction;
+} else if (next == fm->dv) {
+size_t dsize = fm->dvsize += psize;
+fm->dv = p;
+set_size_and_pinuse_of_free_chunk(p, dsize);
+goto postaction;
+} else {
+size_t nsize = chunksize(next);
+psize += nsize;
+unlink_chunk(fm, next, nsize);
+set_size_and_pinuse_of_free_chunk(p, psize);
+if (p == fm->dv) {
+fm->dvsize = psize;
+goto postaction;
+}
+}
+} else
+set_free_with_pinuse(p, psize, next);
+insert_chunk(fm, p, psize);
+check_free_chunk(fm, p);
+goto postaction;
+}
+}
+erroraction:
+USAGE_ERROR_ACTION(fm, p);
+postaction:
+POSTACTION(fm);
 }
 }
 }
-else if (bytes >= MAX_REQUEST)
-nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
+void *
+mspace_calloc(mspace msp, size_t n_elements, size_t elem_size)
+{
+void *mem;
+size_t req = 0;
+mstate ms = (mstate) msp;
+if (!ok_magic(ms)) {
+USAGE_ERROR_ACTION(ms, ms);
+return 0;
+}
+if (n_elements != 0) {
+req = n_elements * elem_size;
+if (((n_elements | elem_size) & ~(size_t) 0xffff) &&
+(req / n_elements != elem_size))
+req = MAX_SIZE_T;   /* force downstream failure on overflow */
+}
+mem = internal_malloc(ms, req);
+if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
+memset(mem, 0, req);
+return mem;
+}
+void *
+mspace_realloc(mspace msp, void *oldmem, size_t bytes)
+{
+if (oldmem == 0)
+return mspace_malloc(msp, bytes);
+#ifdef REALLOC_ZERO_BYTES_FREES
+if (bytes == 0) {
+mspace_free(msp, oldmem);
+return 0;
+}
+#endif /* REALLOC_ZERO_BYTES_FREES */
 else {
-nb = pad_request(bytes);
-if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) {
-check_malloced_chunk(ms, mem, nb);
-goto postaction;
-}
-}
-if (nb <= ms->dvsize) {
-size_t rsize = ms->dvsize - nb;
-mchunkptr p = ms->dv;
-if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
-mchunkptr r = ms->dv = chunk_plus_offset(p, nb);
-ms->dvsize = rsize;
-set_size_and_pinuse_of_free_chunk(r, rsize);
-set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
-}
-else { /* exhaust dv */
-size_t dvs = ms->dvsize;
-ms->dvsize = 0;
-ms->dv = 0;
-set_inuse_and_pinuse(ms, p, dvs);
-}
-mem = chunk2mem(p);
-check_malloced_chunk(ms, mem, nb);
-goto postaction;
-}
-else if (nb < ms->topsize) { /* Split top */
-size_t rsize = ms->topsize -= nb;
-mchunkptr p = ms->top;
-mchunkptr r = ms->top = chunk_plus_offset(p, nb);
-r->head = rsize | PINUSE_BIT;
-set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
-mem = chunk2mem(p);
-check_top_chunk(ms, ms->top);
-check_malloced_chunk(ms, mem, nb);
-goto postaction;
-}
-mem = sys_alloc(ms, nb);
-postaction:
-POSTACTION(ms);
-return mem;
-}
-return 0;
-}
-void mspace_free(mspace msp, void* mem) {
-if (mem != 0) {
-mchunkptr p  = mem2chunk(mem);
 #if FOOTERS
-mstate fm = get_mstate_for(p);
+mchunkptr p = mem2chunk(oldmem);
+mstate ms = get_mstate_for(p);
 #else /* FOOTERS */
-mstate fm = (mstate)msp;
+mstate ms = (mstate) msp;
 #endif /* FOOTERS */
-if (!ok_magic(fm)) {
+if (!ok_magic(ms)) {
-USAGE_ERROR_ACTION(fm, p);
+USAGE_ERROR_ACTION(ms, ms);
-return;
+return 0;
-}
-if (!PREACTION(fm)) {
-check_inuse_chunk(fm, p);
-if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
-size_t psize = chunksize(p);
-mchunkptr next = chunk_plus_offset(p, psize);
-if (!pinuse(p)) {
-size_t prevsize = p->prev_foot;
-if ((prevsize & IS_MMAPPED_BIT) != 0) {
-prevsize &= ~IS_MMAPPED_BIT;
-psize += prevsize + MMAP_FOOT_PAD;
-if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
-fm->footprint -= psize;
-goto postaction;
-}
-else {
-mchunkptr prev = chunk_minus_offset(p, prevsize);
-psize += prevsize;
-p = prev;
-if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
-if (p != fm->dv) {
-unlink_chunk(fm, p, prevsize);
-}
-else if ((next->head & INUSE_BITS) == INUSE_BITS) {
-fm->dvsize = psize;
-set_free_with_pinuse(p, psize, next);
-goto postaction;
-}
-}
-else
-goto erroraction;
-}
 }
+return internal_realloc(ms, oldmem, bytes);
-if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
+}
-if (!cinuse(next)) {  /* consolidate forward */
+}
-if (next == fm->top) {
-size_t tsize = fm->topsize += psize;
+void *
-fm->top = p;
+mspace_memalign(mspace msp, size_t alignment, size_t bytes)
-p->head = tsize | PINUSE_BIT;
+{
-if (p == fm->dv) {
+mstate ms = (mstate) msp;
-fm->dv = 0;
+if (!ok_magic(ms)) {
-fm->dvsize = 0;
+USAGE_ERROR_ACTION(ms, ms);
-}
+return 0;
-if (should_trim(fm, tsize))
+}
-sys_trim(fm, 0);
+return internal_memalign(ms, alignment, bytes);
-goto postaction;
+}
-}
-else if (next == fm->dv) {
+void **
-size_t dsize = fm->dvsize += psize;
+mspace_independent_calloc(mspace msp, size_t n_elements,
-fm->dv = p;
+size_t elem_size, void *chunks[])
-set_size_and_pinuse_of_free_chunk(p, dsize);
+{
-goto postaction;
+size_t sz = elem_size;      /* serves as 1-element array */
-}
+mstate ms = (mstate) msp;
-else {
+if (!ok_magic(ms)) {
-size_t nsize = chunksize(next);
+USAGE_ERROR_ACTION(ms, ms);
-psize += nsize;
+return 0;
-unlink_chunk(fm, next, nsize);
+}
-set_size_and_pinuse_of_free_chunk(p, psize);
+return ialloc(ms, n_elements, &sz, 3, chunks);
-if (p == fm->dv) {
+}
-fm->dvsize = psize;
-goto postaction;
+void **
-}
+mspace_independent_comalloc(mspace msp, size_t n_elements,
-}
+size_t sizes[], void *chunks[])
-}
+{
-else
+mstate ms = (mstate) msp;
-set_free_with_pinuse(p, psize, next);
+if (!ok_magic(ms)) {
-insert_chunk(fm, p, psize);
+USAGE_ERROR_ACTION(ms, ms);
-check_free_chunk(fm, p);
+return 0;
-goto postaction;
+}
+return ialloc(ms, n_elements, sizes, 0, chunks);
+}
+int
+mspace_trim(mspace msp, size_t pad)
+{
+int result = 0;
+mstate ms = (mstate) msp;
+if (ok_magic(ms)) {
+if (!PREACTION(ms)) {
+result = sys_trim(ms, pad);
+POSTACTION(ms);
 }
-}
+} else {
-erroraction:
+USAGE_ERROR_ACTION(ms, ms);
-USAGE_ERROR_ACTION(fm, p);
+}
-postaction:
+return result;
-POSTACTION(fm);
+}
-}
-}
+void
-}
+mspace_malloc_stats(mspace msp)
+{
-void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size) {
+mstate ms = (mstate) msp;
-void* mem;
+if (ok_magic(ms)) {
-size_t req = 0;
+internal_malloc_stats(ms);
-mstate ms = (mstate)msp;
+} else {
-if (!ok_magic(ms)) {
+USAGE_ERROR_ACTION(ms, ms);
-USAGE_ERROR_ACTION(ms,ms);
+}
-return 0;
+}
-}
-if (n_elements != 0) {
+size_t
-req = n_elements * elem_size;
+mspace_footprint(mspace msp)
-if (((n_elements | elem_size) & ~(size_t)0xffff) &&
+{
-(req / n_elements != elem_size))
+size_t result;
-req = MAX_SIZE_T; /* force downstream failure on overflow */
+mstate ms = (mstate) msp;
-}
+if (ok_magic(ms)) {
-mem = internal_malloc(ms, req);
+result = ms->footprint;
-if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
+}
-memset(mem, 0, req);
+USAGE_ERROR_ACTION(ms, ms);
-return mem;
+return result;
 }
-void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) {
-if (oldmem == 0)
+size_t
-return mspace_malloc(msp, bytes);
+mspace_max_footprint(mspace msp)
-#ifdef REALLOC_ZERO_BYTES_FREES
+{
-if (bytes == 0) {
+size_t result;
-mspace_free(msp, oldmem);
+mstate ms = (mstate) msp;
-return 0;
+if (ok_magic(ms)) {
-}
+result = ms->max_footprint;
-#endif /* REALLOC_ZERO_BYTES_FREES */
+}
-else {
+USAGE_ERROR_ACTION(ms, ms);
-#if FOOTERS
+return result;
-mchunkptr p  = mem2chunk(oldmem);
+}
-mstate ms = get_mstate_for(p);
-#else /* FOOTERS */
-mstate ms = (mstate)msp;
+#if !NO_MALLINFO
-#endif /* FOOTERS */
+struct mallinfo
+mspace_mallinfo(mspace msp)
+{
+mstate ms = (mstate) msp;
 if (!ok_magic(ms)) {
-USAGE_ERROR_ACTION(ms,ms);
+USAGE_ERROR_ACTION(ms, ms);
-return 0;
+}
-}
+return internal_mallinfo(ms);
-return internal_realloc(ms, oldmem, bytes);
-}
-}
-void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) {
-mstate ms = (mstate)msp;
-if (!ok_magic(ms)) {
-USAGE_ERROR_ACTION(ms,ms);
-return 0;
-}
-return internal_memalign(ms, alignment, bytes);
-}
-void** mspace_independent_calloc(mspace msp, size_t n_elements,
-size_t elem_size, void* chunks[]) {
-size_t sz = elem_size; /* serves as 1-element array */
-mstate ms = (mstate)msp;
-if (!ok_magic(ms)) {
-USAGE_ERROR_ACTION(ms,ms);
-return 0;
-}
-return ialloc(ms, n_elements, &sz, 3, chunks);
-}
-void** mspace_independent_comalloc(mspace msp, size_t n_elements,
-size_t sizes[], void* chunks[]) {
-mstate ms = (mstate)msp;
-if (!ok_magic(ms)) {
-USAGE_ERROR_ACTION(ms,ms);
-return 0;
-}
-return ialloc(ms, n_elements, sizes, 0, chunks);
-}
-int mspace_trim(mspace msp, size_t pad) {
-int result = 0;
-mstate ms = (mstate)msp;
-if (ok_magic(ms)) {
-if (!PREACTION(ms)) {
-result = sys_trim(ms, pad);
-POSTACTION(ms);
-}
-}
-else {
-USAGE_ERROR_ACTION(ms,ms);
-}
-return result;
-}
-void mspace_malloc_stats(mspace msp) {
-mstate ms = (mstate)msp;
-if (ok_magic(ms)) {
-internal_malloc_stats(ms);
-}
-else {
-USAGE_ERROR_ACTION(ms,ms);
-}
-}
-size_t mspace_footprint(mspace msp) {
-size_t result;
-mstate ms = (mstate)msp;
-if (ok_magic(ms)) {
-result = ms->footprint;
-}
-USAGE_ERROR_ACTION(ms,ms);
-return result;
-}
-size_t mspace_max_footprint(mspace msp) {
-size_t result;
-mstate ms = (mstate)msp;
-if (ok_magic(ms)) {
-result = ms->max_footprint;
-}
-USAGE_ERROR_ACTION(ms,ms);
-return result;
-}
-#if !NO_MALLINFO
-struct mallinfo mspace_mallinfo(mspace msp) {
-mstate ms = (mstate)msp;
-if (!ok_magic(ms)) {
-USAGE_ERROR_ACTION(ms,ms);
-}
-return internal_mallinfo(ms);
 }
 #endif /* NO_MALLINFO */
-int mspace_mallopt(int param_number, int value) {
+int
-return change_mparam(param_number, value);
+mspace_mallopt(int param_number, int value)
+{
+return change_mparam(param_number, value);
 }
 #endif /* MSPACES */
 /* -------------------- Alternative MORECORE functions ------------------- */
 structure of old version,  but most details differ.)
 */
 #endif /* !HAVE_MALLOC */
+/* vi: set ts=4 sw=4 expandtab: */

Mercurial > sdl-ios-xcode

comparison src/stdlib/SDL_malloc.c @ 1895:c121d94672cb