+++ /dev/null
-diff -Nupr a/include/Qt/qatomic_avr32.h b/include/Qt/qatomic_avr32.h
---- a/include/Qt/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/include/Qt/qatomic_avr32.h 2006-07-27 07:55:09.000000000 +0200
-@@ -0,0 +1 @@
-+#include "../../src/corelib/arch/qatomic_avr32.h"
-diff -Nupr a/include/QtCore/qatomic_avr32.h b/include/QtCore/qatomic_avr32.h
---- a/include/QtCore/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/include/QtCore/qatomic_avr32.h 2006-07-27 07:55:28.000000000 +0200
-@@ -0,0 +1 @@
-+#include "../../src/corelib/arch/qatomic_avr32.h"
-diff -Nupr a/src/corelib/arch/arch.pri b/src/corelib/arch/arch.pri
---- a/src/corelib/arch/arch.pri 2006-06-30 09:49:44.000000000 +0200
-+++ b/src/corelib/arch/arch.pri 2006-07-26 11:03:43.000000000 +0200
-@@ -13,6 +13,7 @@ mac:HEADERS += arch/qatomic_macosx.h \
- arch/qatomic_generic.h \
- arch/qatomic_powerpc.h \
- arch/qatomic_arm.h \
-+ arch/qatomic_avr32.h \
- arch/qatomic_i386.h \
- arch/qatomic_mips.h \
- arch/qatomic_s390.h \
-diff -Nupr a/src/corelib/arch/avr32/arch.pri b/src/corelib/arch/avr32/arch.pri
---- a/src/corelib/arch/avr32/arch.pri 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/arch.pri 2006-07-26 11:02:16.000000000 +0200
-@@ -0,0 +1,5 @@
-+#
-+# AVR32 architecture
-+#
-+SOURCES += $$QT_ARCH_CPP/qatomic.cpp \
-+ $$QT_ARCH_CPP/malloc.c
-diff -Nupr a/src/corelib/arch/avr32/malloc.c b/src/corelib/arch/avr32/malloc.c
---- a/src/corelib/arch/avr32/malloc.c 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/malloc.c 2006-07-28 10:29:44.000000000 +0200
-@@ -0,0 +1,5819 @@
-+/****************************************************************************
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** This file contains third party code which is not governed by the Qt
-+** Commercial License Agreement. Please read the license headers below
-+** for more information.
-+**
-+** Further information about Qt licensing is available at:
-+** http://www.trolltech.com/products/qt/licensing.html or by
-+** contacting info@trolltech.com.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+/* ---- config.h */
-+#define KDE_MALLOC
-+#define KDE_MALLOC_FULL
-+#define KDE_MALLOC_AVR32
-+/* ---- */
-+
-+#ifdef KDE_MALLOC
-+
-+#ifdef KDE_MALLOC_DEBUG
-+#define DEBUG
-+#endif
-+
-+#define USE_MALLOC_LOCK
-+#define INLINE __inline__
-+/*#define INLINE*/
-+#define USE_MEMCPY 0
-+#define MMAP_CLEARS 1
-+
-+/*
-+ This is a version (aka dlmalloc) of malloc/free/realloc written by
-+ Doug Lea and released to the public domain. Use, modify, and
-+ redistribute this code without permission or acknowledgment in any
-+ way you wish. Send questions, comments, complaints, performance
-+ data, etc to dl@cs.oswego.edu
-+
-+* VERSION 2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
-+
-+ Note: There may be an updated version of this malloc obtainable at
-+ ftp://gee.cs.oswego.edu/pub/misc/malloc.c
-+ Check before installing!
-+
-+* Quickstart
-+
-+ This library is all in one file to simplify the most common usage:
-+ ftp it, compile it (-O), and link it into another program. All
-+ of the compile-time options default to reasonable values for use on
-+ most unix platforms. Compile -DWIN32 for reasonable defaults on windows.
-+ You might later want to step through various compile-time and dynamic
-+ tuning options.
-+
-+ For convenience, an include file for code using this malloc is at:
-+ ftp://gee.cs.oswego.edu/pub/misc/malloc-2.7.0.h
-+ You don't really need this .h file unless you call functions not
-+ defined in your system include files. The .h file contains only the
-+ excerpts from this file needed for using this malloc on ANSI C/C++
-+ systems, so long as you haven't changed compile-time options about
-+ naming and tuning parameters. If you do, then you can create your
-+ own malloc.h that does include all settings by cutting at the point
-+ indicated below.
-+
-+* Why use this malloc?
-+
-+ This is not the fastest, most space-conserving, most portable, or
-+ most tunable malloc ever written. However it is among the fastest
-+ while also being among the most space-conserving, portable and tunable.
-+ Consistent balance across these factors results in a good general-purpose
-+ allocator for malloc-intensive programs.
-+
-+ The main properties of the algorithms are:
-+ * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
-+ with ties normally decided via FIFO (i.e. least recently used).
-+ * For small (<= 64 bytes by default) requests, it is a caching
-+ allocator, that maintains pools of quickly recycled chunks.
-+ * In between, and for combinations of large and small requests, it does
-+ the best it can trying to meet both goals at once.
-+ * For very large requests (>= 128KB by default), it relies on system
-+ memory mapping facilities, if supported.
-+
-+ For a longer but slightly out of date high-level description, see
-+ http://gee.cs.oswego.edu/dl/html/malloc.html
-+
-+ You may already by default be using a C library containing a malloc
-+ that is based on some version of this malloc (for example in
-+ linux). You might still want to use the one in this file in order to
-+ customize settings or to avoid overheads associated with library
-+ versions.
-+
-+* Contents, described in more detail in "description of public routines" below.
-+
-+ Standard (ANSI/SVID/...) functions:
-+ malloc(size_t n);
-+ calloc(size_t n_elements, size_t element_size);
-+ free(Void_t* p);
-+ realloc(Void_t* p, size_t n);
-+ memalign(size_t alignment, size_t n);
-+ valloc(size_t n);
-+ mallinfo()
-+ mallopt(int parameter_number, int parameter_value)
-+
-+ Additional functions:
-+ independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);
-+ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
-+ pvalloc(size_t n);
-+ cfree(Void_t* p);
-+ malloc_trim(size_t pad);
-+ malloc_usable_size(Void_t* p);
-+ malloc_stats();
-+
-+* Vital statistics:
-+
-+ Supported pointer representation: 4 or 8 bytes
-+ Supported size_t representation: 4 or 8 bytes
-+ Note that size_t is allowed to be 4 bytes even if pointers are 8.
-+ You can adjust this by defining INTERNAL_SIZE_T
-+
-+ Alignment: 2 * sizeof(size_t) (default)
-+ (i.e., 8 byte alignment with 4byte size_t). This suffices for
-+ nearly all current machines and C compilers. However, you can
-+ define MALLOC_ALIGNMENT to be wider than this if necessary.
-+
-+ Minimum overhead per allocated chunk: 4 or 8 bytes
-+ Each malloced chunk has a hidden word of overhead holding size
-+ and status information.
-+
-+ Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
-+ 8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
-+
-+ When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
-+ ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
-+ needed; 4 (8) for a trailing size field and 8 (16) bytes for
-+ free list pointers. Thus, the minimum allocatable size is
-+ 16/24/32 bytes.
-+
-+ Even a request for zero bytes (i.e., malloc(0)) returns a
-+ pointer to something of the minimum allocatable size.
-+
-+ The maximum overhead wastage (i.e., number of extra bytes
-+ allocated than were requested in malloc) is less than or equal
-+ to the minimum size, except for requests >= mmap_threshold that
-+ are serviced via mmap(), where the worst case wastage is 2 *
-+ sizeof(size_t) bytes plus the remainder from a system page (the
-+ minimal mmap unit); typically 4096 or 8192 bytes.
-+
-+ Maximum allocated size: 4-byte size_t: 2^32 minus about two pages
-+ 8-byte size_t: 2^64 minus about two pages
-+
-+ It is assumed that (possibly signed) size_t values suffice to
-+ represent chunk sizes. `Possibly signed' is due to the fact
-+ that `size_t' may be defined on a system as either a signed or
-+ an unsigned type. The ISO C standard says that it must be
-+ unsigned, but a few systems are known not to adhere to this.
-+ Additionally, even when size_t is unsigned, sbrk (which is by
-+ default used to obtain memory from system) accepts signed
-+ arguments, and may not be able to handle size_t-wide arguments
-+ with negative sign bit. Generally, values that would
-+ appear as negative after accounting for overhead and alignment
-+ are supported only via mmap(), which does not have this
-+ limitation.
-+
-+ Requests for sizes outside the allowed range will perform an optional
-+ failure action and then return null. (Requests may also
-+ also fail because a system is out of memory.)
-+
-+ Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined
-+
-+ When USE_MALLOC_LOCK is defined, wrappers are created to
-+ surround every public call with either a pthread mutex or
-+ a win32 spinlock (depending on WIN32). This is not
-+ especially fast, and can be a major bottleneck.
-+ It is designed only to provide minimal protection
-+ in concurrent environments, and to provide a basis for
-+ extensions. If you are using malloc in a concurrent program,
-+ you would be far better off obtaining ptmalloc, which is
-+ derived from a version of this malloc, and is well-tuned for
-+ concurrent programs. (See http://www.malloc.de)
-+
-+ Compliance: I believe it is compliant with the 1997 Single Unix Specification
-+ (See http://www.opennc.org). Also SVID/XPG, ANSI C, and probably
-+ others as well.
-+
-+* Synopsis of compile-time options:
-+
-+ People have reported using previous versions of this malloc on all
-+ versions of Unix, sometimes by tweaking some of the defines
-+ below. It has been tested most extensively on Solaris and
-+ Linux. It is also reported to work on WIN32 platforms.
-+ People also report using it in stand-alone embedded systems.
-+
-+ The implementation is in straight, hand-tuned ANSI C. It is not
-+ at all modular. (Sorry!) It uses a lot of macros. To be at all
-+ usable, this code should be compiled using an optimizing compiler
-+ (for example gcc -O3) that can simplify expressions and control
-+ paths. (FAQ: some macros import variables as arguments rather than
-+ declare locals because people reported that some debuggers
-+ otherwise get confused.)
-+
-+ OPTION DEFAULT VALUE
-+
-+ Compilation Environment options:
-+
-+ __STD_C derived from C compiler defines
-+ WIN32 NOT defined
-+ HAVE_MEMCPY defined
-+ USE_MEMCPY 1 if HAVE_MEMCPY is defined
-+ HAVE_MMAP defined as 1
-+ MMAP_CLEARS 1
-+ HAVE_MREMAP 0 unless linux defined
-+ malloc_getpagesize derived from system #includes, or 4096 if not
-+ HAVE_USR_INCLUDE_MALLOC_H NOT defined
-+ LACKS_UNISTD_H NOT defined unless WIN32
-+ LACKS_SYS_PARAM_H NOT defined unless WIN32
-+ LACKS_SYS_MMAN_H NOT defined unless WIN32
-+
-+ Changing default word sizes:
-+
-+ INTERNAL_SIZE_T size_t
-+ MALLOC_ALIGNMENT 2 * sizeof(INTERNAL_SIZE_T)
-+
-+ Configuration and functionality options:
-+
-+ USE_DL_PREFIX NOT defined
-+ USE_PUBLIC_MALLOC_WRAPPERS NOT defined
-+ USE_MALLOC_LOCK NOT defined
-+ DEBUG NOT defined
-+ REALLOC_ZERO_BYTES_FREES NOT defined
-+ MALLOC_FAILURE_ACTION errno = ENOMEM, if __STD_C defined, else no-op
-+ TRIM_FASTBINS 0
-+
-+ Options for customizing MORECORE:
-+
-+ MORECORE sbrk
-+ MORECORE_CONTIGUOUS 1
-+ MORECORE_CANNOT_TRIM NOT defined
-+ MMAP_AS_MORECORE_SIZE (1024 * 1024)
-+
-+ Tuning options that are also dynamically changeable via mallopt:
-+
-+ DEFAULT_MXFAST 64
-+ DEFAULT_TRIM_THRESHOLD 128 * 1024
-+ DEFAULT_TOP_PAD 0
-+ DEFAULT_MMAP_THRESHOLD 128 * 1024
-+ DEFAULT_MMAP_MAX 65536
-+
-+ There are several other #defined constants and macros that you
-+ probably don't want to touch unless you are extending or adapting malloc.
-+*/
-+
-+/*
-+ WIN32 sets up defaults for MS environment and compilers.
-+ Otherwise defaults are for unix.
-+*/
-+
-+/* #define WIN32 */
-+
-+#ifdef WIN32
-+
-+#define WIN32_LEAN_AND_MEAN
-+#include <windows.h>
-+
-+/* Win32 doesn't supply or need the following headers */
-+#define LACKS_UNISTD_H
-+#define LACKS_SYS_PARAM_H
-+#define LACKS_SYS_MMAN_H
-+
-+/* Use the supplied emulation of sbrk */
-+#define MORECORE sbrk
-+#define MORECORE_CONTIGUOUS 1
-+#define MORECORE_FAILURE ((void*)(-1))
-+
-+/* Use the supplied emulation of mmap and munmap */
-+#define HAVE_MMAP 1
-+#define MUNMAP_FAILURE (-1)
-+#define MMAP_CLEARS 1
-+
-+/* These values don't really matter in windows mmap emulation */
-+#define MAP_PRIVATE 1
-+#define MAP_ANONYMOUS 2
-+#define PROT_READ 1
-+#define PROT_WRITE 2
-+
-+/* Emulation functions defined at the end of this file */
-+
-+/* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */
-+#ifdef USE_MALLOC_LOCK
-+static int slwait(int *sl);
-+static int slrelease(int *sl);
-+#endif
-+
-+static long getpagesize(void);
-+static long getregionsize(void);
-+static void *sbrk(long size);
-+static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg);
-+static long munmap(void *ptr, long size);
-+
-+static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed);
-+static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user);
-+
-+#endif
-+
-+/*
-+ __STD_C should be nonzero if using ANSI-standard C compiler, a C++
-+ compiler, or a C compiler sufficiently close to ANSI to get away
-+ with it.
-+*/
-+
-+#ifndef __STD_C
-+#if defined(__STDC__) || defined(_cplusplus)
-+#define __STD_C 1
-+#else
-+#define __STD_C 0
-+#endif
-+#endif /*__STD_C*/
-+
-+
-+/*
-+ Void_t* is the pointer type that malloc should say it returns
-+*/
-+
-+#ifndef Void_t
-+#if (__STD_C || defined(WIN32))
-+#define Void_t void
-+#else
-+#define Void_t char
-+#endif
-+#endif /*Void_t*/
-+
-+#if __STD_C
-+#include <stddef.h> /* for size_t */
-+#else
-+#include <sys/types.h>
-+#endif
-+
-+#ifdef __cplusplus
-+extern "C" {
-+#endif
-+
-+/* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */
-+
-+/* #define LACKS_UNISTD_H */
-+
-+#ifndef LACKS_UNISTD_H
-+#include <unistd.h>
-+#endif
-+
-+/* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */
-+
-+/* #define LACKS_SYS_PARAM_H */
-+
-+
-+#include <stdio.h> /* needed for malloc_stats */
-+#include <errno.h> /* needed for optional MALLOC_FAILURE_ACTION */
-+
-+
-+/*
-+ Debugging:
-+
-+ Because freed chunks may be overwritten with bookkeeping fields, this
-+ malloc will often die when freed memory is overwritten by user
-+ programs. This can be very effective (albeit in an annoying way)
-+ in helping track down dangling pointers.
-+
-+ If you compile with -DDEBUG, a number of assertion checks are
-+ enabled that will catch more memory errors. You probably won't be
-+ able to make much sense of the actual assertion errors, but they
-+ should help you locate incorrectly overwritten memory. The
-+ checking is fairly extensive, and will slow down execution
-+ noticeably. Calling malloc_stats or mallinfo with DEBUG set will
-+ attempt to check every non-mmapped allocated and free chunk in the
-+ course of computing the summmaries. (By nature, mmapped regions
-+ cannot be checked very much automatically.)
-+
-+ Setting DEBUG may also be helpful if you are trying to modify
-+ this code. The assertions in the check routines spell out in more
-+ detail the assumptions and invariants underlying the algorithms.
-+
-+ Setting DEBUG does NOT provide an automated mechanism for checking
-+ that all accesses to malloced memory stay within their
-+ bounds. However, there are several add-ons and adaptations of this
-+ or other mallocs available that do this.
-+*/
-+
-+#ifdef DEBUG
-+#include <assert.h>
-+#else
-+#define assert(x) ((void)0)
-+#endif
-+
-+
-+/*
-+ INTERNAL_SIZE_T is the word-size used for internal bookkeeping
-+ of chunk sizes.
-+
-+ The default version is the same as size_t.
-+
-+ While not strictly necessary, it is best to define this as an
-+ unsigned type, even if size_t is a signed type. This may avoid some
-+ artificial size limitations on some systems.
-+
-+ On a 64-bit machine, you may be able to reduce malloc overhead by
-+ defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the
-+ expense of not being able to handle more than 2^32 of malloced
-+ space. If this limitation is acceptable, you are encouraged to set
-+ this unless you are on a platform requiring 16byte alignments. In
-+ this case the alignment requirements turn out to negate any
-+ potential advantages of decreasing size_t word size.
-+
-+ Implementors: Beware of the possible combinations of:
-+ - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,
-+ and might be the same width as int or as long
-+ - size_t might have different width and signedness as INTERNAL_SIZE_T
-+ - int and long might be 32 or 64 bits, and might be the same width
-+ To deal with this, most comparisons and difference computations
-+ among INTERNAL_SIZE_Ts should cast them to unsigned long, being
-+ aware of the fact that casting an unsigned int to a wider long does
-+ not sign-extend. (This also makes checking for negative numbers
-+ awkward.) Some of these casts result in harmless compiler warnings
-+ on some systems.
-+*/
-+
-+#ifndef INTERNAL_SIZE_T
-+#define INTERNAL_SIZE_T size_t
-+#endif
-+
-+/* The corresponding word size */
-+#define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
-+
-+
-+/*
-+ MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
-+ It must be a power of two at least 2 * SIZE_SZ, even on machines
-+ for which smaller alignments would suffice. It may be defined as
-+ larger than this though. Note however that code and data structures
-+ are optimized for the case of 8-byte alignment.
-+*/
-+
-+
-+#ifndef MALLOC_ALIGNMENT
-+#define MALLOC_ALIGNMENT (2 * SIZE_SZ)
-+#endif
-+
-+/* The corresponding bit mask value */
-+#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
-+
-+
-+
-+/*
-+ REALLOC_ZERO_BYTES_FREES should be set if a call to
-+ realloc with zero bytes should be the same as a call to free.
-+ Some people think it should. Otherwise, since this malloc
-+ returns a unique pointer for malloc(0), so does realloc(p, 0).
-+*/
-+
-+/* #define REALLOC_ZERO_BYTES_FREES */
-+
-+/*
-+ TRIM_FASTBINS controls whether free() of a very small chunk can
-+ immediately lead to trimming. Setting to true (1) can reduce memory
-+ footprint, but will almost always slow down programs that use a lot
-+ of small chunks.
-+
-+ Define this only if you are willing to give up some speed to more
-+ aggressively reduce system-level memory footprint when releasing
-+ memory in programs that use many small chunks. You can get
-+ essentially the same effect by setting MXFAST to 0, but this can
-+ lead to even greater slowdowns in programs using many small chunks.
-+ TRIM_FASTBINS is an in-between compile-time option, that disables
-+ only those chunks bordering topmost memory from being placed in
-+ fastbins.
-+*/
-+
-+#ifndef TRIM_FASTBINS
-+#define TRIM_FASTBINS 0
-+#endif
-+
-+
-+/*
-+ USE_DL_PREFIX will prefix all public routines with the string 'dl'.
-+ This is necessary when you only want to use this malloc in one part
-+ of a program, using your regular system malloc elsewhere.
-+*/
-+
-+/* #define USE_DL_PREFIX */
-+
-+
-+/*
-+ USE_MALLOC_LOCK causes wrapper functions to surround each
-+ callable routine with pthread mutex lock/unlock.
-+
-+ USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined
-+*/
-+
-+
-+/* #define USE_MALLOC_LOCK */
-+
-+
-+/*
-+ If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is
-+ actually a wrapper function that first calls MALLOC_PREACTION, then
-+ calls the internal routine, and follows it with
-+ MALLOC_POSTACTION. This is needed for locking, but you can also use
-+ this, without USE_MALLOC_LOCK, for purposes of interception,
-+ instrumentation, etc. It is a sad fact that using wrappers often
-+ noticeably degrades performance of malloc-intensive programs.
-+*/
-+
-+#ifdef USE_MALLOC_LOCK
-+#define USE_PUBLIC_MALLOC_WRAPPERS
-+#else
-+/* #define USE_PUBLIC_MALLOC_WRAPPERS */
-+#endif
-+
-+
-+/*
-+ Two-phase name translation.
-+ All of the actual routines are given mangled names.
-+ When wrappers are used, they become the public callable versions.
-+ When DL_PREFIX is used, the callable names are prefixed.
-+*/
-+
-+#ifndef USE_PUBLIC_MALLOC_WRAPPERS
-+#define cALLOc public_cALLOc
-+#define fREe public_fREe
-+#define cFREe public_cFREe
-+#define mALLOc public_mALLOc
-+#define mEMALIGn public_mEMALIGn
-+#define rEALLOc public_rEALLOc
-+#define vALLOc public_vALLOc
-+#define pVALLOc public_pVALLOc
-+#define mALLINFo public_mALLINFo
-+#define mALLOPt public_mALLOPt
-+#define mTRIm public_mTRIm
-+#define mSTATs public_mSTATs
-+#define mUSABLe public_mUSABLe
-+#define iCALLOc public_iCALLOc
-+#define iCOMALLOc public_iCOMALLOc
-+#endif
-+
-+#ifdef USE_DL_PREFIX
-+#define public_cALLOc dlcalloc
-+#define public_fREe dlfree
-+#define public_cFREe dlcfree
-+#define public_mALLOc dlmalloc
-+#define public_mEMALIGn dlmemalign
-+#define public_rEALLOc dlrealloc
-+#define public_vALLOc dlvalloc
-+#define public_pVALLOc dlpvalloc
-+#define public_mALLINFo dlmallinfo
-+#define public_mALLOPt dlmallopt
-+#define public_mTRIm dlmalloc_trim
-+#define public_mSTATs dlmalloc_stats
-+#define public_mUSABLe dlmalloc_usable_size
-+#define public_iCALLOc dlindependent_calloc
-+#define public_iCOMALLOc dlindependent_comalloc
-+#else /* USE_DL_PREFIX */
-+#define public_cALLOc calloc
-+#define public_fREe free
-+#define public_cFREe cfree
-+#define public_mALLOc malloc
-+#define public_mEMALIGn memalign
-+#define public_rEALLOc realloc
-+#define public_vALLOc valloc
-+#define public_pVALLOc pvalloc
-+#define public_mALLINFo mallinfo
-+#define public_mALLOPt mallopt
-+#define public_mTRIm malloc_trim
-+#define public_mSTATs malloc_stats
-+#define public_mUSABLe malloc_usable_size
-+#define public_iCALLOc independent_calloc
-+#define public_iCOMALLOc independent_comalloc
-+#endif /* USE_DL_PREFIX */
-+
-+
-+/*
-+ HAVE_MEMCPY should be defined if you are not otherwise using
-+ ANSI STD C, but still have memcpy and memset in your C library
-+ and want to use them in calloc and realloc. Otherwise simple
-+ macro versions are defined below.
-+
-+ USE_MEMCPY should be defined as 1 if you actually want to
-+ have memset and memcpy called. People report that the macro
-+ versions are faster than libc versions on some systems.
-+
-+ Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks
-+ (of <= 36 bytes) are manually unrolled in realloc and calloc.
-+*/
-+
-+/* If it's available it's defined in config.h. */
-+/* #define HAVE_MEMCPY */
-+
-+#ifndef USE_MEMCPY
-+#ifdef HAVE_MEMCPY
-+#define USE_MEMCPY 1
-+#else
-+#define USE_MEMCPY 0
-+#endif
-+#endif
-+
-+
-+#if (__STD_C || defined(HAVE_MEMCPY))
-+
-+#ifdef WIN32
-+/* On Win32 memset and memcpy are already declared in windows.h */
-+#else
-+#if __STD_C
-+void* memset(void*, int, size_t);
-+void* memcpy(void*, const void*, size_t);
-+#else
-+Void_t* memset();
-+Void_t* memcpy();
-+#endif
-+#endif
-+#endif
-+
-+/*
-+ MALLOC_FAILURE_ACTION is the action to take before "return 0" when
-+ malloc fails to be able to return memory, either because memory is
-+ exhausted or because of illegal arguments.
-+
-+ By default, sets errno if running on STD_C platform, else does nothing.
-+*/
-+
-+#ifndef MALLOC_FAILURE_ACTION
-+#if __STD_C
-+#define MALLOC_FAILURE_ACTION \
-+ errno = ENOMEM;
-+
-+#else
-+#define MALLOC_FAILURE_ACTION
-+#endif
-+#endif
-+
-+/*
-+ MORECORE-related declarations. By default, rely on sbrk
-+*/
-+
-+
-+#ifdef LACKS_UNISTD_H
-+#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
-+#if __STD_C
-+extern Void_t* sbrk(ptrdiff_t);
-+#else
-+extern Void_t* sbrk();
-+#endif
-+#endif
-+#endif
-+
-+/*
-+ MORECORE is the name of the routine to call to obtain more memory
-+ from the system. See below for general guidance on writing
-+ alternative MORECORE functions, as well as a version for WIN32 and a
-+ sample version for pre-OSX macos.
-+*/
-+
-+#ifndef MORECORE
-+#define MORECORE sbrk
-+#endif
-+
-+/*
-+ MORECORE_FAILURE is the value returned upon failure of MORECORE
-+ as well as mmap. Since it cannot be an otherwise valid memory address,
-+ and must reflect values of standard sys calls, you probably ought not
-+ try to redefine it.
-+*/
-+
-+#ifndef MORECORE_FAILURE
-+#define MORECORE_FAILURE (-1)
-+#endif
-+
-+/*
-+ If MORECORE_CONTIGUOUS is true, take advantage of fact that
-+ consecutive calls to MORECORE with positive arguments always return
-+ contiguous increasing addresses. This is true of unix sbrk. Even
-+ if not defined, when regions happen to be contiguous, malloc will
-+ permit allocations spanning regions obtained from different
-+ calls. But defining this when applicable enables some stronger
-+ consistency checks and space efficiencies.
-+*/
-+
-+#ifndef MORECORE_CONTIGUOUS
-+#define MORECORE_CONTIGUOUS 1
-+#endif
-+
-+/*
-+ Define MORECORE_CANNOT_TRIM if your version of MORECORE
-+ cannot release space back to the system when given negative
-+ arguments. This is generally necessary only if you are using
-+ a hand-crafted MORECORE function that cannot handle negative arguments.
-+*/
-+
-+/* #define MORECORE_CANNOT_TRIM */
-+
-+
-+/*
-+ Define HAVE_MMAP as true to optionally make malloc() use mmap() to
-+ allocate very large blocks. These will be returned to the
-+ operating system immediately after a free(). Also, if mmap
-+ is available, it is used as a backup strategy in cases where
-+ MORECORE fails to provide space from system.
-+
-+ This malloc is best tuned to work with mmap for large requests.
-+ If you do not have mmap, operations involving very large chunks (1MB
-+ or so) may be slower than you'd like.
-+*/
-+
-+#ifndef HAVE_MMAP
-+#define HAVE_MMAP 1
-+#endif
-+
-+#if HAVE_MMAP
-+/*
-+ Standard unix mmap using /dev/zero clears memory so calloc doesn't
-+ need to.
-+*/
-+
-+#ifndef MMAP_CLEARS
-+#define MMAP_CLEARS 1
-+#endif
-+
-+#else /* no mmap */
-+#ifndef MMAP_CLEARS
-+#define MMAP_CLEARS 0
-+#endif
-+#endif
-+
-+
-+/*
-+ MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if
-+ sbrk fails, and mmap is used as a backup (which is done only if
-+ HAVE_MMAP). The value must be a multiple of page size. This
-+ backup strategy generally applies only when systems have "holes" in
-+ address space, so sbrk cannot perform contiguous expansion, but
-+ there is still space available on system. On systems for which
-+ this is known to be useful (i.e. most linux kernels), this occurs
-+ only when programs allocate huge amounts of memory. Between this,
-+ and the fact that mmap regions tend to be limited, the size should
-+ be large, to avoid too many mmap calls and thus avoid running out
-+ of kernel resources.
-+*/
-+
-+#ifndef MMAP_AS_MORECORE_SIZE
-+#define MMAP_AS_MORECORE_SIZE (1024 * 1024)
-+#endif
-+
-+/*
-+ Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
-+ large blocks. This is currently only possible on Linux with
-+ kernel versions newer than 1.3.77.
-+*/
-+
-+#ifndef HAVE_MREMAP
-+#if defined(linux) || defined(__linux__) || defined(__linux)
-+#define HAVE_MREMAP 1
-+#else
-+#define HAVE_MREMAP 0
-+#endif
-+
-+#endif /* HAVE_MMAP */
-+
-+
-+/*
-+ The system page size. To the extent possible, this malloc manages
-+ memory from the system in page-size units. Note that this value is
-+ cached during initialization into a field of malloc_state. So even
-+ if malloc_getpagesize is a function, it is only called once.
-+
-+ The following mechanics for getpagesize were adapted from bsd/gnu
-+ getpagesize.h. If none of the system-probes here apply, a value of
-+ 4096 is used, which should be OK: If they don't apply, then using
-+ the actual value probably doesn't impact performance.
-+*/
-+
-+
-+#ifndef malloc_getpagesize
-+
-+#ifndef LACKS_UNISTD_H
-+# include <unistd.h>
-+#endif
-+
-+# 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 */
-+# define malloc_getpagesize getpagesize()
-+# else
-+# ifndef LACKS_SYS_PARAM_H
-+# include <sys/param.h>
-+# endif
-+# ifdef EXEC_PAGESIZE
-+# define malloc_getpagesize EXEC_PAGESIZE
-+# else
-+# ifdef NBPG
-+# ifndef CLSIZE
-+# define malloc_getpagesize NBPG
-+# else
-+# define malloc_getpagesize (NBPG * CLSIZE)
-+# endif
-+# else
-+# ifdef NBPC
-+# define malloc_getpagesize NBPC
-+# else
-+# ifdef PAGESIZE
-+# define malloc_getpagesize PAGESIZE
-+# else /* just guess */
-+# define malloc_getpagesize (4096)
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+#endif
-+
-+/*
-+ This version of malloc supports the standard SVID/XPG mallinfo
-+ routine that returns a struct containing usage properties and
-+ statistics. It should work on any SVID/XPG compliant system that has
-+ a /usr/include/malloc.h defining struct mallinfo. (If you'd like to
-+ install such a thing yourself, cut out the preliminary declarations
-+ as described above and below and save them in a malloc.h file. But
-+ there's no compelling reason to bother to do this.)
-+
-+ The main declaration needed is the mallinfo struct that is returned
-+ (by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a
-+ bunch of field that are not even meaningful in this version of
-+ malloc. These fields are are instead filled by mallinfo() with
-+ other numbers that might be of interest.
-+
-+ HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
-+ /usr/include/malloc.h file that includes a declaration of struct
-+ mallinfo. If so, it is included; else an SVID2/XPG2 compliant
-+ version is declared below. These must be precisely the same for
-+ mallinfo() to work. The original SVID version of this struct,
-+ defined on most systems with mallinfo, declares all fields as
-+ ints. But some others define as unsigned long. If your system
-+ defines the fields using a type of different width than listed here,
-+ you must #include your system version and #define
-+ HAVE_USR_INCLUDE_MALLOC_H.
-+*/
-+
-+/* #define HAVE_USR_INCLUDE_MALLOC_H */
-+
-+/*#ifdef HAVE_USR_INCLUDE_MALLOC_H*/
-+#if 0
-+#include "/usr/include/malloc.h"
-+#else
-+
-+/* SVID2/XPG mallinfo structure */
-+
-+struct mallinfo {
-+ int arena; /* non-mmapped space allocated from system */
-+ int ordblks; /* number of free chunks */
-+ int smblks; /* number of fastbin blocks */
-+ int hblks; /* number of mmapped regions */
-+ int hblkhd; /* space in mmapped regions */
-+ int usmblks; /* maximum total allocated space */
-+ int fsmblks; /* space available in freed fastbin blocks */
-+ int uordblks; /* total allocated space */
-+ int fordblks; /* total free space */
-+ int keepcost; /* top-most, releasable (via malloc_trim) space */
-+};
-+
-+/*
-+ SVID/XPG defines four standard parameter numbers for mallopt,
-+ normally defined in malloc.h. Only one of these (M_MXFAST) is used
-+ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
-+ so setting them has no effect. But this malloc also supports other
-+ options in mallopt described below.
-+*/
-+#endif
-+
-+
-+/* ---------- description of public routines ------------ */
-+
-+/*
-+ malloc(size_t n)
-+ Returns a pointer to a newly allocated chunk of at least n bytes, or null
-+ if no space is available. Additionally, on failure, errno is
-+ set to ENOMEM on ANSI C systems.
-+
-+ If n is zero, malloc returns a minumum-sized chunk. (The minimum
-+ size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
-+ systems.) On most systems, size_t is an unsigned type, so calls
-+ with negative arguments 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.
-+*/
-+#if __STD_C
-+Void_t* public_mALLOc(size_t);
-+#else
-+Void_t* public_mALLOc();
-+#endif
-+
-+/*
-+ free(Void_t* 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. It can have arbitrary (i.e., bad!)
-+ effects if p has already been freed.
-+
-+ Unless disabled (using mallopt), freeing very large spaces will
-+ when possible, automatically trigger operations that give
-+ back unused memory to the system, thus reducing program footprint.
-+*/
-+#if __STD_C
-+void public_fREe(Void_t*);
-+#else
-+void public_fREe();
-+#endif
-+
-+/*
-+ calloc(size_t n_elements, size_t element_size);
-+ Returns a pointer to n_elements * element_size bytes, with all locations
-+ set to zero.
-+*/
-+#if __STD_C
-+Void_t* public_cALLOc(size_t, size_t);
-+#else
-+Void_t* public_cALLOc();
-+#endif
-+
-+/*
-+ realloc(Void_t* 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
-+ if no space is available.
-+
-+ The returned pointer may or may not be the same as p. The algorithm
-+ prefers extending p when possible, otherwise it employs the
-+ equivalent of a malloc-copy-free sequence.
-+
-+ If p is null, realloc is equivalent to malloc.
-+
-+ If space is not available, realloc returns null, errno is set (if on
-+ ANSI) and p is NOT freed.
-+
-+ if n is for fewer bytes than already held by p, the newly unused
-+ space is lopped off and freed if possible. Unless the #define
-+ REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of
-+ zero (re)allocates a minimum-sized chunk.
-+
-+ Large chunks that were internally obtained via mmap will always
-+ be reallocated using malloc-copy-free sequences unless
-+ the system supports MREMAP (currently only linux).
-+
-+ The old unix realloc convention of allowing the last-free'd chunk
-+ to be used as an argument to realloc is not supported.
-+*/
-+#if __STD_C
-+Void_t* public_rEALLOc(Void_t*, size_t);
-+#else
-+Void_t* public_rEALLOc();
-+#endif
-+
-+/*
-+ 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.
-+
-+ The alignment argument should be a power of two. If the argument is
-+ not a power of two, the nearest greater power is used.
-+ 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.
-+*/
-+#if __STD_C
-+Void_t* public_mEMALIGn(size_t, size_t);
-+#else
-+Void_t* public_mEMALIGn();
-+#endif
-+
-+/*
-+ 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.
-+*/
-+#if __STD_C
-+Void_t* public_vALLOc(size_t);
-+#else
-+Void_t* public_vALLOc();
-+#endif
-+
-+
-+
-+/*
-+ 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
-+ corresponding parameter to the argument value if it can (i.e., so
-+ long as the value is meaningful), and returns 1 if successful else
-+ 0. SVID/XPG/ANSI defines four standard param numbers for mallopt,
-+ normally defined in malloc.h. Only one of these (M_MXFAST) is used
-+ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
-+ so setting them has no effect. But this malloc also supports four
-+ other options in mallopt. See below for details. Briefly, supported
-+ parameters are as follows (listed defaults are for "typical"
-+ configurations).
-+
-+ Symbol param # default allowed param values
-+ M_MXFAST 1 64 0-80 (0 disables fastbins)
-+ M_TRIM_THRESHOLD -1 128*1024 any (-1U disables trimming)
-+ M_TOP_PAD -2 0 any
-+ M_MMAP_THRESHOLD -3 128*1024 any (or 0 if no MMAP support)
-+ M_MMAP_MAX -4 65536 any (0 disables use of mmap)
-+*/
-+#if __STD_C
-+int public_mALLOPt(int, int);
-+#else
-+int public_mALLOPt();
-+#endif
-+
-+
-+/*
-+ mallinfo()
-+ Returns (by copy) a struct containing various summary statistics:
-+
-+ arena: current total non-mmapped bytes allocated from system
-+ ordblks: the number of free chunks
-+ smblks: the number of fastbin blocks (i.e., small chunks that
-+ have been freed but not use resused or consolidated)
-+ hblks: current number of mmapped regions
-+ hblkhd: total bytes held in mmapped regions
-+ usmblks: the maximum total allocated space. This will be greater
-+ than current total if trimming has occurred.
-+ fsmblks: total bytes held in fastbin blocks
-+ uordblks: current total allocated space (normal or mmapped)
-+ fordblks: total free space
-+ keepcost: the maximum number of bytes that could ideally be released
-+ back to system via malloc_trim. ("ideally" means that
-+ it ignores page restrictions etc.)
-+
-+ Because these fields are ints, but internal bookkeeping may
-+ be kept as longs, the reported values may wrap around zero and
-+ thus be inaccurate.
-+*/
-+#if __STD_C
-+struct mallinfo public_mALLINFo(void);
-+#else
-+struct mallinfo public_mALLINFo();
-+#endif
-+
-+/*
-+ independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
-+
-+ independent_calloc is similar to calloc, but instead of returning a
-+ single cleared space, it returns an array of pointers to n_elements
-+ independent elements that can hold contents of size elem_size, each
-+ of which starts out cleared, and can be independently freed,
-+ realloc'ed etc. The elements are guaranteed to be adjacently
-+ allocated (this is not guaranteed to occur with multiple callocs or
-+ mallocs), which may also improve cache locality in some
-+ applications.
-+
-+ The "chunks" argument is optional (i.e., may be null, which is
-+ probably the most typical usage). If it is null, the returned array
-+ is itself dynamically allocated and should also be freed when it is
-+ no longer needed. Otherwise, the chunks array must be of at least
-+ n_elements in length. It is filled in with the pointers to the
-+ chunks.
-+
-+ In either case, independent_calloc returns this pointer array, or
-+ null if the allocation failed. If n_elements is zero and "chunks"
-+ is null, it returns a chunk representing an array with zero elements
-+ (which should be freed if not wanted).
-+
-+ Each element must be individually freed when it is no longer
-+ needed. If you'd like to instead be able to free all at once, you
-+ should instead use regular calloc and assign pointers into this
-+ space to represent elements. (In this case though, you cannot
-+ independently free elements.)
-+
-+ independent_calloc simplifies and speeds up implementations of many
-+ kinds of pools. It may also be useful when constructing large data
-+ structures that initially have a fixed number of fixed-sized nodes,
-+ but the number is not known at compile time, and some of the nodes
-+ may later need to be freed. For example:
-+
-+ struct Node { int item; struct Node* next; };
-+
-+ struct Node* build_list() {
-+ struct Node** pool;
-+ int n = read_number_of_nodes_needed();
-+ if (n <= 0) return 0;
-+ pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
-+ if (pool == 0) die();
-+ // organize into a linked list...
-+ struct Node* first = pool[0];
-+ for (i = 0; i < n-1; ++i)
-+ pool[i]->next = pool[i+1];
-+ free(pool); // Can now free the array (or not, if it is needed later)
-+ return first;
-+ }
-+*/
-+#if __STD_C
-+Void_t** public_iCALLOc(size_t, size_t, Void_t**);
-+#else
-+Void_t** public_iCALLOc();
-+#endif
-+
-+/*
-+ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
-+
-+ independent_comalloc allocates, all at once, a set of n_elements
-+ chunks with sizes indicated in the "sizes" array. It returns
-+ an array of pointers to these elements, each of which can be
-+ independently freed, realloc'ed etc. The elements are guaranteed to
-+ be adjacently allocated (this is not guaranteed to occur with
-+ multiple callocs or mallocs), which may also improve cache locality
-+ in some applications.
-+
-+ The "chunks" argument is optional (i.e., may be null). If it is null
-+ the returned array is itself dynamically allocated and should also
-+ be freed when it is no longer needed. Otherwise, the chunks array
-+ must be of at least n_elements in length. It is filled in with the
-+ pointers to the chunks.
-+
-+ In either case, independent_comalloc returns this pointer array, or
-+ null if the allocation failed. If n_elements is zero and chunks is
-+ null, it returns a chunk representing an array with zero elements
-+ (which should be freed if not wanted).
-+
-+ Each element must be individually freed when it is no longer
-+ needed. If you'd like to instead be able to free all at once, you
-+ should instead use a single regular malloc, and assign pointers at
-+ particular offsets in the aggregate space. (In this case though, you
-+ cannot independently free elements.)
-+
-+ independent_comallac differs from independent_calloc in that each
-+ element may have a different size, and also that it does not
-+ automatically clear elements.
-+
-+ independent_comalloc can be used to speed up allocation in cases
-+ where several structs or objects must always be allocated at the
-+ same time. For example:
-+
-+ struct Head { ... }
-+ struct Foot { ... }
-+
-+ void send_message(char* msg) {
-+ int msglen = strlen(msg);
-+ size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
-+ void* chunks[3];
-+ if (independent_comalloc(3, sizes, chunks) == 0)
-+ die();
-+ struct Head* head = (struct Head*)(chunks[0]);
-+ char* body = (char*)(chunks[1]);
-+ struct Foot* foot = (struct Foot*)(chunks[2]);
-+ // ...
-+ }
-+
-+ In general though, independent_comalloc is worth using only for
-+ larger values of n_elements. For small values, you probably won't
-+ detect enough difference from series of malloc calls to bother.
-+
-+ 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.
-+*/
-+#if __STD_C
-+Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
-+#else
-+Void_t** public_iCOMALLOc();
-+#endif
-+
-+
-+/*
-+ pvalloc(size_t n);
-+ Equivalent to valloc(minimum-page-that-holds(n)), that is,
-+ round up n to nearest pagesize.
-+ */
-+#if __STD_C
-+Void_t* public_pVALLOc(size_t);
-+#else
-+Void_t* public_pVALLOc();
-+#endif
-+
-+/*
-+ cfree(Void_t* p);
-+ Equivalent to free(p).
-+
-+ cfree is needed/defined on some systems that pair it with calloc,
-+ for odd historical reasons (such as: cfree is used in example
-+ code in the first edition of K&R).
-+*/
-+#if __STD_C
-+void public_cFREe(Void_t*);
-+#else
-+void public_cFREe();
-+#endif
-+
-+/*
-+ malloc_trim(size_t pad);
-+
-+ If possible, gives memory back to the system (via negative
-+ arguments to sbrk) if there is unused memory at the `high' end of
-+ the malloc pool. You can call this after freeing large blocks of
-+ memory to potentially reduce the system-level memory requirements
-+ of a program. However, it cannot guarantee to reduce memory. Under
-+ some allocation patterns, some large free blocks of memory will be
-+ locked between two used chunks, so they cannot be given back to
-+ the system.
-+
-+ The `pad' argument to malloc_trim represents the amount of free
-+ trailing space to leave untrimmed. If this argument is zero,
-+ only the minimum amount of memory to maintain internal data
-+ structures will be left (one page or less). Non-zero arguments
-+ can be supplied to maintain enough 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.
-+ On systems that do not support "negative sbrks", it will always
-+ rreturn 0.
-+*/
-+#if __STD_C
-+int public_mTRIm(size_t);
-+#else
-+int public_mTRIm();
-+#endif
-+
-+/*
-+ malloc_usable_size(Void_t* p);
-+
-+ Returns the number of bytes you can actually use in
-+ an allocated chunk, which may be more than you requested (although
-+ often not) due to alignment and minimum size constraints.
-+ You can use this many bytes without worrying about
-+ overwriting other allocated objects. This is not a particularly great
-+ programming practice. malloc_usable_size can be more useful in
-+ debugging and assertions, for example:
-+
-+ p = malloc(n);
-+ assert(malloc_usable_size(p) >= 256);
-+
-+*/
-+#if __STD_C
-+size_t public_mUSABLe(Void_t*);
-+#else
-+size_t public_mUSABLe();
-+#endif
-+
-+/*
-+ 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
-+ current if malloc_trim and/or munmap got called), and the current
-+ number of bytes allocated via malloc (or realloc, etc) but not yet
-+ freed. Note that this is the number of bytes allocated, not the
-+ number requested. It will be larger than the number requested
-+ because of alignment and bookkeeping overhead. Because it includes
-+ alignment wastage as being in use, this figure may be greater than
-+ zero even when no user-level chunks are allocated.
-+
-+ The reported current and maximum system memory can be inaccurate if
-+ a program makes other calls to system memory allocation functions
-+ (normally sbrk) outside of malloc.
-+
-+ malloc_stats prints only the most commonly interesting statistics.
-+ More information can be obtained by calling mallinfo.
-+
-+*/
-+#if __STD_C
-+void public_mSTATs();
-+#else
-+void public_mSTATs();
-+#endif
-+
-+/* mallopt tuning options */
-+
-+/*
-+ M_MXFAST is the maximum request size used for "fastbins", special bins
-+ that hold returned chunks without consolidating their spaces. This
-+ enables future requests for chunks of the same size to be handled
-+ very quickly, but can increase fragmentation, and thus increase the
-+ overall memory footprint of a program.
-+
-+ This malloc manages fastbins very conservatively yet still
-+ efficiently, so fragmentation is rarely a problem for values less
-+ than or equal to the default. The maximum supported value of MXFAST
-+ is 80. You wouldn't want it any higher than this anyway. Fastbins
-+ are designed especially for use with many small structs, objects or
-+ strings -- the default handles structs/objects/arrays with sizes up
-+ to 8 4byte fields, or small strings representing words, tokens,
-+ etc. Using fastbins for larger objects normally worsens
-+ fragmentation without improving speed.
-+
-+ M_MXFAST is set in REQUEST size units. It is internally used in
-+ chunksize units, which adds padding and alignment. You can reduce
-+ M_MXFAST to 0 to disable all use of fastbins. This causes the malloc
-+ algorithm to be a closer approximation of fifo-best-fit in all cases,
-+ not just for larger requests, but will generally cause it to be
-+ slower.
-+*/
-+
-+
-+/* M_MXFAST is a standard SVID/XPG tuning option, usually listed in malloc.h */
-+#ifndef M_MXFAST
-+#define M_MXFAST 1
-+#endif
-+
-+#ifndef DEFAULT_MXFAST
-+#define DEFAULT_MXFAST 64
-+#endif
-+
-+
-+/*
-+ M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
-+ to keep before releasing via malloc_trim in free().
-+
-+ Automatic trimming is mainly useful in long-lived programs.
-+ Because trimming via sbrk can be slow on some systems, and can
-+ sometimes be wasteful (in cases where programs immediately
-+ afterward allocate more large chunks) the value should be high
-+ enough so that your overall system performance would improve by
-+ releasing this much memory.
-+
-+ The trim threshold and the mmap control parameters (see below)
-+ can be traded off with one another. Trimming and mmapping are
-+ two different ways of releasing unused memory back to the
-+ system. Between these two, it is often possible to keep
-+ system-level demands of a long-lived program down to a bare
-+ minimum. For example, in one test suite of sessions measuring
-+ the XF86 X server on Linux, using a trim threshold of 128K and a
-+ mmap threshold of 192K led to near-minimal long term resource
-+ consumption.
-+
-+ If you are using this malloc in a long-lived program, it should
-+ pay to experiment with these values. As a rough guide, you
-+ might set to a value close to the average size of a process
-+ (program) running on your system. Releasing this much memory
-+ would allow such a process to run in memory. Generally, it's
-+ worth it to tune for trimming rather tham memory mapping when a
-+ program undergoes phases where several large chunks are
-+ allocated and released in ways that can reuse each other's
-+ storage, perhaps mixed with phases where there are no such
-+ chunks at all. And in well-behaved long-lived programs,
-+ controlling release of large blocks via trimming versus mapping
-+ is usually faster.
-+
-+ However, in most programs, these parameters serve mainly as
-+ protection against the system-level effects of carrying around
-+ massive amounts of unneeded memory. Since frequent calls to
-+ sbrk, mmap, and munmap otherwise degrade performance, the default
-+ parameters are set to relatively high values that serve only as
-+ safeguards.
-+
-+ The trim value It must be greater than page size to have any useful
-+ effect. To disable trimming completely, you can set to
-+ (unsigned long)(-1)
-+
-+ Trim settings interact with fastbin (MXFAST) settings: Unless
-+ TRIM_FASTBINS is defined, automatic trimming never takes place upon
-+ freeing a chunk with size less than or equal to MXFAST. Trimming is
-+ instead delayed until subsequent freeing of larger chunks. However,
-+ you can still force an attempted trim by calling malloc_trim.
-+
-+ Also, trimming is not generally possible in cases where
-+ the main arena is obtained via mmap.
-+
-+ Note that the trick some people use of mallocing a huge space and
-+ then freeing it at program startup, in an attempt to reserve system
-+ memory, doesn't have the intended effect under automatic trimming,
-+ since that memory will immediately be returned to the system.
-+*/
-+
-+#define M_TRIM_THRESHOLD -1
-+
-+#ifndef DEFAULT_TRIM_THRESHOLD
-+#define DEFAULT_TRIM_THRESHOLD (128 * 1024)
-+#endif
-+
-+/*
-+ M_TOP_PAD is the amount of extra `padding' space to allocate or
-+ retain whenever sbrk is called. It is used in two ways internally:
-+
-+ * When sbrk is called to extend the top of the arena to satisfy
-+ a new malloc request, this much padding is added to the sbrk
-+ request.
-+
-+ * When malloc_trim is called automatically from free(),
-+ it is used as the `pad' argument.
-+
-+ In both cases, the actual amount of padding is rounded
-+ so that the end of the arena is always a system page boundary.
-+
-+ The main reason for using padding is to avoid calling sbrk so
-+ often. Having even a small pad greatly reduces the likelihood
-+ that nearly every malloc request during program start-up (or
-+ after trimming) will invoke sbrk, which needlessly wastes
-+ time.
-+
-+ Automatic rounding-up to page-size units is normally sufficient
-+ to avoid measurable overhead, so the default is 0. However, in
-+ systems where sbrk is relatively slow, it can pay to increase
-+ this value, at the expense of carrying around more memory than
-+ the program needs.
-+*/
-+
-+#define M_TOP_PAD -2
-+
-+#ifndef DEFAULT_TOP_PAD
-+#define DEFAULT_TOP_PAD (0)
-+#endif
-+
-+/*
-+ M_MMAP_THRESHOLD is the request size threshold for using mmap()
-+ to service a request. Requests of at least this size that cannot
-+ be allocated using already-existing space will be serviced via mmap.
-+ (If enough normal freed space already exists it is used instead.)
-+
-+ Using mmap segregates relatively large chunks of memory so that
-+ they can be individually obtained and released from the host
-+ system. A request serviced through mmap is never reused by any
-+ other request (at least not directly; the system may just so
-+ happen to remap successive requests to the same locations).
-+
-+ Segregating space in this way has the benefits that:
-+
-+ 1. Mmapped space can ALWAYS be individually released back
-+ to the system, which helps keep the system level memory
-+ demands of a long-lived program low.
-+ 2. Mapped memory can never become `locked' between
-+ other chunks, as can happen with normally allocated chunks, which
-+ means that even trimming via malloc_trim would not release them.
-+ 3. On some systems with "holes" in address spaces, mmap can obtain
-+ memory that sbrk cannot.
-+
-+ However, it has the disadvantages that:
-+
-+ 1. The space cannot be reclaimed, consolidated, and then
-+ used to service later requests, as happens with normal chunks.
-+ 2. It can lead to more wastage because of mmap page alignment
-+ requirements
-+ 3. It causes malloc performance to be more dependent on host
-+ system memory management support routines which may vary in
-+ implementation quality and may impose arbitrary
-+ limitations. Generally, servicing a request via normal
-+ malloc steps is faster than going through a system's mmap.
-+
-+ The advantages of mmap nearly always outweigh disadvantages for
-+ "large" chunks, but the value of "large" varies across systems. The
-+ default is an empirically derived value that works well in most
-+ systems.
-+*/
-+
-+#define M_MMAP_THRESHOLD -3
-+
-+#ifndef DEFAULT_MMAP_THRESHOLD
-+#define DEFAULT_MMAP_THRESHOLD (128 * 1024)
-+#endif
-+
-+/*
-+ M_MMAP_MAX is the maximum number of requests to simultaneously
-+ service using mmap. This parameter exists because
-+. Some systems have a limited number of internal tables for
-+ use by mmap, and using more than a few of them may degrade
-+ performance.
-+
-+ The default is set to a value that serves only as a safeguard.
-+ Setting to 0 disables use of mmap for servicing large requests. If
-+ HAVE_MMAP is not set, the default value is 0, and attempts to set it
-+ to non-zero values in mallopt will fail.
-+*/
-+
-+#define M_MMAP_MAX -4
-+
-+#ifndef DEFAULT_MMAP_MAX
-+#if HAVE_MMAP
-+#define DEFAULT_MMAP_MAX (65536)
-+#else
-+#define DEFAULT_MMAP_MAX (0)
-+#endif
-+#endif
-+
-+#ifdef __cplusplus
-+}; /* end of extern "C" */
-+#endif
-+
-+/*
-+ ========================================================================
-+ To make a fully customizable malloc.h header file, cut everything
-+ above this line, put into file malloc.h, edit to suit, and #include it
-+ on the next line, as well as in programs that use this malloc.
-+ ========================================================================
-+*/
-+
-+/* #include "malloc.h" */
-+
-+/* --------------------- public wrappers ---------------------- */
-+
-+#ifdef USE_PUBLIC_MALLOC_WRAPPERS
-+
-+/* Declare all routines as internal */
-+#if __STD_C
-+static Void_t* mALLOc(size_t);
-+static void fREe(Void_t*);
-+static Void_t* rEALLOc(Void_t*, size_t);
-+static Void_t* mEMALIGn(size_t, size_t);
-+static Void_t* vALLOc(size_t);
-+static Void_t* pVALLOc(size_t);
-+static Void_t* cALLOc(size_t, size_t);
-+static Void_t** iCALLOc(size_t, size_t, Void_t**);
-+static Void_t** iCOMALLOc(size_t, size_t*, Void_t**);
-+static void cFREe(Void_t*);
-+static int mTRIm(size_t);
-+static size_t mUSABLe(Void_t*);
-+static void mSTATs();
-+static int mALLOPt(int, int);
-+static struct mallinfo mALLINFo(void);
-+#else
-+static Void_t* mALLOc();
-+static void fREe();
-+static Void_t* rEALLOc();
-+static Void_t* mEMALIGn();
-+static Void_t* vALLOc();
-+static Void_t* pVALLOc();
-+static Void_t* cALLOc();
-+static Void_t** iCALLOc();
-+static Void_t** iCOMALLOc();
-+static void cFREe();
-+static int mTRIm();
-+static size_t mUSABLe();
-+static void mSTATs();
-+static int mALLOPt();
-+static struct mallinfo mALLINFo();
-+#endif
-+
-+/*
-+ MALLOC_PREACTION and MALLOC_POSTACTION should be
-+ defined to return 0 on success, and nonzero on failure.
-+ The return value of MALLOC_POSTACTION is currently ignored
-+ in wrapper functions since there is no reasonable default
-+ action to take on failure.
-+*/
-+
-+
-+#ifdef USE_MALLOC_LOCK
-+
-+#ifdef WIN32
-+
-+static int mALLOC_MUTEx;
-+#define MALLOC_PREACTION slwait(&mALLOC_MUTEx)
-+#define MALLOC_POSTACTION slrelease(&mALLOC_MUTEx)
-+
-+#else
-+
-+#if 0
-+#include <pthread.h>
-+
-+static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER;
-+
-+#define MALLOC_PREACTION pthread_mutex_lock(&mALLOC_MUTEx)
-+#define MALLOC_POSTACTION pthread_mutex_unlock(&mALLOC_MUTEx)
-+
-+#else
-+
-+#ifdef KDE_MALLOC_X86
-+#include "x86.h"
-+#elif defined(KDE_MALLOC_AVR32)
-+
-+#include <sched.h>
-+#include <time.h>
-+
-+static __inline__ int q_atomic_swp(volatile unsigned int *ptr,
-+ unsigned int newval)
-+{
-+ register int ret;
-+ asm volatile("xchg %0,%1,%2"
-+ : "=&r"(ret)
-+ : "r"(ptr), "r"(newval)
-+ : "memory", "cc");
-+ return ret;
-+}
-+
-+typedef struct {
-+ volatile unsigned int lock;
-+ int pad0_;
-+} mutex_t;
-+
-+#define MUTEX_INITIALIZER { 0, 0 }
-+
-+static __inline__ int lock(mutex_t *m) {
-+ int cnt = 0;
-+ struct timespec tm;
-+
-+ for(;;) {
-+ if (q_atomic_swp(&m->lock, 1) == 0)
-+ return 0;
-+#ifdef _POSIX_PRIORITY_SCHEDULING
-+ if(cnt < 50) {
-+ sched_yield();
-+ cnt++;
-+ } else
-+#endif
-+ {
-+ tm.tv_sec = 0;
-+ tm.tv_nsec = 2000001;
-+ nanosleep(&tm, NULL);
-+ cnt = 0;
-+ }
-+ }
-+}
-+
-+static __inline__ int unlock(mutex_t *m) {
-+ m->lock = 0;
-+ return 0;
-+}
-+
-+#else
-+#error Unknown spinlock implementation
-+#endif
-+
-+static mutex_t spinlock = MUTEX_INITIALIZER;
-+
-+#define MALLOC_PREACTION lock( &spinlock )
-+#define MALLOC_POSTACTION unlock( &spinlock )
-+
-+#endif
-+
-+#endif /* USE_MALLOC_LOCK */
-+
-+#else
-+
-+/* Substitute anything you like for these */
-+
-+#define MALLOC_PREACTION (0)
-+#define MALLOC_POSTACTION (0)
-+
-+#endif
-+
-+#if 0
-+Void_t* public_mALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+void public_fREe(Void_t* m) {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ fREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = rEALLOc(m, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mEMALIGn(alignment, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_vALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = vALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_pVALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = pVALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_cALLOc(size_t n, size_t elem_size) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = cALLOc(n, elem_size);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+
-+Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {
-+ Void_t** m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = iCALLOc(n, elem_size, chunks);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {
-+ Void_t** m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = iCOMALLOc(n, sizes, chunks);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+void public_cFREe(Void_t* m) {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ cFREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+int public_mTRIm(size_t s) {
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mTRIm(s);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+
-+size_t public_mUSABLe(Void_t* m) {
-+ size_t result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mUSABLe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+
-+void public_mSTATs() {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ mSTATs();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+struct mallinfo public_mALLINFo() {
-+ struct mallinfo m;
-+ if (MALLOC_PREACTION != 0) {
-+ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-+ return nm;
-+ }
-+ m = mALLINFo();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+int public_mALLOPt(int p, int v) {
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mALLOPt(p, v);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+#endif
-+
-+#endif
-+
-+
-+
-+/* ------------- Optional versions of memcopy ---------------- */
-+
-+
-+#if USE_MEMCPY
-+
-+/*
-+ Note: memcpy is ONLY invoked with non-overlapping regions,
-+ so the (usually slower) memmove is not needed.
-+*/
-+
-+#define MALLOC_COPY(dest, src, nbytes) memcpy(dest, src, nbytes)
-+#define MALLOC_ZERO(dest, nbytes) memset(dest, 0, nbytes)
-+
-+#else /* !USE_MEMCPY */
-+
-+/* Use Duff's device for good zeroing/copying performance. */
-+
-+#define MALLOC_ZERO(charp, nbytes) \
-+do { \
-+ INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \
-+ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
-+ long mcn; \
-+ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
-+ switch (mctmp) { \
-+ case 0: for(;;) { *mzp++ = 0; \
-+ case 7: *mzp++ = 0; \
-+ case 6: *mzp++ = 0; \
-+ case 5: *mzp++ = 0; \
-+ case 4: *mzp++ = 0; \
-+ case 3: *mzp++ = 0; \
-+ case 2: *mzp++ = 0; \
-+ case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \
-+ } \
-+} while(0)
-+
-+#define MALLOC_COPY(dest,src,nbytes) \
-+do { \
-+ INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \
-+ INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \
-+ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
-+ long mcn; \
-+ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
-+ switch (mctmp) { \
-+ case 0: for(;;) { *mcdst++ = *mcsrc++; \
-+ case 7: *mcdst++ = *mcsrc++; \
-+ case 6: *mcdst++ = *mcsrc++; \
-+ case 5: *mcdst++ = *mcsrc++; \
-+ case 4: *mcdst++ = *mcsrc++; \
-+ case 3: *mcdst++ = *mcsrc++; \
-+ case 2: *mcdst++ = *mcsrc++; \
-+ case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \
-+ } \
-+} while(0)
-+
-+#endif
-+
-+/* ------------------ MMAP support ------------------ */
-+
-+
-+#if HAVE_MMAP
-+
-+#include <fcntl.h>
-+#ifndef LACKS_SYS_MMAN_H
-+#include <sys/mman.h>
-+#endif
-+
-+#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
-+#define MAP_ANONYMOUS MAP_ANON
-+#endif
-+
-+/*
-+ Nearly all versions of mmap support MAP_ANONYMOUS,
-+ so the following is unlikely to be needed, but is
-+ supplied just in case.
-+*/
-+
-+#ifndef MAP_ANONYMOUS
-+
-+static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
-+
-+#define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? \
-+ (dev_zero_fd = open("/dev/zero", O_RDWR), \
-+ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : \
-+ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0))
-+
-+#else
-+
-+#define MMAP(addr, size, prot, flags) \
-+ (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0))
-+
-+#endif
-+
-+
-+#endif /* HAVE_MMAP */
-+
-+
-+/*
-+ ----------------------- Chunk representations -----------------------
-+*/
-+
-+
-+/*
-+ This struct declaration is misleading (but accurate and necessary).
-+ It declares a "view" into memory allowing access to necessary
-+ fields at known offsets from a given base. See explanation below.
-+*/
-+
-+struct malloc_chunk {
-+
-+ INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
-+ INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
-+
-+ struct malloc_chunk* fd; /* double links -- used only if free. */
-+ struct malloc_chunk* bk;
-+};
-+
-+
-+typedef struct malloc_chunk* mchunkptr;
-+
-+/*
-+ malloc_chunk details:
-+
-+ (The following includes lightly edited explanations by Colin Plumb.)
-+
-+ Chunks of memory are maintained using a `boundary tag' method as
-+ described in e.g., Knuth or Standish. (See the paper by Paul
-+ Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
-+ survey of such techniques.) Sizes of free chunks are stored both
-+ in the front of each chunk and at the end. This makes
-+ consolidating fragmented chunks into bigger chunks very fast. The
-+ size fields also hold bits representing whether chunks are free or
-+ in use.
-+
-+ An allocated chunk looks like this:
-+
-+
-+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of previous chunk, if allocated | |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of chunk, in bytes |P|
-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | User data starts here... .
-+ . .
-+ . (malloc_usable_space() bytes) .
-+ . |
-+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of chunk |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+
-+
-+ Where "chunk" is the front of the chunk for the purpose of most of
-+ the malloc code, but "mem" is the pointer that is returned to the
-+ user. "Nextchunk" is the beginning of the next contiguous chunk.
-+
-+ Chunks always begin on even word boundaries, so the mem portion
-+ (which is returned to the user) is also on an even word boundary, and
-+ thus at least double-word aligned.
-+
-+ Free chunks are stored in circular doubly-linked lists, and look like this:
-+
-+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of previous chunk |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ `head:' | Size of chunk, in bytes |P|
-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Forward pointer to next chunk in list |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Back pointer to previous chunk in list |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Unused space (may be 0 bytes long) .
-+ . .
-+ . |
-+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ `foot:' | Size of chunk, in bytes |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+
-+ The P (PREV_INUSE) bit, stored in the unused low-order bit of the
-+ chunk size (which is always a multiple of two words), is an in-use
-+ bit for the *previous* chunk. If that bit is *clear*, then the
-+ word before the current chunk size contains the previous chunk
-+ size, and can be used to find the front of the previous chunk.
-+ The very first chunk allocated always has this bit set,
-+ preventing access to non-existent (or non-owned) memory. If
-+ prev_inuse is set for any given chunk, then you CANNOT determine
-+ the size of the previous chunk, and might even get a memory
-+ addressing fault when trying to do so.
-+
-+ Note that the `foot' of the current chunk is actually represented
-+ as the prev_size of the NEXT chunk. This makes it easier to
-+ deal with alignments etc but can be very confusing when trying
-+ to extend or adapt this code.
-+
-+ The two exceptions to all this are
-+
-+ 1. The special chunk `top' doesn't bother using the
-+ trailing size field since there is no next contiguous chunk
-+ that would have to index off it. After initialization, `top'
-+ is forced to always exist. If it would become less than
-+ MINSIZE bytes long, it is replenished.
-+
-+ 2. Chunks allocated via mmap, which have the second-lowest-order
-+ bit (IS_MMAPPED) set in their size fields. Because they are
-+ allocated one-by-one, each must contain its own trailing size field.
-+
-+*/
-+
-+/*
-+ ---------- Size and alignment checks and conversions ----------
-+*/
-+
-+/* conversion from malloc headers to user pointers, and back */
-+
-+#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ))
-+#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
-+
-+/* The smallest possible chunk */
-+#define MIN_CHUNK_SIZE (sizeof(struct malloc_chunk))
-+
-+/* The smallest size we can malloc is an aligned minimal chunk */
-+
-+#define MINSIZE \
-+ (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
-+
-+/* Check if m has acceptable alignment */
-+
-+#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
-+
-+
-+/*
-+ Check if a request is so large that it would wrap around zero when
-+ padded and aligned. To simplify some other code, the bound is made
-+ low enough so that adding MINSIZE will also not wrap around zero.
-+*/
-+
-+#define REQUEST_OUT_OF_RANGE(req) \
-+ ((unsigned long)(req) >= \
-+ (unsigned long)(INTERNAL_SIZE_T)(-2 * MINSIZE))
-+
-+/* pad request bytes into a usable size -- internal version */
-+
-+#define request2size(req) \
-+ (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \
-+ MINSIZE : \
-+ ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
-+
-+/* Same, except also perform argument check */
-+
-+#define checked_request2size(req, sz) \
-+ if (REQUEST_OUT_OF_RANGE(req)) { \
-+ MALLOC_FAILURE_ACTION; \
-+ return 0; \
-+ } \
-+ (sz) = request2size(req);
-+
-+/*
-+ --------------- Physical chunk operations ---------------
-+*/
-+
-+
-+/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
-+#define PREV_INUSE 0x1
-+
-+/* extract inuse bit of previous chunk */
-+#define prev_inuse(p) ((p)->size & PREV_INUSE)
-+
-+
-+/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
-+#define IS_MMAPPED 0x2
-+
-+/* check for mmap()'ed chunk */
-+#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
-+
-+/*
-+ Bits to mask off when extracting size
-+
-+ Note: IS_MMAPPED is intentionally not masked off from size field in
-+ macros for which mmapped chunks should never be seen. This should
-+ cause helpful core dumps to occur if it is tried by accident by
-+ people extending or adapting this malloc.
-+*/
-+#define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
-+
-+/* Get size, ignoring use bits */
-+#define chunksize(p) ((p)->size & ~(SIZE_BITS))
-+
-+
-+/* Ptr to next physical malloc_chunk. */
-+#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
-+
-+/* Ptr to previous physical malloc_chunk */
-+#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
-+
-+/* Treat space at ptr + offset as a chunk */
-+#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
-+
-+/* extract p's inuse bit */
-+#define inuse(p)\
-+((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
-+
-+/* set/clear chunk as being inuse without otherwise disturbing */
-+#define set_inuse(p)\
-+((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
-+
-+#define clear_inuse(p)\
-+((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
-+
-+
-+/* check/set/clear inuse bits in known places */
-+#define inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
-+
-+#define set_inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
-+
-+#define clear_inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
-+
-+
-+/* Set size at head, without disturbing its use bit */
-+#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s)))
-+
-+/* Set size/use field */
-+#define set_head(p, s) ((p)->size = (s))
-+
-+/* Set size at footer (only when chunk is not in use) */
-+#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
-+
-+
-+/*
-+ -------------------- Internal data structures --------------------
-+
-+ All internal state is held in an instance of malloc_state defined
-+ below. There are no other static variables, except in two optional
-+ cases:
-+ * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
-+ * If HAVE_MMAP is true, but mmap doesn't support
-+ MAP_ANONYMOUS, a dummy file descriptor for mmap.
-+
-+ Beware of lots of tricks that minimize the total bookkeeping space
-+ requirements. The result is a little over 1K bytes (for 4byte
-+ pointers and size_t.)
-+*/
-+
-+/*
-+ Bins
-+
-+ An array of bin headers for free chunks. Each bin is doubly
-+ linked. The bins are approximately proportionally (log) spaced.
-+ There are a lot of these bins (128). This may look excessive, but
-+ works very well in practice. Most bins hold sizes that are
-+ unusual as malloc request sizes, but are more usual for fragments
-+ and consolidated sets of chunks, which is what these bins hold, so
-+ they can be found quickly. All procedures maintain the invariant
-+ that no consolidated chunk physically borders another one, so each
-+ chunk in a list is known to be preceded and followed by either
-+ inuse chunks or the ends of memory.
-+
-+ Chunks in bins are kept in size order, with ties going to the
-+ approximately least recently used chunk. Ordering isn't needed
-+ for the small bins, which all contain the same-sized chunks, but
-+ facilitates best-fit allocation for larger chunks. These lists
-+ are just sequential. Keeping them in order almost never requires
-+ enough traversal to warrant using fancier ordered data
-+ structures.
-+
-+ Chunks of the same size are linked with the most
-+ recently freed at the front, and allocations are taken from the
-+ back. This results in LRU (FIFO) allocation order, which tends
-+ to give each chunk an equal opportunity to be consolidated with
-+ adjacent freed chunks, resulting in larger free chunks and less
-+ fragmentation.
-+
-+ To simplify use in double-linked lists, each bin header acts
-+ as a malloc_chunk. This avoids special-casing for headers.
-+ But to conserve space and improve locality, we allocate
-+ only the fd/bk pointers of bins, and then use repositioning tricks
-+ to treat these as the fields of a malloc_chunk*.
-+*/
-+
-+typedef struct malloc_chunk* mbinptr;
-+
-+/* addressing -- note that bin_at(0) does not exist */
-+#define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1)))
-+
-+/* analog of ++bin */
-+#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
-+
-+/* Reminders about list directionality within bins */
-+#define first(b) ((b)->fd)
-+#define last(b) ((b)->bk)
-+
-+/* Take a chunk off a bin list */
-+#define unlink(P, BK, FD) { \
-+ FD = P->fd; \
-+ BK = P->bk; \
-+ FD->bk = BK; \
-+ BK->fd = FD; \
-+}
-+
-+/*
-+ Indexing
-+
-+ Bins for sizes < 512 bytes contain chunks of all the same size, spaced
-+ 8 bytes apart. Larger bins are approximately logarithmically spaced:
-+
-+ 64 bins of size 8
-+ 32 bins of size 64
-+ 16 bins of size 512
-+ 8 bins of size 4096
-+ 4 bins of size 32768
-+ 2 bins of size 262144
-+ 1 bin of size what's left
-+
-+ There is actually a little bit of slop in the numbers in bin_index
-+ for the sake of speed. This makes no difference elsewhere.
-+
-+ The bins top out around 1MB because we expect to service large
-+ requests via mmap.
-+*/
-+
-+#define NBINS 128
-+#define NSMALLBINS 64
-+#define SMALLBIN_WIDTH 8
-+#define MIN_LARGE_SIZE 512
-+
-+#define in_smallbin_range(sz) \
-+ ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
-+
-+#define smallbin_index(sz) (((unsigned)(sz)) >> 3)
-+
-+#define largebin_index(sz) \
-+(((((unsigned long)(sz)) >> 6) <= 32)? 56 + (((unsigned long)(sz)) >> 6): \
-+ ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
-+ ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
-+ ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
-+ ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
-+ 126)
-+
-+#define bin_index(sz) \
-+ ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
-+
-+
-+/*
-+ Unsorted chunks
-+
-+ All remainders from chunk splits, as well as all returned chunks,
-+ are first placed in the "unsorted" bin. They are then placed
-+ in regular bins after malloc gives them ONE chance to be used before
-+ binning. So, basically, the unsorted_chunks list acts as a queue,
-+ with chunks being placed on it in free (and malloc_consolidate),
-+ and taken off (to be either used or placed in bins) in malloc.
-+*/
-+
-+/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
-+#define unsorted_chunks(M) (bin_at(M, 1))
-+
-+/*
-+ Top
-+
-+ The top-most available chunk (i.e., the one bordering the end of
-+ available memory) is treated specially. It is never included in
-+ any bin, is used only if no other chunk is available, and is
-+ released back to the system if it is very large (see
-+ M_TRIM_THRESHOLD). Because top initially
-+ points to its own bin with initial zero size, thus forcing
-+ extension on the first malloc request, we avoid having any special
-+ code in malloc to check whether it even exists yet. But we still
-+ need to do so when getting memory from system, so we make
-+ initial_top treat the bin as a legal but unusable chunk during the
-+ interval between initialization and the first call to
-+ sYSMALLOc. (This is somewhat delicate, since it relies on
-+ the 2 preceding words to be zero during this interval as well.)
-+*/
-+
-+/* Conveniently, the unsorted bin can be used as dummy top on first call */
-+#define initial_top(M) (unsorted_chunks(M))
-+
-+/*
-+ Binmap
-+
-+ To help compensate for the large number of bins, a one-level index
-+ structure is used for bin-by-bin searching. `binmap' is a
-+ bitvector recording whether bins are definitely empty so they can
-+ be skipped over during during traversals. The bits are NOT always
-+ cleared as soon as bins are empty, but instead only
-+ when they are noticed to be empty during traversal in malloc.
-+*/
-+
-+/* Conservatively use 32 bits per map word, even if on 64bit system */
-+#define BINMAPSHIFT 5
-+#define BITSPERMAP (1U << BINMAPSHIFT)
-+#define BINMAPSIZE (NBINS / BITSPERMAP)
-+
-+#define idx2block(i) ((i) >> BINMAPSHIFT)
-+#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
-+
-+#define mark_bin(m,i) ((m)->binmap[idx2block(i)] |= idx2bit(i))
-+#define unmark_bin(m,i) ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
-+#define get_binmap(m,i) ((m)->binmap[idx2block(i)] & idx2bit(i))
-+
-+/*
-+ Fastbins
-+
-+ An array of lists holding recently freed small chunks. Fastbins
-+ are not doubly linked. It is faster to single-link them, and
-+ since chunks are never removed from the middles of these lists,
-+ double linking is not necessary. Also, unlike regular bins, they
-+ are not even processed in FIFO order (they use faster LIFO) since
-+ ordering doesn't much matter in the transient contexts in which
-+ fastbins are normally used.
-+
-+ Chunks in fastbins keep their inuse bit set, so they cannot
-+ be consolidated with other free chunks. malloc_consolidate
-+ releases all chunks in fastbins and consolidates them with
-+ other free chunks.
-+*/
-+
-+typedef struct malloc_chunk* mfastbinptr;
-+
-+/* offset 2 to use otherwise unindexable first 2 bins */
-+#define fastbin_index(sz) ((((unsigned int)(sz)) >> 3) - 2)
-+
-+/* The maximum fastbin request size we support */
-+#define MAX_FAST_SIZE 80
-+
-+#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE))+1)
-+
-+/*
-+ FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
-+ that triggers automatic consolidation of possibly-surrounding
-+ fastbin chunks. This is a heuristic, so the exact value should not
-+ matter too much. It is defined at half the default trim threshold as a
-+ compromise heuristic to only attempt consolidation if it is likely
-+ to lead to trimming. However, it is not dynamically tunable, since
-+ consolidation reduces fragmentation surrounding loarge chunks even
-+ if trimming is not used.
-+*/
-+
-+#define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL)
-+
-+/*
-+ Since the lowest 2 bits in max_fast don't matter in size comparisons,
-+ they are used as flags.
-+*/
-+
-+/*
-+ FASTCHUNKS_BIT held in max_fast indicates that there are probably
-+ some fastbin chunks. It is set true on entering a chunk into any
-+ fastbin, and cleared only in malloc_consolidate.
-+
-+ The truth value is inverted so that have_fastchunks will be true
-+ upon startup (since statics are zero-filled), simplifying
-+ initialization checks.
-+*/
-+
-+#define FASTCHUNKS_BIT (1U)
-+
-+#define have_fastchunks(M) (((M)->max_fast & FASTCHUNKS_BIT) == 0)
-+#define clear_fastchunks(M) ((M)->max_fast |= FASTCHUNKS_BIT)
-+#define set_fastchunks(M) ((M)->max_fast &= ~FASTCHUNKS_BIT)
-+
-+/*
-+ NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
-+ regions. Otherwise, contiguity is exploited in merging together,
-+ when possible, results from consecutive MORECORE calls.
-+
-+ The initial value comes from MORECORE_CONTIGUOUS, but is
-+ changed dynamically if mmap is ever used as an sbrk substitute.
-+*/
-+
-+#define NONCONTIGUOUS_BIT (2U)
-+
-+#define contiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) == 0)
-+#define noncontiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) != 0)
-+#define set_noncontiguous(M) ((M)->max_fast |= NONCONTIGUOUS_BIT)
-+#define set_contiguous(M) ((M)->max_fast &= ~NONCONTIGUOUS_BIT)
-+
-+/*
-+ Set value of max_fast.
-+ Use impossibly small value if 0.
-+ Precondition: there are no existing fastbin chunks.
-+ Setting the value clears fastchunk bit but preserves noncontiguous bit.
-+*/
-+
-+#define set_max_fast(M, s) \
-+ (M)->max_fast = (((s) == 0)? SMALLBIN_WIDTH: request2size(s)) | \
-+ FASTCHUNKS_BIT | \
-+ ((M)->max_fast & NONCONTIGUOUS_BIT)
-+
-+
-+/*
-+ ----------- Internal state representation and initialization -----------
-+*/
-+
-+struct malloc_state {
-+
-+ /* The maximum chunk size to be eligible for fastbin */
-+ INTERNAL_SIZE_T max_fast; /* low 2 bits used as flags */
-+
-+ /* Fastbins */
-+ mfastbinptr fastbins[NFASTBINS];
-+
-+ /* Base of the topmost chunk -- not otherwise kept in a bin */
-+ mchunkptr top;
-+
-+ /* The remainder from the most recent split of a small request */
-+ mchunkptr last_remainder;
-+
-+ /* Normal bins packed as described above */
-+ mchunkptr bins[NBINS * 2];
-+
-+ /* Bitmap of bins */
-+ unsigned int binmap[BINMAPSIZE];
-+
-+ /* Tunable parameters */
-+ unsigned long trim_threshold;
-+ INTERNAL_SIZE_T top_pad;
-+ INTERNAL_SIZE_T mmap_threshold;
-+
-+ /* Memory map support */
-+ int n_mmaps;
-+ int n_mmaps_max;
-+ int max_n_mmaps;
-+
-+ /* Cache malloc_getpagesize */
-+ unsigned int pagesize;
-+
-+ /* Statistics */
-+ INTERNAL_SIZE_T mmapped_mem;
-+ INTERNAL_SIZE_T sbrked_mem;
-+ INTERNAL_SIZE_T max_sbrked_mem;
-+ INTERNAL_SIZE_T max_mmapped_mem;
-+ INTERNAL_SIZE_T max_total_mem;
-+};
-+
-+typedef struct malloc_state *mstate;
-+
-+/*
-+ There is exactly one instance of this struct in this malloc.
-+ If you are adapting this malloc in a way that does NOT use a static
-+ malloc_state, you MUST explicitly zero-fill it before using. This
-+ malloc relies on the property that malloc_state is initialized to
-+ all zeroes (as is true of C statics).
-+*/
-+
-+static struct malloc_state av_; /* never directly referenced */
-+
-+/*
-+ All uses of av_ are via get_malloc_state().
-+ At most one "call" to get_malloc_state is made per invocation of
-+ the public versions of malloc and free, but other routines
-+ that in turn invoke malloc and/or free may call more then once.
-+ Also, it is called in check* routines if DEBUG is set.
-+*/
-+
-+#define get_malloc_state() (&(av_))
-+
-+/*
-+ Initialize a malloc_state struct.
-+
-+ This is called only from within malloc_consolidate, which needs
-+ be called in the same contexts anyway. It is never called directly
-+ outside of malloc_consolidate because some optimizing compilers try
-+ to inline it at all call points, which turns out not to be an
-+ optimization at all. (Inlining it in malloc_consolidate is fine though.)
-+*/
-+
-+#if __STD_C
-+static void malloc_init_state(mstate av)
-+#else
-+static void malloc_init_state(av) mstate av;
-+#endif
-+{
-+ int i;
-+ mbinptr bin;
-+
-+ /* Establish circular links for normal bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ bin = bin_at(av,i);
-+ bin->fd = bin->bk = bin;
-+ }
-+
-+ av->top_pad = DEFAULT_TOP_PAD;
-+ av->n_mmaps_max = DEFAULT_MMAP_MAX;
-+ av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
-+ av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
-+
-+#if !MORECORE_CONTIGUOUS
-+ set_noncontiguous(av);
-+#endif
-+
-+ set_max_fast(av, DEFAULT_MXFAST);
-+
-+ av->top = initial_top(av);
-+ av->pagesize = malloc_getpagesize;
-+}
-+
-+/*
-+ Other internal utilities operating on mstates
-+*/
-+
-+#if __STD_C
-+static Void_t* sYSMALLOc(INTERNAL_SIZE_T, mstate);
-+static int sYSTRIm(size_t, mstate);
-+static void malloc_consolidate(mstate);
-+static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
-+#else
-+static Void_t* sYSMALLOc();
-+static int sYSTRIm();
-+static void malloc_consolidate();
-+static Void_t** iALLOc();
-+#endif
-+
-+/*
-+ Debugging support
-+
-+ These routines make a number of assertions about the states
-+ of data structures that should be true at all times. If any
-+ are not true, it's very likely that a user program has somehow
-+ trashed memory. (It's also possible that there is a coding error
-+ in malloc. In which case, please report it!)
-+*/
-+
-+#ifndef DEBUG
-+
-+#define check_chunk(P)
-+#define check_free_chunk(P)
-+#define check_inuse_chunk(P)
-+#define check_remalloced_chunk(P,N)
-+#define check_malloced_chunk(P,N)
-+#define check_malloc_state()
-+
-+#else
-+#define check_chunk(P) do_check_chunk(P)
-+#define check_free_chunk(P) do_check_free_chunk(P)
-+#define check_inuse_chunk(P) do_check_inuse_chunk(P)
-+#define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N)
-+#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
-+#define check_malloc_state() do_check_malloc_state()
-+
-+/*
-+ Properties of all chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_chunk(mchunkptr p)
-+#else
-+static void do_check_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ unsigned long sz = chunksize(p);
-+ /* min and max possible addresses assuming contiguous allocation */
-+ char* max_address = (char*)(av->top) + chunksize(av->top);
-+ char* min_address = max_address - av->sbrked_mem;
-+
-+ if (!chunk_is_mmapped(p)) {
-+
-+ /* Has legal address ... */
-+ if (p != av->top) {
-+ if (contiguous(av)) {
-+ assert(((char*)p) >= min_address);
-+ assert(((char*)p + sz) <= ((char*)(av->top)));
-+ }
-+ }
-+ else {
-+ /* top size is always at least MINSIZE */
-+ assert((unsigned long)(sz) >= MINSIZE);
-+ /* top predecessor always marked inuse */
-+ assert(prev_inuse(p));
-+ }
-+
-+ }
-+ else {
-+#if HAVE_MMAP
-+ /* address is outside main heap */
-+ if (contiguous(av) && av->top != initial_top(av)) {
-+ assert(((char*)p) < min_address || ((char*)p) > max_address);
-+ }
-+ /* chunk is page-aligned */
-+ assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
-+ /* mem is aligned */
-+ assert(aligned_OK(chunk2mem(p)));
-+#else
-+ /* force an appropriate assert violation if debug set */
-+ assert(!chunk_is_mmapped(p));
-+#endif
-+ }
-+}
-+
-+/*
-+ Properties of free chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_free_chunk(mchunkptr p)
-+#else
-+static void do_check_free_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
-+ mchunkptr next = chunk_at_offset(p, sz);
-+
-+ do_check_chunk(p);
-+
-+ /* Chunk must claim to be free ... */
-+ assert(!inuse(p));
-+ assert (!chunk_is_mmapped(p));
-+
-+ /* Unless a special marker, must have OK fields */
-+ if ((unsigned long)(sz) >= MINSIZE)
-+ {
-+ assert((sz & MALLOC_ALIGN_MASK) == 0);
-+ assert(aligned_OK(chunk2mem(p)));
-+ /* ... matching footer field */
-+ assert(next->prev_size == sz);
-+ /* ... and is fully consolidated */
-+ assert(prev_inuse(p));
-+ assert (next == av->top || inuse(next));
-+
-+ /* ... and has minimally sane links */
-+ assert(p->fd->bk == p);
-+ assert(p->bk->fd == p);
-+ }
-+ else /* markers are always of size SIZE_SZ */
-+ assert(sz == SIZE_SZ);
-+}
-+
-+/*
-+ Properties of inuse chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_inuse_chunk(mchunkptr p)
-+#else
-+static void do_check_inuse_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ mchunkptr next;
-+ do_check_chunk(p);
-+
-+ if (chunk_is_mmapped(p))
-+ return; /* mmapped chunks have no next/prev */
-+
-+ /* Check whether it claims to be in use ... */
-+ assert(inuse(p));
-+
-+ next = next_chunk(p);
-+
-+ /* ... and is surrounded by OK chunks.
-+ Since more things can be checked with free chunks than inuse ones,
-+ if an inuse chunk borders them and debug is on, it's worth doing them.
-+ */
-+ if (!prev_inuse(p)) {
-+ /* Note that we cannot even look at prev unless it is not inuse */
-+ mchunkptr prv = prev_chunk(p);
-+ assert(next_chunk(prv) == p);
-+ do_check_free_chunk(prv);
-+ }
-+
-+ if (next == av->top) {
-+ assert(prev_inuse(next));
-+ assert(chunksize(next) >= MINSIZE);
-+ }
-+ else if (!inuse(next))
-+ do_check_free_chunk(next);
-+}
-+
-+/*
-+ Properties of chunks recycled from fastbins
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
-+#else
-+static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
-+#endif
-+{
-+ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
-+
-+ do_check_inuse_chunk(p);
-+
-+ /* Legal size ... */
-+ assert((sz & MALLOC_ALIGN_MASK) == 0);
-+ assert((unsigned long)(sz) >= MINSIZE);
-+ /* ... and alignment */
-+ assert(aligned_OK(chunk2mem(p)));
-+ /* chunk is less than MINSIZE more than request */
-+ assert((long)(sz) - (long)(s) >= 0);
-+ assert((long)(sz) - (long)(s + MINSIZE) < 0);
-+}
-+
-+/*
-+ Properties of nonrecycled chunks at the point they are malloced
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
-+#else
-+static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
-+#endif
-+{
-+ /* same as recycled case ... */
-+ do_check_remalloced_chunk(p, s);
-+
-+ /*
-+ ... plus, must obey implementation invariant that prev_inuse is
-+ always true of any allocated chunk; i.e., that each allocated
-+ chunk borders either a previously allocated and still in-use
-+ chunk, or the base of its memory arena. This is ensured
-+ by making all allocations from the the `lowest' part of any found
-+ chunk. This does not necessarily hold however for chunks
-+ recycled via fastbins.
-+ */
-+
-+ assert(prev_inuse(p));
-+}
-+
-+
-+/*
-+ Properties of malloc_state.
-+
-+ This may be useful for debugging malloc, as well as detecting user
-+ programmer errors that somehow write into malloc_state.
-+
-+ If you are extending or experimenting with this malloc, you can
-+ probably figure out how to hack this routine to print out or
-+ display chunk addresses, sizes, bins, and other instrumentation.
-+*/
-+
-+static void do_check_malloc_state()
-+{
-+ mstate av = get_malloc_state();
-+ int i;
-+ mchunkptr p;
-+ mchunkptr q;
-+ mbinptr b;
-+ unsigned int binbit;
-+ int empty;
-+ unsigned int idx;
-+ INTERNAL_SIZE_T size;
-+ unsigned long total = 0;
-+ int max_fast_bin;
-+
-+ /* internal size_t must be no wider than pointer type */
-+ assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*));
-+
-+ /* alignment is a power of 2 */
-+ assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0);
-+
-+ /* cannot run remaining checks until fully initialized */
-+ if (av->top == 0 || av->top == initial_top(av))
-+ return;
-+
-+ /* pagesize is a power of 2 */
-+ assert((av->pagesize & (av->pagesize-1)) == 0);
-+
-+ /* properties of fastbins */
-+
-+ /* max_fast is in allowed range */
-+ assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE));
-+
-+ max_fast_bin = fastbin_index(av->max_fast);
-+
-+ for (i = 0; i < NFASTBINS; ++i) {
-+ p = av->fastbins[i];
-+
-+ /* all bins past max_fast are empty */
-+ if (i > max_fast_bin)
-+ assert(p == 0);
-+
-+ while (p != 0) {
-+ /* each chunk claims to be inuse */
-+ do_check_inuse_chunk(p);
-+ total += chunksize(p);
-+ /* chunk belongs in this bin */
-+ assert(fastbin_index(chunksize(p)) == i);
-+ p = p->fd;
-+ }
-+ }
-+
-+ if (total != 0)
-+ assert(have_fastchunks(av));
-+ else if (!have_fastchunks(av))
-+ assert(total == 0);
-+
-+ /* check normal bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ b = bin_at(av,i);
-+
-+ /* binmap is accurate (except for bin 1 == unsorted_chunks) */
-+ if (i >= 2) {
-+ binbit = get_binmap(av,i);
-+ empty = last(b) == b;
-+ if (!binbit)
-+ assert(empty);
-+ else if (!empty)
-+ assert(binbit);
-+ }
-+
-+ for (p = last(b); p != b; p = p->bk) {
-+ /* each chunk claims to be free */
-+ do_check_free_chunk(p);
-+ size = chunksize(p);
-+ total += size;
-+ if (i >= 2) {
-+ /* chunk belongs in bin */
-+ idx = bin_index(size);
-+ assert(idx == i);
-+ /* lists are sorted */
-+ assert(p->bk == b ||
-+ (unsigned long)chunksize(p->bk) >= (unsigned long)chunksize(p));
-+ }
-+ /* chunk is followed by a legal chain of inuse chunks */
-+ for (q = next_chunk(p);
-+ (q != av->top && inuse(q) &&
-+ (unsigned long)(chunksize(q)) >= MINSIZE);
-+ q = next_chunk(q))
-+ do_check_inuse_chunk(q);
-+ }
-+ }
-+
-+ /* top chunk is OK */
-+ check_chunk(av->top);
-+
-+ /* sanity checks for statistics */
-+
-+ assert(total <= (unsigned long)(av->max_total_mem));
-+ assert(av->n_mmaps >= 0);
-+ assert(av->n_mmaps <= av->n_mmaps_max);
-+ assert(av->n_mmaps <= av->max_n_mmaps);
-+
-+ assert((unsigned long)(av->sbrked_mem) <=
-+ (unsigned long)(av->max_sbrked_mem));
-+
-+ assert((unsigned long)(av->mmapped_mem) <=
-+ (unsigned long)(av->max_mmapped_mem));
-+
-+ assert((unsigned long)(av->max_total_mem) >=
-+ (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
-+}
-+#endif
-+
-+
-+/* ----------- Routines dealing with system allocation -------------- */
-+
-+/*
-+ sYSTRIm is an inverse of sorts to sYSMALLOc. It gives memory back
-+ to the system (via negative arguments to sbrk) if there is unused
-+ memory at the `high' end of the malloc pool. It is called
-+ automatically by free() when top space exceeds the trim
-+ threshold. It is also called by the public malloc_trim routine. It
-+ returns 1 if it actually released any memory, else 0.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static int sYSTRIm(size_t pad, mstate av)
-+#else
-+static int sYSTRIm(pad, av) size_t pad; mstate av;
-+#endif
-+{
-+ long top_size; /* Amount of top-most memory */
-+ long extra; /* Amount to release */
-+ long released; /* Amount actually released */
-+ char* current_brk; /* address returned by pre-check sbrk call */
-+ char* new_brk; /* address returned by post-check sbrk call */
-+ size_t pagesz;
-+
-+ pagesz = av->pagesize;
-+ top_size = chunksize(av->top);
-+
-+ /* Release in pagesize units, keeping at least one page */
-+ extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
-+
-+ if (extra > 0) {
-+
-+ /*
-+ Only proceed if end of memory is where we last set it.
-+ This avoids problems if there were foreign sbrk calls.
-+ */
-+ current_brk = (char*)(MORECORE(0));
-+ if (current_brk == (char*)(av->top) + top_size) {
-+
-+ /*
-+ Attempt to release memory. We ignore MORECORE return value,
-+ and instead call again to find out where new end of memory is.
-+ This avoids problems if first call releases less than we asked,
-+ of if failure somehow altered brk value. (We could still
-+ encounter problems if it altered brk in some very bad way,
-+ but the only thing we can do is adjust anyway, which will cause
-+ some downstream failure.)
-+ */
-+
-+ MORECORE(-extra);
-+ new_brk = (char*)(MORECORE(0));
-+
-+ if (new_brk != (char*)MORECORE_FAILURE) {
-+ released = (long)(current_brk - new_brk);
-+
-+ if (released != 0) {
-+ /* Success. Adjust top. */
-+ av->sbrked_mem -= released;
-+ set_head(av->top, (top_size - released) | PREV_INUSE);
-+ check_malloc_state();
-+ return 1;
-+ }
-+ }
-+ }
-+ }
-+ return 0;
-+}
-+
-+/*
-+ ------------------------- malloc_consolidate -------------------------
-+
-+ malloc_consolidate is a specialized version of free() that tears
-+ down chunks held in fastbins. Free itself cannot be used for this
-+ purpose since, among other things, it might place chunks back onto
-+ fastbins. So, instead, we need to use a minor variant of the same
-+ code.
-+
-+ Also, because this routine needs to be called the first time through
-+ malloc anyway, it turns out to be the perfect place to trigger
-+ initialization code.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void malloc_consolidate(mstate av)
-+#else
-+static void malloc_consolidate(av) mstate av;
-+#endif
-+{
-+ mfastbinptr* fb; /* current fastbin being consolidated */
-+ mfastbinptr* maxfb; /* last fastbin (for loop control) */
-+ mchunkptr p; /* current chunk being consolidated */
-+ mchunkptr nextp; /* next chunk to consolidate */
-+ mchunkptr unsorted_bin; /* bin header */
-+ mchunkptr first_unsorted; /* chunk to link to */
-+
-+ /* These have same use as in free() */
-+ mchunkptr nextchunk;
-+ INTERNAL_SIZE_T size;
-+ INTERNAL_SIZE_T nextsize;
-+ INTERNAL_SIZE_T prevsize;
-+ int nextinuse;
-+ mchunkptr bck;
-+ mchunkptr fwd;
-+
-+ /*
-+ If max_fast is 0, we know that av hasn't
-+ yet been initialized, in which case do so below
-+ */
-+
-+ if (av->max_fast != 0) {
-+ clear_fastchunks(av);
-+
-+ unsorted_bin = unsorted_chunks(av);
-+
-+ /*
-+ Remove each chunk from fast bin and consolidate it, placing it
-+ then in unsorted bin. Among other reasons for doing this,
-+ placing in unsorted bin avoids needing to calculate actual bins
-+ until malloc is sure that chunks aren't immediately going to be
-+ reused anyway.
-+ */
-+
-+ maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
-+ fb = &(av->fastbins[0]);
-+ do {
-+ if ( (p = *fb) != 0) {
-+ *fb = 0;
-+
-+ do {
-+ check_inuse_chunk(p);
-+ nextp = p->fd;
-+
-+ /* Slightly streamlined version of consolidation code in free() */
-+ size = p->size & ~PREV_INUSE;
-+ nextchunk = chunk_at_offset(p, size);
-+ nextsize = chunksize(nextchunk);
-+
-+ if (!prev_inuse(p)) {
-+ prevsize = p->prev_size;
-+ size += prevsize;
-+ p = chunk_at_offset(p, -((long) prevsize));
-+ unlink(p, bck, fwd);
-+ }
-+
-+ if (nextchunk != av->top) {
-+ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
-+ set_head(nextchunk, nextsize);
-+
-+ if (!nextinuse) {
-+ size += nextsize;
-+ unlink(nextchunk, bck, fwd);
-+ }
-+
-+ first_unsorted = unsorted_bin->fd;
-+ unsorted_bin->fd = p;
-+ first_unsorted->bk = p;
-+
-+ set_head(p, size | PREV_INUSE);
-+ p->bk = unsorted_bin;
-+ p->fd = first_unsorted;
-+ set_foot(p, size);
-+ }
-+
-+ else {
-+ size += nextsize;
-+ set_head(p, size | PREV_INUSE);
-+ av->top = p;
-+ }
-+
-+ } while ( (p = nextp) != 0);
-+
-+ }
-+ } while (fb++ != maxfb);
-+ }
-+ else {
-+ malloc_init_state(av);
-+ check_malloc_state();
-+ }
-+}
-+
-+/*
-+ ------------------------------ free ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+void fREe(Void_t* mem)
-+#else
-+void fREe(mem) Void_t* mem;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ mchunkptr p; /* chunk corresponding to mem */
-+ INTERNAL_SIZE_T size; /* its size */
-+ mfastbinptr* fb; /* associated fastbin */
-+ mchunkptr nextchunk; /* next contiguous chunk */
-+ INTERNAL_SIZE_T nextsize; /* its size */
-+ int nextinuse; /* true if nextchunk is used */
-+ INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
-+ mchunkptr bck; /* misc temp for linking */
-+ mchunkptr fwd; /* misc temp for linking */
-+
-+
-+ /* free(0) has no effect */
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+ size = chunksize(p);
-+
-+ check_inuse_chunk(p);
-+
-+ /*
-+ If eligible, place chunk on a fastbin so it can be found
-+ and used quickly in malloc.
-+ */
-+
-+ if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
-+
-+#if TRIM_FASTBINS
-+ /*
-+ If TRIM_FASTBINS set, don't place chunks
-+ bordering top into fastbins
-+ */
-+ && (chunk_at_offset(p, size) != av->top)
-+#endif
-+ ) {
-+
-+ set_fastchunks(av);
-+ fb = &(av->fastbins[fastbin_index(size)]);
-+ p->fd = *fb;
-+ *fb = p;
-+ }
-+
-+ /*
-+ Consolidate other non-mmapped chunks as they arrive.
-+ */
-+
-+ else if (!chunk_is_mmapped(p)) {
-+ nextchunk = chunk_at_offset(p, size);
-+ nextsize = chunksize(nextchunk);
-+
-+ /* consolidate backward */
-+ if (!prev_inuse(p)) {
-+ prevsize = p->prev_size;
-+ size += prevsize;
-+ p = chunk_at_offset(p, -((long) prevsize));
-+ unlink(p, bck, fwd);
-+ }
-+
-+ if (nextchunk != av->top) {
-+ /* get and clear inuse bit */
-+ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
-+ set_head(nextchunk, nextsize);
-+
-+ /* consolidate forward */
-+ if (!nextinuse) {
-+ unlink(nextchunk, bck, fwd);
-+ size += nextsize;
-+ }
-+
-+ /*
-+ Place the chunk in unsorted chunk list. Chunks are
-+ not placed into regular bins until after they have
-+ been given one chance to be used in malloc.
-+ */
-+
-+ bck = unsorted_chunks(av);
-+ fwd = bck->fd;
-+ p->bk = bck;
-+ p->fd = fwd;
-+ bck->fd = p;
-+ fwd->bk = p;
-+
-+ set_head(p, size | PREV_INUSE);
-+ set_foot(p, size);
-+
-+ check_free_chunk(p);
-+ }
-+
-+ /*
-+ If the chunk borders the current high end of memory,
-+ consolidate into top
-+ */
-+
-+ else {
-+ size += nextsize;
-+ set_head(p, size | PREV_INUSE);
-+ av->top = p;
-+ check_chunk(p);
-+ }
-+
-+ /*
-+ If freeing a large space, consolidate possibly-surrounding
-+ chunks. Then, if the total unused topmost memory exceeds trim
-+ threshold, ask malloc_trim to reduce top.
-+
-+ Unless max_fast is 0, we don't know if there are fastbins
-+ bordering top, so we cannot tell for sure whether threshold
-+ has been reached unless fastbins are consolidated. But we
-+ don't want to consolidate on each free. As a compromise,
-+ consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
-+ is reached.
-+ */
-+
-+ if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
-+ if (have_fastchunks(av))
-+ malloc_consolidate(av);
-+
-+#ifndef MORECORE_CANNOT_TRIM
-+ if ((unsigned long)(chunksize(av->top)) >=
-+ (unsigned long)(av->trim_threshold))
-+ sYSTRIm(av->top_pad, av);
-+#endif
-+ }
-+
-+ }
-+ /*
-+ If the chunk was allocated via mmap, release via munmap()
-+ Note that if HAVE_MMAP is false but chunk_is_mmapped is
-+ true, then user must have overwritten memory. There's nothing
-+ we can do to catch this error unless DEBUG is set, in which case
-+ check_inuse_chunk (above) will have triggered error.
-+ */
-+
-+ else {
-+#if HAVE_MMAP
-+ int ret;
-+ INTERNAL_SIZE_T offset = p->prev_size;
-+ av->n_mmaps--;
-+ av->mmapped_mem -= (size + offset);
-+ ret = munmap((char*)p - offset, size + offset);
-+ /* munmap returns non-zero on failure */
-+ assert(ret == 0);
-+#endif
-+ }
-+ }
-+}
-+
-+/*
-+ sysmalloc handles malloc cases requiring more memory from the system.
-+ On entry, it is assumed that av->top does not have enough
-+ space to service request for nb bytes, thus requiring that av->top
-+ be extended or replaced.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
-+#else
-+static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
-+#endif
-+{
-+ mchunkptr old_top; /* incoming value of av->top */
-+ INTERNAL_SIZE_T old_size; /* its size */
-+ char* old_end; /* its end address */
-+
-+ long size; /* arg to first MORECORE or mmap call */
-+ char* brk; /* return value from MORECORE */
-+
-+ long correction; /* arg to 2nd MORECORE call */
-+ char* snd_brk; /* 2nd return val */
-+
-+ INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
-+ INTERNAL_SIZE_T end_misalign; /* partial page left at end of new space */
-+ char* aligned_brk; /* aligned offset into brk */
-+
-+ mchunkptr p; /* the allocated/returned chunk */
-+ mchunkptr remainder; /* remainder from allocation */
-+ unsigned long remainder_size; /* its size */
-+
-+ unsigned long sum; /* for updating stats */
-+
-+ size_t pagemask = av->pagesize - 1;
-+
-+
-+#if HAVE_MMAP
-+
-+ /*
-+ If have mmap, and the request size meets the mmap threshold, and
-+ the system supports mmap, and there are few enough currently
-+ allocated mmapped regions, try to directly map this request
-+ rather than expanding top.
-+ */
-+
-+ if ((unsigned long)(nb) >= (unsigned long)(av->mmap_threshold) &&
-+ (av->n_mmaps < av->n_mmaps_max)) {
-+
-+ char* mm; /* return value from mmap call*/
-+
-+ /*
-+ Round up size to nearest page. For mmapped chunks, the overhead
-+ is one SIZE_SZ unit larger than for normal chunks, because there
-+ is no following chunk whose prev_size field could be used.
-+ */
-+ size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
-+
-+ /* Don't try if size wraps around 0 */
-+ if ((unsigned long)(size) > (unsigned long)(nb)) {
-+
-+ mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
-+
-+ if (mm != (char*)(MORECORE_FAILURE)) {
-+
-+ /*
-+ The offset to the start of the mmapped region is stored
-+ in the prev_size field of the chunk. This allows us to adjust
-+ returned start address to meet alignment requirements here
-+ and in memalign(), and still be able to compute proper
-+ address argument for later munmap in free() and realloc().
-+ */
-+
-+ front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK;
-+ if (front_misalign > 0) {
-+ correction = MALLOC_ALIGNMENT - front_misalign;
-+ p = (mchunkptr)(mm + correction);
-+ p->prev_size = correction;
-+ set_head(p, (size - correction) |IS_MMAPPED);
-+ }
-+ else {
-+ p = (mchunkptr)mm;
-+ p->prev_size = 0;
-+ set_head(p, size|IS_MMAPPED);
-+ }
-+
-+ /* update statistics */
-+
-+ if (++av->n_mmaps > av->max_n_mmaps)
-+ av->max_n_mmaps = av->n_mmaps;
-+
-+ sum = av->mmapped_mem += size;
-+ if (sum > (unsigned long)(av->max_mmapped_mem))
-+ av->max_mmapped_mem = sum;
-+ sum += av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ check_chunk(p);
-+
-+ return chunk2mem(p);
-+ }
-+ }
-+ }
-+#endif
-+
-+ /* Record incoming configuration of top */
-+
-+ old_top = av->top;
-+ old_size = chunksize(old_top);
-+ old_end = (char*)(chunk_at_offset(old_top, old_size));
-+
-+ brk = snd_brk = (char*)(MORECORE_FAILURE);
-+
-+ /*
-+ If not the first time through, we require old_size to be
-+ at least MINSIZE and to have prev_inuse set.
-+ */
-+
-+ assert((old_top == initial_top(av) && old_size == 0) ||
-+ ((unsigned long) (old_size) >= MINSIZE &&
-+ prev_inuse(old_top)));
-+
-+ /* Precondition: not enough current space to satisfy nb request */
-+ assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
-+
-+ /* Precondition: all fastbins are consolidated */
-+ assert(!have_fastchunks(av));
-+
-+
-+ /* Request enough space for nb + pad + overhead */
-+
-+ size = nb + av->top_pad + MINSIZE;
-+
-+ /*
-+ If contiguous, we can subtract out existing space that we hope to
-+ combine with new space. We add it back later only if
-+ we don't actually get contiguous space.
-+ */
-+
-+ if (contiguous(av))
-+ size -= old_size;
-+
-+ /*
-+ Round to a multiple of page size.
-+ If MORECORE is not contiguous, this ensures that we only call it
-+ with whole-page arguments. And if MORECORE is contiguous and
-+ this is not first time through, this preserves page-alignment of
-+ previous calls. Otherwise, we correct to page-align below.
-+ */
-+
-+ size = (size + pagemask) & ~pagemask;
-+
-+ /*
-+ Don't try to call MORECORE if argument is so big as to appear
-+ negative. Note that since mmap takes size_t arg, it may succeed
-+ below even if we cannot call MORECORE.
-+ */
-+
-+ if (size > 0)
-+ brk = (char*)(MORECORE(size));
-+
-+ /*
-+ If have mmap, try using it as a backup when MORECORE fails or
-+ cannot be used. This is worth doing on systems that have "holes" in
-+ address space, so sbrk cannot extend to give contiguous space, but
-+ space is available elsewhere. Note that we ignore mmap max count
-+ and threshold limits, since the space will not be used as a
-+ segregated mmap region.
-+ */
-+
-+#if HAVE_MMAP
-+ if (brk == (char*)(MORECORE_FAILURE)) {
-+
-+ /* Cannot merge with old top, so add its size back in */
-+ if (contiguous(av))
-+ size = (size + old_size + pagemask) & ~pagemask;
-+
-+ /* If we are relying on mmap as backup, then use larger units */
-+ if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
-+ size = MMAP_AS_MORECORE_SIZE;
-+
-+ /* Don't try if size wraps around 0 */
-+ if ((unsigned long)(size) > (unsigned long)(nb)) {
-+
-+ brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
-+
-+ if (brk != (char*)(MORECORE_FAILURE)) {
-+
-+ /* We do not need, and cannot use, another sbrk call to find end */
-+ snd_brk = brk + size;
-+
-+ /*
-+ Record that we no longer have a contiguous sbrk region.
-+ After the first time mmap is used as backup, we do not
-+ ever rely on contiguous space since this could incorrectly
-+ bridge regions.
-+ */
-+ set_noncontiguous(av);
-+ }
-+ }
-+ }
-+#endif
-+
-+ if (brk != (char*)(MORECORE_FAILURE)) {
-+ av->sbrked_mem += size;
-+
-+ /*
-+ If MORECORE extends previous space, we can likewise extend top size.
-+ */
-+
-+ if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
-+ set_head(old_top, (size + old_size) | PREV_INUSE);
-+ }
-+
-+ /*
-+ Otherwise, make adjustments:
-+
-+ * If the first time through or noncontiguous, we need to call sbrk
-+ just to find out where the end of memory lies.
-+
-+ * We need to ensure that all returned chunks from malloc will meet
-+ MALLOC_ALIGNMENT
-+
-+ * If there was an intervening foreign sbrk, we need to adjust sbrk
-+ request size to account for fact that we will not be able to
-+ combine new space with existing space in old_top.
-+
-+ * Almost all systems internally allocate whole pages at a time, in
-+ which case we might as well use the whole last page of request.
-+ So we allocate enough more memory to hit a page boundary now,
-+ which in turn causes future contiguous calls to page-align.
-+ */
-+
-+ else {
-+ front_misalign = 0;
-+ end_misalign = 0;
-+ correction = 0;
-+ aligned_brk = brk;
-+
-+ /* handle contiguous cases */
-+ if (contiguous(av)) {
-+
-+ /* Guarantee alignment of first new chunk made from this space */
-+
-+ front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
-+ if (front_misalign > 0) {
-+
-+ /*
-+ Skip over some bytes to arrive at an aligned position.
-+ We don't need to specially mark these wasted front bytes.
-+ They will never be accessed anyway because
-+ prev_inuse of av->top (and any chunk created from its start)
-+ is always true after initialization.
-+ */
-+
-+ correction = MALLOC_ALIGNMENT - front_misalign;
-+ aligned_brk += correction;
-+ }
-+
-+ /*
-+ If this isn't adjacent to existing space, then we will not
-+ be able to merge with old_top space, so must add to 2nd request.
-+ */
-+
-+ correction += old_size;
-+
-+ /* Extend the end address to hit a page boundary */
-+ end_misalign = (INTERNAL_SIZE_T)(brk + size + correction);
-+ correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
-+
-+ assert(correction >= 0);
-+ snd_brk = (char*)(MORECORE(correction));
-+
-+ /*
-+ If can't allocate correction, try to at least find out current
-+ brk. It might be enough to proceed without failing.
-+
-+ Note that if second sbrk did NOT fail, we assume that space
-+ is contiguous with first sbrk. This is a safe assumption unless
-+ program is multithreaded but doesn't use locks and a foreign sbrk
-+ occurred between our first and second calls.
-+ */
-+
-+ if (snd_brk == (char*)(MORECORE_FAILURE)) {
-+ correction = 0;
-+ snd_brk = (char*)(MORECORE(0));
-+ }
-+ }
-+
-+ /* handle non-contiguous cases */
-+ else {
-+ /* MORECORE/mmap must correctly align */
-+ assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
-+
-+ /* Find out current end of memory */
-+ if (snd_brk == (char*)(MORECORE_FAILURE)) {
-+ snd_brk = (char*)(MORECORE(0));
-+ }
-+ }
-+
-+ /* Adjust top based on results of second sbrk */
-+ if (snd_brk != (char*)(MORECORE_FAILURE)) {
-+ av->top = (mchunkptr)aligned_brk;
-+ set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
-+ av->sbrked_mem += correction;
-+
-+ /*
-+ If not the first time through, we either have a
-+ gap due to foreign sbrk or a non-contiguous region. Insert a
-+ double fencepost at old_top to prevent consolidation with space
-+ we don't own. These fenceposts are artificial chunks that are
-+ marked as inuse and are in any case too small to use. We need
-+ two to make sizes and alignments work out.
-+ */
-+
-+ if (old_size != 0) {
-+ /*
-+ Shrink old_top to insert fenceposts, keeping size a
-+ multiple of MALLOC_ALIGNMENT. We know there is at least
-+ enough space in old_top to do this.
-+ */
-+ old_size = (old_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
-+ set_head(old_top, old_size | PREV_INUSE);
-+
-+ /*
-+ Note that the following assignments completely overwrite
-+ old_top when old_size was previously MINSIZE. This is
-+ intentional. We need the fencepost, even if old_top otherwise gets
-+ lost.
-+ */
-+ chunk_at_offset(old_top, old_size )->size =
-+ SIZE_SZ|PREV_INUSE;
-+
-+ chunk_at_offset(old_top, old_size + SIZE_SZ)->size =
-+ SIZE_SZ|PREV_INUSE;
-+
-+ /* If possible, release the rest. */
-+ if (old_size >= MINSIZE) {
-+ fREe(chunk2mem(old_top));
-+ }
-+
-+ }
-+ }
-+ }
-+
-+ /* Update statistics */
-+ sum = av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_sbrked_mem))
-+ av->max_sbrked_mem = sum;
-+
-+ sum += av->mmapped_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ check_malloc_state();
-+
-+ /* finally, do the allocation */
-+ p = av->top;
-+ size = chunksize(p);
-+
-+ /* check that one of the above allocation paths succeeded */
-+ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(p, nb);
-+ av->top = remainder;
-+ set_head(p, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ check_malloced_chunk(p, nb);
-+ return chunk2mem(p);
-+ }
-+ }
-+
-+ /* catch all failure paths */
-+ MALLOC_FAILURE_ACTION;
-+ return 0;
-+}
-+
-+
-+/*
-+ ------------------------------ malloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* mALLOc(size_t bytes)
-+#else
-+ Void_t* mALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T nb; /* normalized request size */
-+ unsigned int idx; /* associated bin index */
-+ mbinptr bin; /* associated bin */
-+ mfastbinptr* fb; /* associated fastbin */
-+
-+ mchunkptr victim; /* inspected/selected chunk */
-+ INTERNAL_SIZE_T size; /* its size */
-+ int victim_index; /* its bin index */
-+
-+ mchunkptr remainder; /* remainder from a split */
-+ unsigned long remainder_size; /* its size */
-+
-+ unsigned int block; /* bit map traverser */
-+ unsigned int bit; /* bit map traverser */
-+ unsigned int map; /* current word of binmap */
-+
-+ mchunkptr fwd; /* misc temp for linking */
-+ mchunkptr bck; /* misc temp for linking */
-+
-+ /*
-+ Convert request size to internal form by adding SIZE_SZ bytes
-+ overhead plus possibly more to obtain necessary alignment and/or
-+ to obtain a size of at least MINSIZE, the smallest allocatable
-+ size. Also, checked_request2size traps (returning 0) request sizes
-+ that are so large that they wrap around zero when padded and
-+ aligned.
-+ */
-+
-+ checked_request2size(bytes, nb);
-+
-+ /*
-+ If the size qualifies as a fastbin, first check corresponding bin.
-+ This code is safe to execute even if av is not yet initialized, so we
-+ can try it without checking, which saves some time on this fast path.
-+ */
-+
-+ if ((unsigned long)(nb) <= (unsigned long)(av->max_fast)) {
-+ fb = &(av->fastbins[(fastbin_index(nb))]);
-+ if ( (victim = *fb) != 0) {
-+ *fb = victim->fd;
-+ check_remalloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+
-+ /*
-+ If a small request, check regular bin. Since these "smallbins"
-+ hold one size each, no searching within bins is necessary.
-+ (For a large request, we need to wait until unsorted chunks are
-+ processed to find best fit. But for small ones, fits are exact
-+ anyway, so we can check now, which is faster.)
-+ */
-+
-+ if (in_smallbin_range(nb)) {
-+ idx = smallbin_index(nb);
-+ bin = bin_at(av,idx);
-+
-+ if ( (victim = last(bin)) != bin) {
-+ if (victim == 0) /* initialization check */
-+ malloc_consolidate(av);
-+ else {
-+ bck = victim->bk;
-+ set_inuse_bit_at_offset(victim, nb);
-+ bin->bk = bck;
-+ bck->fd = bin;
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ /*
-+ If this is a large request, consolidate fastbins before continuing.
-+ While it might look excessive to kill all fastbins before
-+ even seeing if there is space available, this avoids
-+ fragmentation problems normally associated with fastbins.
-+ Also, in practice, programs tend to have runs of either small or
-+ large requests, but less often mixtures, so consolidation is not
-+ invoked all that often in most programs. And the programs that
-+ it is called frequently in otherwise tend to fragment.
-+ */
-+
-+ else {
-+ idx = largebin_index(nb);
-+ if (have_fastchunks(av))
-+ malloc_consolidate(av);
-+ }
-+
-+ /*
-+ Process recently freed or remaindered chunks, taking one only if
-+ it is exact fit, or, if this a small request, the chunk is remainder from
-+ the most recent non-exact fit. Place other traversed chunks in
-+ bins. Note that this step is the only place in any routine where
-+ chunks are placed in bins.
-+
-+ The outer loop here is needed because we might not realize until
-+ near the end of malloc that we should have consolidated, so must
-+ do so and retry. This happens at most once, and only when we would
-+ otherwise need to expand memory to service a "small" request.
-+ */
-+
-+ for(;;) {
-+
-+ while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
-+ bck = victim->bk;
-+ size = chunksize(victim);
-+
-+ /*
-+ If a small request, try to use last remainder if it is the
-+ only chunk in unsorted bin. This helps promote locality for
-+ runs of consecutive small requests. This is the only
-+ exception to best-fit, and applies only when there is
-+ no exact fit for a small chunk.
-+ */
-+
-+ if (in_smallbin_range(nb) &&
-+ bck == unsorted_chunks(av) &&
-+ victim == av->last_remainder &&
-+ (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
-+
-+ /* split and reattach remainder */
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(victim, nb);
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ av->last_remainder = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* remove from unsorted list */
-+ unsorted_chunks(av)->bk = bck;
-+ bck->fd = unsorted_chunks(av);
-+
-+ /* Take now instead of binning if exact fit */
-+
-+ if (size == nb) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* place chunk in bin */
-+
-+ if (in_smallbin_range(size)) {
-+ victim_index = smallbin_index(size);
-+ bck = bin_at(av, victim_index);
-+ fwd = bck->fd;
-+ }
-+ else {
-+ victim_index = largebin_index(size);
-+ bck = bin_at(av, victim_index);
-+ fwd = bck->fd;
-+
-+ /* maintain large bins in sorted order */
-+ if (fwd != bck) {
-+ size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
-+ /* if smaller than smallest, bypass loop below */
-+ if ((unsigned long)(size) <= (unsigned long)(bck->bk->size)) {
-+ fwd = bck;
-+ bck = bck->bk;
-+ }
-+ else {
-+ while ((unsigned long)(size) < (unsigned long)(fwd->size))
-+ fwd = fwd->fd;
-+ bck = fwd->bk;
-+ }
-+ }
-+ }
-+
-+ mark_bin(av, victim_index);
-+ victim->bk = bck;
-+ victim->fd = fwd;
-+ fwd->bk = victim;
-+ bck->fd = victim;
-+ }
-+
-+ /*
-+ If a large request, scan through the chunks of current bin in
-+ sorted order to find smallest that fits. This is the only step
-+ where an unbounded number of chunks might be scanned without doing
-+ anything useful with them. However the lists tend to be short.
-+ */
-+
-+ if (!in_smallbin_range(nb)) {
-+ bin = bin_at(av, idx);
-+
-+ /* skip scan if empty or largest chunk is too small */
-+ if ((victim = last(bin)) != bin &&
-+ (unsigned long)(first(bin)->size) >= (unsigned long)(nb)) {
-+
-+ while (((unsigned long)(size = chunksize(victim)) <
-+ (unsigned long)(nb)))
-+ victim = victim->bk;
-+
-+ remainder_size = size - nb;
-+ unlink(victim, bck, fwd);
-+
-+ /* Exhaust */
-+ if (remainder_size < MINSIZE) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ /* Split */
-+ else {
-+ remainder = chunk_at_offset(victim, nb);
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ /*
-+ Search for a chunk by scanning bins, starting with next largest
-+ bin. This search is strictly by best-fit; i.e., the smallest
-+ (with ties going to approximately the least recently used) chunk
-+ that fits is selected.
-+
-+ The bitmap avoids needing to check that most blocks are nonempty.
-+ The particular case of skipping all bins during warm-up phases
-+ when no chunks have been returned yet is faster than it might look.
-+ */
-+
-+ ++idx;
-+ bin = bin_at(av,idx);
-+ block = idx2block(idx);
-+ map = av->binmap[block];
-+ bit = idx2bit(idx);
-+
-+ for (;;) {
-+
-+ /* Skip rest of block if there are no more set bits in this block. */
-+ if (bit > map || bit == 0) {
-+ do {
-+ if (++block >= BINMAPSIZE) /* out of bins */
-+ goto use_top;
-+ } while ( (map = av->binmap[block]) == 0);
-+
-+ bin = bin_at(av, (block << BINMAPSHIFT));
-+ bit = 1;
-+ }
-+
-+ /* Advance to bin with set bit. There must be one. */
-+ while ((bit & map) == 0) {
-+ bin = next_bin(bin);
-+ bit <<= 1;
-+ assert(bit != 0);
-+ }
-+
-+ /* Inspect the bin. It is likely to be non-empty */
-+ victim = last(bin);
-+
-+ /* If a false alarm (empty bin), clear the bit. */
-+ if (victim == bin) {
-+ av->binmap[block] = map &= ~bit; /* Write through */
-+ bin = next_bin(bin);
-+ bit <<= 1;
-+ }
-+
-+ else {
-+ size = chunksize(victim);
-+
-+ /* We know the first chunk in this bin is big enough to use. */
-+ assert((unsigned long)(size) >= (unsigned long)(nb));
-+
-+ remainder_size = size - nb;
-+
-+ /* unlink */
-+ bck = victim->bk;
-+ bin->bk = bck;
-+ bck->fd = bin;
-+
-+ /* Exhaust */
-+ if (remainder_size < MINSIZE) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* Split */
-+ else {
-+ remainder = chunk_at_offset(victim, nb);
-+
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+ /* advertise as last remainder */
-+ if (in_smallbin_range(nb))
-+ av->last_remainder = remainder;
-+
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ use_top:
-+ /*
-+ If large enough, split off the chunk bordering the end of memory
-+ (held in av->top). Note that this is in accord with the best-fit
-+ search rule. In effect, av->top is treated as larger (and thus
-+ less well fitting) than any other available chunk since it can
-+ be extended to be as large as necessary (up to system
-+ limitations).
-+
-+ We require that av->top always exists (i.e., has size >=
-+ MINSIZE) after initialization, so if it would otherwise be
-+ exhuasted by current request, it is replenished. (The main
-+ reason for ensuring it exists is that we may need MINSIZE space
-+ to put in fenceposts in sysmalloc.)
-+ */
-+
-+ victim = av->top;
-+ size = chunksize(victim);
-+
-+ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(victim, nb);
-+ av->top = remainder;
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /*
-+ If there is space available in fastbins, consolidate and retry,
-+ to possibly avoid expanding memory. This can occur only if nb is
-+ in smallbin range so we didn't consolidate upon entry.
-+ */
-+
-+ else if (have_fastchunks(av)) {
-+ assert(in_smallbin_range(nb));
-+ malloc_consolidate(av);
-+ idx = smallbin_index(nb); /* restore original bin index */
-+ }
-+
-+ /*
-+ Otherwise, relay to handle system-dependent cases
-+ */
-+ else
-+ return sYSMALLOc(nb, av);
-+ }
-+}
-+
-+/*
-+ ------------------------------ realloc ------------------------------
-+*/
-+
-+
-+INLINE
-+#if __STD_C
-+Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
-+#else
-+Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T nb; /* padded request size */
-+
-+ mchunkptr oldp; /* chunk corresponding to oldmem */
-+ INTERNAL_SIZE_T oldsize; /* its size */
-+
-+ mchunkptr newp; /* chunk to return */
-+ INTERNAL_SIZE_T newsize; /* its size */
-+ Void_t* newmem; /* corresponding user mem */
-+
-+ mchunkptr next; /* next contiguous chunk after oldp */
-+
-+ mchunkptr remainder; /* extra space at end of newp */
-+ unsigned long remainder_size; /* its size */
-+
-+ mchunkptr bck; /* misc temp for linking */
-+ mchunkptr fwd; /* misc temp for linking */
-+
-+ unsigned long copysize; /* bytes to copy */
-+ unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
-+ INTERNAL_SIZE_T* s; /* copy source */
-+ INTERNAL_SIZE_T* d; /* copy destination */
-+
-+
-+#ifdef REALLOC_ZERO_BYTES_FREES
-+ if (bytes == 0) {
-+ fREe(oldmem);
-+ return 0;
-+ }
-+#endif
-+
-+ /* realloc of null is supposed to be same as malloc */
-+ if (oldmem == 0) return mALLOc(bytes);
-+
-+ checked_request2size(bytes, nb);
-+
-+ oldp = mem2chunk(oldmem);
-+ oldsize = chunksize(oldp);
-+
-+ check_inuse_chunk(oldp);
-+
-+ if (!chunk_is_mmapped(oldp)) {
-+
-+ if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
-+ /* already big enough; split below */
-+ newp = oldp;
-+ newsize = oldsize;
-+ }
-+
-+ else {
-+ next = chunk_at_offset(oldp, oldsize);
-+
-+ /* Try to expand forward into top */
-+ if (next == av->top &&
-+ (unsigned long)(newsize = oldsize + chunksize(next)) >=
-+ (unsigned long)(nb + MINSIZE)) {
-+ set_head_size(oldp, nb);
-+ av->top = chunk_at_offset(oldp, nb);
-+ set_head(av->top, (newsize - nb) | PREV_INUSE);
-+ return chunk2mem(oldp);
-+ }
-+
-+ /* Try to expand forward into next chunk; split off remainder below */
-+ else if (next != av->top &&
-+ !inuse(next) &&
-+ (unsigned long)(newsize = oldsize + chunksize(next)) >=
-+ (unsigned long)(nb)) {
-+ newp = oldp;
-+ unlink(next, bck, fwd);
-+ }
-+
-+ /* allocate, copy, free */
-+ else {
-+ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
-+ if (newmem == 0)
-+ return 0; /* propagate failure */
-+
-+ newp = mem2chunk(newmem);
-+ newsize = chunksize(newp);
-+
-+ /*
-+ Avoid copy if newp is next chunk after oldp.
-+ */
-+ if (newp == next) {
-+ newsize += oldsize;
-+ newp = oldp;
-+ }
-+ else {
-+ /*
-+ Unroll copy of <= 36 bytes (72 if 8byte sizes)
-+ We know that contents have an odd number of
-+ INTERNAL_SIZE_T-sized words; minimally 3.
-+ */
-+
-+ copysize = oldsize - SIZE_SZ;
-+ s = (INTERNAL_SIZE_T*)(oldmem);
-+ d = (INTERNAL_SIZE_T*)(newmem);
-+ ncopies = copysize / sizeof(INTERNAL_SIZE_T);
-+ assert(ncopies >= 3);
-+
-+ if (ncopies > 9)
-+ MALLOC_COPY(d, s, copysize);
-+
-+ else {
-+ *(d+0) = *(s+0);
-+ *(d+1) = *(s+1);
-+ *(d+2) = *(s+2);
-+ if (ncopies > 4) {
-+ *(d+3) = *(s+3);
-+ *(d+4) = *(s+4);
-+ if (ncopies > 6) {
-+ *(d+5) = *(s+5);
-+ *(d+6) = *(s+6);
-+ if (ncopies > 8) {
-+ *(d+7) = *(s+7);
-+ *(d+8) = *(s+8);
-+ }
-+ }
-+ }
-+ }
-+
-+ fREe(oldmem);
-+ check_inuse_chunk(newp);
-+ return chunk2mem(newp);
-+ }
-+ }
-+ }
-+
-+ /* If possible, free extra space in old or extended chunk */
-+
-+ assert((unsigned long)(newsize) >= (unsigned long)(nb));
-+
-+ remainder_size = newsize - nb;
-+
-+ if (remainder_size < MINSIZE) { /* not enough extra to split off */
-+ set_head_size(newp, newsize);
-+ set_inuse_bit_at_offset(newp, newsize);
-+ }
-+ else { /* split remainder */
-+ remainder = chunk_at_offset(newp, nb);
-+ set_head_size(newp, nb);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ /* Mark remainder as inuse so free() won't complain */
-+ set_inuse_bit_at_offset(remainder, remainder_size);
-+ fREe(chunk2mem(remainder));
-+ }
-+
-+ check_inuse_chunk(newp);
-+ return chunk2mem(newp);
-+ }
-+
-+ /*
-+ Handle mmap cases
-+ */
-+
-+ else {
-+#if HAVE_MMAP
-+
-+#if HAVE_MREMAP
-+ INTERNAL_SIZE_T offset = oldp->prev_size;
-+ size_t pagemask = av->pagesize - 1;
-+ char *cp;
-+ unsigned long sum;
-+
-+ /* Note the extra SIZE_SZ overhead */
-+ newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask;
-+
-+ /* don't need to remap if still within same page */
-+ if (oldsize == newsize - offset)
-+ return oldmem;
-+
-+ cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
-+
-+ if (cp != (char*)MORECORE_FAILURE) {
-+
-+ newp = (mchunkptr)(cp + offset);
-+ set_head(newp, (newsize - offset)|IS_MMAPPED);
-+
-+ assert(aligned_OK(chunk2mem(newp)));
-+ assert((newp->prev_size == offset));
-+
-+ /* update statistics */
-+ sum = av->mmapped_mem += newsize - oldsize;
-+ if (sum > (unsigned long)(av->max_mmapped_mem))
-+ av->max_mmapped_mem = sum;
-+ sum += av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ return chunk2mem(newp);
-+ }
-+#endif
-+
-+ /* Note the extra SIZE_SZ overhead. */
-+ if ((unsigned long)(oldsize) >= (unsigned long)(nb + SIZE_SZ))
-+ newmem = oldmem; /* do nothing */
-+ else {
-+ /* Must alloc, copy, free. */
-+ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
-+ if (newmem != 0) {
-+ MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
-+ fREe(oldmem);
-+ }
-+ }
-+ return newmem;
-+
-+#else
-+ /* If !HAVE_MMAP, but chunk_is_mmapped, user must have overwritten mem */
-+ check_malloc_state();
-+ MALLOC_FAILURE_ACTION;
-+ return 0;
-+#endif
-+ }
-+}
-+
-+/*
-+ ------------------------------ memalign ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* mEMALIGn(size_t alignment, size_t bytes)
-+#else
-+Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
-+#endif
-+{
-+ INTERNAL_SIZE_T nb; /* padded request size */
-+ char* m; /* memory returned by malloc call */
-+ mchunkptr p; /* corresponding chunk */
-+ char* brk; /* alignment point within p */
-+ mchunkptr newp; /* chunk to return */
-+ INTERNAL_SIZE_T newsize; /* its size */
-+ INTERNAL_SIZE_T leadsize; /* leading space before alignment point */
-+ mchunkptr remainder; /* spare room at end to split off */
-+ unsigned long remainder_size; /* its size */
-+ INTERNAL_SIZE_T size;
-+
-+ /* If need less alignment than we give anyway, just relay to malloc */
-+
-+ if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
-+
-+ /* Otherwise, ensure that it is at least a minimum chunk size */
-+
-+ if (alignment < MINSIZE) alignment = MINSIZE;
-+
-+ /* Make sure alignment is power of 2 (in case MINSIZE is not). */
-+ if ((alignment & (alignment - 1)) != 0) {
-+ size_t a = MALLOC_ALIGNMENT * 2;
-+ while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
-+ alignment = a;
-+ }
-+
-+ checked_request2size(bytes, nb);
-+
-+ /*
-+ Strategy: find a spot within that chunk that meets the alignment
-+ request, and then possibly free the leading and trailing space.
-+ */
-+
-+
-+ /* Call malloc with worst case padding to hit alignment. */
-+
-+ m = (char*)(mALLOc(nb + alignment + MINSIZE));
-+
-+ if (m == 0) return 0; /* propagate failure */
-+
-+ p = mem2chunk(m);
-+
-+ if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
-+
-+ /*
-+ Find an aligned spot inside chunk. Since we need to give back
-+ leading space in a chunk of at least MINSIZE, if the first
-+ calculation places us at a spot with less than MINSIZE leader,
-+ we can move to the next aligned spot -- we've allocated enough
-+ total room so that this is always possible.
-+ */
-+
-+ brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) &
-+ -((signed long) alignment));
-+ if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
-+ brk += alignment;
-+
-+ newp = (mchunkptr)brk;
-+ leadsize = brk - (char*)(p);
-+ newsize = chunksize(p) - leadsize;
-+
-+ /* For mmapped chunks, just adjust offset */
-+ if (chunk_is_mmapped(p)) {
-+ newp->prev_size = p->prev_size + leadsize;
-+ set_head(newp, newsize|IS_MMAPPED);
-+ return chunk2mem(newp);
-+ }
-+
-+ /* Otherwise, give back leader, use the rest */
-+ set_head(newp, newsize | PREV_INUSE);
-+ set_inuse_bit_at_offset(newp, newsize);
-+ set_head_size(p, leadsize);
-+ fREe(chunk2mem(p));
-+ p = newp;
-+
-+ assert (newsize >= nb &&
-+ (((unsigned long)(chunk2mem(p))) % alignment) == 0);
-+ }
-+
-+ /* Also give back spare room at the end */
-+ if (!chunk_is_mmapped(p)) {
-+ size = chunksize(p);
-+ if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(p, nb);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_head_size(p, nb);
-+ fREe(chunk2mem(remainder));
-+ }
-+ }
-+
-+ check_inuse_chunk(p);
-+ return chunk2mem(p);
-+}
-+
-+/*
-+ ------------------------------ calloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* cALLOc(size_t n_elements, size_t elem_size)
-+#else
-+Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size;
-+#endif
-+{
-+ mchunkptr p;
-+ unsigned long clearsize;
-+ unsigned long nclears;
-+ INTERNAL_SIZE_T* d;
-+
-+ Void_t* mem = mALLOc(n_elements * elem_size);
-+
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+
-+ if (!chunk_is_mmapped(p))
-+ {
-+ /*
-+ Unroll clear of <= 36 bytes (72 if 8byte sizes)
-+ We know that contents have an odd number of
-+ INTERNAL_SIZE_T-sized words; minimally 3.
-+ */
-+
-+ d = (INTERNAL_SIZE_T*)mem;
-+ clearsize = chunksize(p) - SIZE_SZ;
-+ nclears = clearsize / sizeof(INTERNAL_SIZE_T);
-+ assert(nclears >= 3);
-+
-+ if (nclears > 9)
-+ MALLOC_ZERO(d, clearsize);
-+
-+ else {
-+ *(d+0) = 0;
-+ *(d+1) = 0;
-+ *(d+2) = 0;
-+ if (nclears > 4) {
-+ *(d+3) = 0;
-+ *(d+4) = 0;
-+ if (nclears > 6) {
-+ *(d+5) = 0;
-+ *(d+6) = 0;
-+ if (nclears > 8) {
-+ *(d+7) = 0;
-+ *(d+8) = 0;
-+ }
-+ }
-+ }
-+ }
-+ }
-+#if ! MMAP_CLEARS
-+ else
-+ {
-+ d = (INTERNAL_SIZE_T*)mem;
-+ clearsize = chunksize(p) - 2 * SIZE_SZ;
-+ MALLOC_ZERO(d, clearsize);
-+ }
-+#endif
-+ }
-+ return mem;
-+}
-+
-+/*
-+ ------------------------------ cfree ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+void cFREe(Void_t *mem)
-+#else
-+void cFREe(mem) Void_t *mem;
-+#endif
-+{
-+ fREe(mem);
-+}
-+
-+/*
-+ ------------------------------ ialloc ------------------------------
-+ ialloc 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
-+*/
-+
-+
-+INLINE
-+#if __STD_C
-+static Void_t** iALLOc(size_t n_elements,
-+ size_t* sizes,
-+ int opts,
-+ Void_t* chunks[])
-+#else
-+static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ INTERNAL_SIZE_T element_size; /* chunksize of each element, if all same */
-+ INTERNAL_SIZE_T contents_size; /* total size of elements */
-+ INTERNAL_SIZE_T array_size; /* request size of pointer array */
-+ Void_t* mem; /* malloced aggregate space */
-+ mchunkptr p; /* corresponding chunk */
-+ INTERNAL_SIZE_T remainder_size; /* remaining bytes while splitting */
-+ Void_t** marray; /* either "chunks" or malloced ptr array */
-+ mchunkptr array_chunk; /* chunk for malloced ptr array */
-+ int mmx; /* to disable mmap */
-+ INTERNAL_SIZE_T size;
-+ size_t i;
-+
-+ /* Ensure initialization/consolidation */
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+
-+ /* 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_t**) mALLOc(0);
-+ marray = 0;
-+ array_size = request2size(n_elements * (sizeof(Void_t*)));
-+ }
-+
-+ /* 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]);
-+ }
-+
-+ /* subtract out alignment bytes from total to minimize overallocation */
-+ size = contents_size + array_size - MALLOC_ALIGN_MASK;
-+
-+ /*
-+ Allocate the aggregate chunk.
-+ But first disable mmap so malloc won't use it, since
-+ we would not be able to later free/realloc space internal
-+ to a segregated mmap region.
-+ */
-+ mmx = av->n_mmaps_max; /* disable mmap */
-+ av->n_mmaps_max = 0;
-+ mem = mALLOc(size);
-+ av->n_mmaps_max = mmx; /* reset mmap */
-+ if (mem == 0)
-+ return 0;
-+
-+ p = mem2chunk(mem);
-+ assert(!chunk_is_mmapped(p));
-+ remainder_size = chunksize(p);
-+
-+ if (opts & 0x2) { /* optionally clear the elements */
-+ MALLOC_ZERO(mem, remainder_size - SIZE_SZ - array_size);
-+ }
-+
-+ /* If not provided, allocate the pointer array as final part of chunk */
-+ if (marray == 0) {
-+ array_chunk = chunk_at_offset(p, contents_size);
-+ marray = (Void_t**) (chunk2mem(array_chunk));
-+ set_head(array_chunk, (remainder_size - contents_size) | PREV_INUSE);
-+ 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_head(p, size | PREV_INUSE);
-+ p = chunk_at_offset(p, size);
-+ }
-+ else { /* the final element absorbs any overallocation slop */
-+ set_head(p, remainder_size | PREV_INUSE);
-+ break;
-+ }
-+ }
-+
-+#ifdef 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(mem2chunk(marray));
-+ }
-+
-+ for (i = 0; i != n_elements; ++i)
-+ check_inuse_chunk(mem2chunk(marray[i]));
-+#endif
-+
-+ return marray;
-+}
-+
-+
-+/*
-+ ------------------------- independent_calloc -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])
-+#else
-+Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];
-+#endif
-+{
-+ size_t sz = elem_size; /* serves as 1-element array */
-+ /* opts arg of 3 means all elements are same size, and should be cleared */
-+ return iALLOc(n_elements, &sz, 3, chunks);
-+}
-+
-+/*
-+ ------------------------- independent_comalloc -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])
-+#else
-+Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];
-+#endif
-+{
-+ return iALLOc(n_elements, sizes, 0, chunks);
-+}
-+
-+
-+/*
-+ ------------------------------ valloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* vALLOc(size_t bytes)
-+#else
-+Void_t* vALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ /* Ensure initialization/consolidation */
-+ mstate av = get_malloc_state();
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+ return mEMALIGn(av->pagesize, bytes);
-+}
-+
-+/*
-+ ------------------------------ pvalloc ------------------------------
-+*/
-+
-+
-+#if __STD_C
-+Void_t* pVALLOc(size_t bytes)
-+#else
-+Void_t* pVALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ size_t pagesz;
-+
-+ /* Ensure initialization/consolidation */
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+ pagesz = av->pagesize;
-+ return mEMALIGn(pagesz, (bytes + pagesz - 1) & ~(pagesz - 1));
-+}
-+
-+
-+/*
-+ ------------------------------ malloc_trim ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+int mTRIm(size_t pad)
-+#else
-+int mTRIm(pad) size_t pad;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ /* Ensure initialization/consolidation */
-+ malloc_consolidate(av);
-+
-+#ifndef MORECORE_CANNOT_TRIM
-+ return sYSTRIm(pad, av);
-+#else
-+ return 0;
-+#endif
-+}
-+
-+
-+/*
-+ ------------------------- malloc_usable_size -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+size_t mUSABLe(Void_t* mem)
-+#else
-+size_t mUSABLe(mem) Void_t* mem;
-+#endif
-+{
-+ mchunkptr p;
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+ if (chunk_is_mmapped(p))
-+ return chunksize(p) - 2*SIZE_SZ;
-+ else if (inuse(p))
-+ return chunksize(p) - SIZE_SZ;
-+ }
-+ return 0;
-+}
-+
-+/*
-+ ------------------------------ mallinfo ------------------------------
-+*/
-+
-+struct mallinfo mALLINFo()
-+{
-+ mstate av = get_malloc_state();
-+ struct mallinfo mi;
-+ unsigned int i;
-+ mbinptr b;
-+ mchunkptr p;
-+ INTERNAL_SIZE_T avail;
-+ INTERNAL_SIZE_T fastavail;
-+ int nblocks;
-+ int nfastblocks;
-+
-+ /* Ensure initialization */
-+ if (av->top == 0) malloc_consolidate(av);
-+
-+ check_malloc_state();
-+
-+ /* Account for top */
-+ avail = chunksize(av->top);
-+ nblocks = 1; /* top always exists */
-+
-+ /* traverse fastbins */
-+ nfastblocks = 0;
-+ fastavail = 0;
-+
-+ for (i = 0; i < NFASTBINS; ++i) {
-+ for (p = av->fastbins[i]; p != 0; p = p->fd) {
-+ ++nfastblocks;
-+ fastavail += chunksize(p);
-+ }
-+ }
-+
-+ avail += fastavail;
-+
-+ /* traverse regular bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ b = bin_at(av, i);
-+ for (p = last(b); p != b; p = p->bk) {
-+ ++nblocks;
-+ avail += chunksize(p);
-+ }
-+ }
-+
-+ mi.smblks = nfastblocks;
-+ mi.ordblks = nblocks;
-+ mi.fordblks = avail;
-+ mi.uordblks = av->sbrked_mem - avail;
-+ mi.arena = av->sbrked_mem;
-+ mi.hblks = av->n_mmaps;
-+ mi.hblkhd = av->mmapped_mem;
-+ mi.fsmblks = fastavail;
-+ mi.keepcost = chunksize(av->top);
-+ mi.usmblks = av->max_total_mem;
-+ return mi;
-+}
-+
-+/*
-+ ------------------------------ malloc_stats ------------------------------
-+*/
-+
-+void mSTATs()
-+{
-+ struct mallinfo mi = mALLINFo();
-+
-+#ifdef WIN32
-+ {
-+ unsigned long free, reserved, committed;
-+ vminfo (&free, &reserved, &committed);
-+ fprintf(stderr, "free bytes = %10lu\n",
-+ free);
-+ fprintf(stderr, "reserved bytes = %10lu\n",
-+ reserved);
-+ fprintf(stderr, "committed bytes = %10lu\n",
-+ committed);
-+ }
-+#endif
-+
-+
-+ fprintf(stderr, "max system bytes = %10lu\n",
-+ (unsigned long)(mi.usmblks));
-+ fprintf(stderr, "system bytes = %10lu\n",
-+ (unsigned long)(mi.arena + mi.hblkhd));
-+ fprintf(stderr, "in use bytes = %10lu\n",
-+ (unsigned long)(mi.uordblks + mi.hblkhd));
-+
-+
-+#ifdef WIN32
-+ {
-+ unsigned long kernel, user;
-+ if (cpuinfo (TRUE, &kernel, &user)) {
-+ fprintf(stderr, "kernel ms = %10lu\n",
-+ kernel);
-+ fprintf(stderr, "user ms = %10lu\n",
-+ user);
-+ }
-+ }
-+#endif
-+}
-+
-+
-+/*
-+ ------------------------------ mallopt ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+int mALLOPt(int param_number, int value)
-+#else
-+int mALLOPt(param_number, value) int param_number; int value;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ /* Ensure initialization/consolidation */
-+ malloc_consolidate(av);
-+
-+ switch(param_number) {
-+ case M_MXFAST:
-+ if (value >= 0 && value <= MAX_FAST_SIZE) {
-+ set_max_fast(av, value);
-+ return 1;
-+ }
-+ else
-+ return 0;
-+
-+ case M_TRIM_THRESHOLD:
-+ av->trim_threshold = value;
-+ return 1;
-+
-+ case M_TOP_PAD:
-+ av->top_pad = value;
-+ return 1;
-+
-+ case M_MMAP_THRESHOLD:
-+ av->mmap_threshold = value;
-+ return 1;
-+
-+ case M_MMAP_MAX:
-+#if !HAVE_MMAP
-+ if (value != 0)
-+ return 0;
-+#endif
-+ av->n_mmaps_max = value;
-+ return 1;
-+
-+ default:
-+ return 0;
-+ }
-+}
-+
-+
-+/*
-+ -------------------- Alternative MORECORE functions --------------------
-+*/
-+
-+
-+/*
-+ General Requirements for MORECORE.
-+
-+ The MORECORE function must have the following properties:
-+
-+ If MORECORE_CONTIGUOUS is false:
-+
-+ * MORECORE must allocate in multiples of pagesize. It will
-+ only be called with arguments that are multiples of pagesize.
-+
-+ * MORECORE(0) must return an address that is at least
-+ MALLOC_ALIGNMENT aligned. (Page-aligning always suffices.)
-+
-+ else (i.e. If MORECORE_CONTIGUOUS is true):
-+
-+ * Consecutive calls to MORECORE with positive arguments
-+ return increasing addresses, indicating that space has been
-+ contiguously extended.
-+
-+ * MORECORE need not allocate in multiples of pagesize.
-+ Calls to MORECORE need not have args of multiples of pagesize.
-+
-+ * MORECORE need not page-align.
-+
-+ In either case:
-+
-+ * MORECORE may allocate more memory than requested. (Or even less,
-+ but this will generally result in a malloc failure.)
-+
-+ * MORECORE must not allocate memory when given argument zero, but
-+ instead return one past the end address of memory from previous
-+ nonzero call. This malloc does NOT call MORECORE(0)
-+ until at least one call with positive arguments is made, so
-+ the initial value returned is not important.
-+
-+ * Even though consecutive calls to MORECORE need not return contiguous
-+ addresses, it must be OK for malloc'ed chunks to span multiple
-+ regions in those cases where they do happen to be contiguous.
-+
-+ * MORECORE need not handle negative arguments -- it may instead
-+ just return MORECORE_FAILURE when given negative arguments.
-+ Negative arguments are always multiples of pagesize. MORECORE
-+ must not misinterpret negative args as large positive unsigned
-+ args. You can suppress all such calls from even occurring by defining
-+ MORECORE_CANNOT_TRIM,
-+
-+ There is some variation across systems about the type of the
-+ argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
-+ actually be size_t, because sbrk supports negative args, so it is
-+ normally the signed type of the same width as size_t (sometimes
-+ declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much
-+ matter though. Internally, we use "long" as arguments, which should
-+ work across all reasonable possibilities.
-+
-+ Additionally, if MORECORE ever returns failure for a positive
-+ 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 map noncontiguous space.
-+
-+ If you'd like mmap to ALWAYS be used, you can define MORECORE to be
-+ a function that always returns MORECORE_FAILURE.
-+
-+ If you are using this malloc with something other than sbrk (or its
-+ emulation) to supply memory regions, you probably want to set
-+ MORECORE_CONTIGUOUS as false. As an example, here is a custom
-+ allocator kindly contributed for pre-OSX macOS. It uses virtually
-+ but not necessarily physically contiguous non-paged memory (locked
-+ in, present and won't get swapped out). You can use it by
-+ uncommenting this section, adding some #includes, and setting up the
-+ appropriate defines above:
-+
-+ #define MORECORE osMoreCore
-+ #define MORECORE_CONTIGUOUS 0
-+
-+ There is also a shutdown routine that should somehow be called for
-+ cleanup upon program exit.
-+
-+ #define MAX_POOL_ENTRIES 100
-+ #define MINIMUM_MORECORE_SIZE (64 * 1024)
-+ static int next_os_pool;
-+ void *our_os_pools[MAX_POOL_ENTRIES];
-+
-+ void *osMoreCore(int size)
-+ {
-+ void *ptr = 0;
-+ static void *sbrk_top = 0;
-+
-+ if (size > 0)
-+ {
-+ if (size < MINIMUM_MORECORE_SIZE)
-+ size = MINIMUM_MORECORE_SIZE;
-+ if (CurrentExecutionLevel() == kTaskLevel)
-+ ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
-+ if (ptr == 0)
-+ {
-+ return (void *) MORECORE_FAILURE;
-+ }
-+ // save ptrs so they can be freed during cleanup
-+ our_os_pools[next_os_pool] = ptr;
-+ next_os_pool++;
-+ ptr = (void *) ((((unsigned long) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
-+ sbrk_top = (char *) ptr + size;
-+ return ptr;
-+ }
-+ else if (size < 0)
-+ {
-+ // we don't currently support shrink behavior
-+ return (void *) MORECORE_FAILURE;
-+ }
-+ else
-+ {
-+ return sbrk_top;
-+ }
-+ }
-+
-+ // cleanup any allocated memory pools
-+ // called as last thing before shutting down driver
-+
-+ void osCleanupMem(void)
-+ {
-+ void **ptr;
-+
-+ for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
-+ if (*ptr)
-+ {
-+ PoolDeallocate(*ptr);
-+ *ptr = 0;
-+ }
-+ }
-+
-+*/
-+
-+
-+/*
-+ --------------------------------------------------------------
-+
-+ Emulation of sbrk for win32.
-+ Donated by J. Walter <Walter@GeNeSys-e.de>.
-+ For additional information about this code, and malloc on Win32, see
-+ http://www.genesys-e.de/jwalter/
-+*/
-+
-+
-+#ifdef WIN32
-+
-+#ifdef _DEBUG
-+/* #define TRACE */
-+#endif
-+
-+/* Support for USE_MALLOC_LOCK */
-+#ifdef USE_MALLOC_LOCK
-+
-+/* Wait for spin lock */
-+static int slwait (int *sl) {
-+ while (InterlockedCompareExchange ((void **) sl, (void *) 1, (void *) 0) != 0)
-+ Sleep (0);
-+ return 0;
-+}
-+
-+/* Release spin lock */
-+static int slrelease (int *sl) {
-+ InterlockedExchange (sl, 0);
-+ return 0;
-+}
-+
-+#ifdef NEEDED
-+/* Spin lock for emulation code */
-+static int g_sl;
-+#endif
-+
-+#endif /* USE_MALLOC_LOCK */
-+
-+/* getpagesize for windows */
-+static long getpagesize (void) {
-+ static long g_pagesize = 0;
-+ if (! g_pagesize) {
-+ SYSTEM_INFO system_info;
-+ GetSystemInfo (&system_info);
-+ g_pagesize = system_info.dwPageSize;
-+ }
-+ return g_pagesize;
-+}
-+static long getregionsize (void) {
-+ static long g_regionsize = 0;
-+ if (! g_regionsize) {
-+ SYSTEM_INFO system_info;
-+ GetSystemInfo (&system_info);
-+ g_regionsize = system_info.dwAllocationGranularity;
-+ }
-+ return g_regionsize;
-+}
-+
-+/* A region list entry */
-+typedef struct _region_list_entry {
-+ void *top_allocated;
-+ void *top_committed;
-+ void *top_reserved;
-+ long reserve_size;
-+ struct _region_list_entry *previous;
-+} region_list_entry;
-+
-+/* Allocate and link a region entry in the region list */
-+static int region_list_append (region_list_entry **last, void *base_reserved, long reserve_size) {
-+ region_list_entry *next = HeapAlloc (GetProcessHeap (), 0, sizeof (region_list_entry));
-+ if (! next)
-+ return FALSE;
-+ next->top_allocated = (char *) base_reserved;
-+ next->top_committed = (char *) base_reserved;
-+ next->top_reserved = (char *) base_reserved + reserve_size;
-+ next->reserve_size = reserve_size;
-+ next->previous = *last;
-+ *last = next;
-+ return TRUE;
-+}
-+/* Free and unlink the last region entry from the region list */
-+static int region_list_remove (region_list_entry **last) {
-+ region_list_entry *previous = (*last)->previous;
-+ if (! HeapFree (GetProcessHeap (), sizeof (region_list_entry), *last))
-+ return FALSE;
-+ *last = previous;
-+ return TRUE;
-+}
-+
-+#define CEIL(size,to) (((size)+(to)-1)&~((to)-1))
-+#define FLOOR(size,to) ((size)&~((to)-1))
-+
-+#define SBRK_SCALE 0
-+/* #define SBRK_SCALE 1 */
-+/* #define SBRK_SCALE 2 */
-+/* #define SBRK_SCALE 4 */
-+
-+/* sbrk for windows */
-+static void *sbrk (long size) {
-+ static long g_pagesize, g_my_pagesize;
-+ static long g_regionsize, g_my_regionsize;
-+ static region_list_entry *g_last;
-+ void *result = (void *) MORECORE_FAILURE;
-+#ifdef TRACE
-+ printf ("sbrk %d\n", size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize) {
-+ g_pagesize = getpagesize ();
-+ g_my_pagesize = g_pagesize << SBRK_SCALE;
-+ }
-+ if (! g_regionsize) {
-+ g_regionsize = getregionsize ();
-+ g_my_regionsize = g_regionsize << SBRK_SCALE;
-+ }
-+ if (! g_last) {
-+ if (! region_list_append (&g_last, 0, 0))
-+ goto sbrk_exit;
-+ }
-+ /* Assert invariants */
-+ assert (g_last);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
-+ g_last->top_allocated <= g_last->top_committed);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
-+ g_last->top_committed <= g_last->top_reserved &&
-+ (unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
-+ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
-+ /* Allocation requested? */
-+ if (size >= 0) {
-+ /* Allocation size is the requested size */
-+ long allocate_size = size;
-+ /* Compute the size to commit */
-+ long to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Do we reach the commit limit? */
-+ if (to_commit > 0) {
-+ /* Round size to commit */
-+ long commit_size = CEIL (to_commit, g_my_pagesize);
-+ /* Compute the size to reserve */
-+ long to_reserve = (char *) g_last->top_committed + commit_size - (char *) g_last->top_reserved;
-+ /* Do we reach the reserve limit? */
-+ if (to_reserve > 0) {
-+ /* Compute the remaining size to commit in the current region */
-+ long remaining_commit_size = (char *) g_last->top_reserved - (char *) g_last->top_committed;
-+ if (remaining_commit_size > 0) {
-+ /* Assert preconditions */
-+ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert (0 < remaining_commit_size && remaining_commit_size % g_pagesize == 0); {
-+ /* Commit this */
-+ void *base_committed = VirtualAlloc (g_last->top_committed, remaining_commit_size,
-+ MEM_COMMIT, PAGE_READWRITE);
-+ /* Check returned pointer for consistency */
-+ if (base_committed != g_last->top_committed)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", base_committed, remaining_commit_size);
-+#endif
-+ /* Adjust the regions commit top */
-+ g_last->top_committed = (char *) base_committed + remaining_commit_size;
-+ }
-+ } {
-+ /* Now we are going to search and reserve. */
-+ int contiguous = -1;
-+ int found = FALSE;
-+ MEMORY_BASIC_INFORMATION memory_info;
-+ void *base_reserved;
-+ long reserve_size;
-+ do {
-+ /* Assume contiguous memory */
-+ contiguous = TRUE;
-+ /* Round size to reserve */
-+ reserve_size = CEIL (to_reserve, g_my_regionsize);
-+ /* Start with the current region's top */
-+ memory_info.BaseAddress = g_last->top_reserved;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
-+ /* Assert postconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Query %p %d %s\n", memory_info.BaseAddress, memory_info.RegionSize,
-+ memory_info.State == MEM_FREE ? "FREE":
-+ (memory_info.State == MEM_RESERVE ? "RESERVED":
-+ (memory_info.State == MEM_COMMIT ? "COMMITTED": "?")));
-+#endif
-+ /* Region is free, well aligned and big enough: we are done */
-+ if (memory_info.State == MEM_FREE &&
-+ (unsigned) memory_info.BaseAddress % g_regionsize == 0 &&
-+ memory_info.RegionSize >= (unsigned) reserve_size) {
-+ found = TRUE;
-+ break;
-+ }
-+ /* From now on we can't get contiguous memory! */
-+ contiguous = FALSE;
-+ /* Recompute size to reserve */
-+ reserve_size = CEIL (allocate_size, g_my_regionsize);
-+ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ }
-+ /* Search failed? */
-+ if (! found)
-+ goto sbrk_exit;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_regionsize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ /* Try to reserve this */
-+ base_reserved = VirtualAlloc (memory_info.BaseAddress, reserve_size,
-+ MEM_RESERVE, PAGE_NOACCESS);
-+ if (! base_reserved) {
-+ int rc = GetLastError ();
-+ if (rc != ERROR_INVALID_ADDRESS)
-+ goto sbrk_exit;
-+ }
-+ /* A null pointer signals (hopefully) a race condition with another thread. */
-+ /* In this case, we try again. */
-+ } while (! base_reserved);
-+ /* Check returned pointer for consistency */
-+ if (memory_info.BaseAddress && base_reserved != memory_info.BaseAddress)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_reserved % g_regionsize == 0);
-+#ifdef TRACE
-+ printf ("Reserve %p %d\n", base_reserved, reserve_size);
-+#endif
-+ /* Did we get contiguous memory? */
-+ if (contiguous) {
-+ long start_size = (char *) g_last->top_committed - (char *) g_last->top_allocated;
-+ /* Adjust allocation size */
-+ allocate_size -= start_size;
-+ /* Adjust the regions allocation top */
-+ g_last->top_allocated = g_last->top_committed;
-+ /* Recompute the size to commit */
-+ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Round size to commit */
-+ commit_size = CEIL (to_commit, g_my_pagesize);
-+ }
-+ /* Append the new region to the list */
-+ if (! region_list_append (&g_last, base_reserved, reserve_size))
-+ goto sbrk_exit;
-+ /* Didn't we get contiguous memory? */
-+ if (! contiguous) {
-+ /* Recompute the size to commit */
-+ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Round size to commit */
-+ commit_size = CEIL (to_commit, g_my_pagesize);
-+ }
-+ }
-+ }
-+ /* Assert preconditions */
-+ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert (0 < commit_size && commit_size % g_pagesize == 0); {
-+ /* Commit this */
-+ void *base_committed = VirtualAlloc (g_last->top_committed, commit_size,
-+ MEM_COMMIT, PAGE_READWRITE);
-+ /* Check returned pointer for consistency */
-+ if (base_committed != g_last->top_committed)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", base_committed, commit_size);
-+#endif
-+ /* Adjust the regions commit top */
-+ g_last->top_committed = (char *) base_committed + commit_size;
-+ }
-+ }
-+ /* Adjust the regions allocation top */
-+ g_last->top_allocated = (char *) g_last->top_allocated + allocate_size;
-+ result = (char *) g_last->top_allocated - size;
-+ /* Deallocation requested? */
-+ } else if (size < 0) {
-+ long deallocate_size = - size;
-+ /* As long as we have a region to release */
-+ while ((char *) g_last->top_allocated - deallocate_size < (char *) g_last->top_reserved - g_last->reserve_size) {
-+ /* Get the size to release */
-+ long release_size = g_last->reserve_size;
-+ /* Get the base address */
-+ void *base_reserved = (char *) g_last->top_reserved - release_size;
-+ /* Assert preconditions */
-+ assert ((unsigned) base_reserved % g_regionsize == 0);
-+ assert (0 < release_size && release_size % g_regionsize == 0); {
-+ /* Release this */
-+ int rc = VirtualFree (base_reserved, 0,
-+ MEM_RELEASE);
-+ /* Check returned code for consistency */
-+ if (! rc)
-+ goto sbrk_exit;
-+#ifdef TRACE
-+ printf ("Release %p %d\n", base_reserved, release_size);
-+#endif
-+ }
-+ /* Adjust deallocation size */
-+ deallocate_size -= (char *) g_last->top_allocated - (char *) base_reserved;
-+ /* Remove the old region from the list */
-+ if (! region_list_remove (&g_last))
-+ goto sbrk_exit;
-+ } {
-+ /* Compute the size to decommit */
-+ long to_decommit = (char *) g_last->top_committed - ((char *) g_last->top_allocated - deallocate_size);
-+ if (to_decommit >= g_my_pagesize) {
-+ /* Compute the size to decommit */
-+ long decommit_size = FLOOR (to_decommit, g_my_pagesize);
-+ /* Compute the base address */
-+ void *base_committed = (char *) g_last->top_committed - decommit_size;
-+ /* Assert preconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+ assert (0 < decommit_size && decommit_size % g_pagesize == 0); {
-+ /* Decommit this */
-+ int rc = VirtualFree ((char *) base_committed, decommit_size,
-+ MEM_DECOMMIT);
-+ /* Check returned code for consistency */
-+ if (! rc)
-+ goto sbrk_exit;
-+#ifdef TRACE
-+ printf ("Decommit %p %d\n", base_committed, decommit_size);
-+#endif
-+ }
-+ /* Adjust deallocation size and regions commit and allocate top */
-+ deallocate_size -= (char *) g_last->top_allocated - (char *) base_committed;
-+ g_last->top_committed = base_committed;
-+ g_last->top_allocated = base_committed;
-+ }
-+ }
-+ /* Adjust regions allocate top */
-+ g_last->top_allocated = (char *) g_last->top_allocated - deallocate_size;
-+ /* Check for underflow */
-+ if ((char *) g_last->top_reserved - g_last->reserve_size > (char *) g_last->top_allocated ||
-+ g_last->top_allocated > g_last->top_committed) {
-+ /* Adjust regions allocate top */
-+ g_last->top_allocated = (char *) g_last->top_reserved - g_last->reserve_size;
-+ goto sbrk_exit;
-+ }
-+ result = g_last->top_allocated;
-+ }
-+ /* Assert invariants */
-+ assert (g_last);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
-+ g_last->top_allocated <= g_last->top_committed);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
-+ g_last->top_committed <= g_last->top_reserved &&
-+ (unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
-+ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
-+
-+sbrk_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return result;
-+}
-+
-+/* mmap for windows */
-+static void *mmap (void *ptr, long size, long prot, long type, long handle, long arg) {
-+ static long g_pagesize;
-+ static long g_regionsize;
-+#ifdef TRACE
-+ printf ("mmap %d\n", size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize)
-+ g_pagesize = getpagesize ();
-+ if (! g_regionsize)
-+ g_regionsize = getregionsize ();
-+ /* Assert preconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+ assert (size % g_pagesize == 0);
-+ /* Allocate this */
-+ ptr = VirtualAlloc (ptr, size,
-+ MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE);
-+ if (! ptr) {
-+ ptr = (void *) MORECORE_FAILURE;
-+ goto mmap_exit;
-+ }
-+ /* Assert postconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", ptr, size);
-+#endif
-+mmap_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return ptr;
-+}
-+
-+/* munmap for windows */
-+static long munmap (void *ptr, long size) {
-+ static long g_pagesize;
-+ static long g_regionsize;
-+ int rc = MUNMAP_FAILURE;
-+#ifdef TRACE
-+ printf ("munmap %p %d\n", ptr, size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize)
-+ g_pagesize = getpagesize ();
-+ if (! g_regionsize)
-+ g_regionsize = getregionsize ();
-+ /* Assert preconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+ assert (size % g_pagesize == 0);
-+ /* Free this */
-+ if (! VirtualFree (ptr, 0,
-+ MEM_RELEASE))
-+ goto munmap_exit;
-+ rc = 0;
-+#ifdef TRACE
-+ printf ("Release %p %d\n", ptr, size);
-+#endif
-+munmap_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return rc;
-+}
-+
-+static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed) {
-+ MEMORY_BASIC_INFORMATION memory_info;
-+ memory_info.BaseAddress = 0;
-+ *free = *reserved = *committed = 0;
-+ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
-+ switch (memory_info.State) {
-+ case MEM_FREE:
-+ *free += memory_info.RegionSize;
-+ break;
-+ case MEM_RESERVE:
-+ *reserved += memory_info.RegionSize;
-+ break;
-+ case MEM_COMMIT:
-+ *committed += memory_info.RegionSize;
-+ break;
-+ }
-+ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
-+ }
-+}
-+
-+static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user) {
-+ if (whole) {
-+ __int64 creation64, exit64, kernel64, user64;
-+ int rc = GetProcessTimes (GetCurrentProcess (),
-+ (FILETIME *) &creation64,
-+ (FILETIME *) &exit64,
-+ (FILETIME *) &kernel64,
-+ (FILETIME *) &user64);
-+ if (! rc) {
-+ *kernel = 0;
-+ *user = 0;
-+ return FALSE;
-+ }
-+ *kernel = (unsigned long) (kernel64 / 10000);
-+ *user = (unsigned long) (user64 / 10000);
-+ return TRUE;
-+ } else {
-+ __int64 creation64, exit64, kernel64, user64;
-+ int rc = GetThreadTimes (GetCurrentThread (),
-+ (FILETIME *) &creation64,
-+ (FILETIME *) &exit64,
-+ (FILETIME *) &kernel64,
-+ (FILETIME *) &user64);
-+ if (! rc) {
-+ *kernel = 0;
-+ *user = 0;
-+ return FALSE;
-+ }
-+ *kernel = (unsigned long) (kernel64 / 10000);
-+ *user = (unsigned long) (user64 / 10000);
-+ return TRUE;
-+ }
-+}
-+
-+#endif /* WIN32 */
-+
-+/* ------------------------------------------------------------
-+History:
-+
-+ V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
-+ * Introduce independent_comalloc and independent_calloc.
-+ Thanks to Michael Pachos for motivation and help.
-+ * Make optional .h file available
-+ * Allow > 2GB requests on 32bit systems.
-+ * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>.
-+ Thanks also to Andreas Mueller <a.mueller at paradatec.de>,
-+ and Anonymous.
-+ * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for
-+ helping test this.)
-+ * memalign: check alignment arg
-+ * realloc: don't try to shift chunks backwards, since this
-+ leads to more fragmentation in some programs and doesn't
-+ seem to help in any others.
-+ * Collect all cases in malloc requiring system memory into sYSMALLOc
-+ * Use mmap as backup to sbrk
-+ * Place all internal state in malloc_state
-+ * Introduce fastbins (although similar to 2.5.1)
-+ * Many minor tunings and cosmetic improvements
-+ * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK
-+ * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS
-+ Thanks to Tony E. Bennett <tbennett@nvidia.com> and others.
-+ * Include errno.h to support default failure action.
-+
-+ V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee)
-+ * return null for negative arguments
-+ * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com>
-+ * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h'
-+ (e.g. WIN32 platforms)
-+ * Cleanup header file inclusion for WIN32 platforms
-+ * Cleanup code to avoid Microsoft Visual C++ compiler complaints
-+ * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing
-+ memory allocation routines
-+ * Set 'malloc_getpagesize' for WIN32 platforms (needs more work)
-+ * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to
-+ usage of 'assert' in non-WIN32 code
-+ * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to
-+ avoid infinite loop
-+ * Always call 'fREe()' rather than 'free()'
-+
-+ V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee)
-+ * Fixed ordering problem with boundary-stamping
-+
-+ V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
-+ * Added pvalloc, as recommended by H.J. Liu
-+ * Added 64bit pointer support mainly from Wolfram Gloger
-+ * Added anonymously donated WIN32 sbrk emulation
-+ * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
-+ * malloc_extend_top: fix mask error that caused wastage after
-+ foreign sbrks
-+ * Add linux mremap support code from HJ Liu
-+
-+ V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
-+ * Integrated most documentation with the code.
-+ * Add support for mmap, with help from
-+ Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
-+ * Use last_remainder in more cases.
-+ * Pack bins using idea from colin@nyx10.cs.du.edu
-+ * Use ordered bins instead of best-fit threshold
-+ * Eliminate block-local decls to simplify tracing and debugging.
-+ * Support another case of realloc via move into top
-+ * Fix error occurring when initial sbrk_base not word-aligned.
-+ * Rely on page size for units instead of SBRK_UNIT to
-+ avoid surprises about sbrk alignment conventions.
-+ * Add mallinfo, mallopt. Thanks to Raymond Nijssen
-+ (raymond@es.ele.tue.nl) for the suggestion.
-+ * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
-+ * More precautions for cases where other routines call sbrk,
-+ courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
-+ * Added macros etc., allowing use in linux libc from
-+ H.J. Lu (hjl@gnu.ai.mit.edu)
-+ * Inverted this history list
-+
-+ V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
-+ * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
-+ * Removed all preallocation code since under current scheme
-+ the work required to undo bad preallocations exceeds
-+ the work saved in good cases for most test programs.
-+ * No longer use return list or unconsolidated bins since
-+ no scheme using them consistently outperforms those that don't
-+ given above changes.
-+ * Use best fit for very large chunks to prevent some worst-cases.
-+ * Added some support for debugging
-+
-+ V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
-+ * Removed footers when chunks are in use. Thanks to
-+ Paul Wilson (wilson@cs.texas.edu) for the suggestion.
-+
-+ V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
-+ * Added malloc_trim, with help from Wolfram Gloger
-+ (wmglo@Dent.MED.Uni-Muenchen.DE).
-+
-+ V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
-+
-+ V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
-+ * realloc: try to expand in both directions
-+ * malloc: swap order of clean-bin strategy;
-+ * realloc: only conditionally expand backwards
-+ * Try not to scavenge used bins
-+ * Use bin counts as a guide to preallocation
-+ * Occasionally bin return list chunks in first scan
-+ * Add a few optimizations from colin@nyx10.cs.du.edu
-+
-+ V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
-+ * faster bin computation & slightly different binning
-+ * merged all consolidations to one part of malloc proper
-+ (eliminating old malloc_find_space & malloc_clean_bin)
-+ * Scan 2 returns chunks (not just 1)
-+ * Propagate failure in realloc if malloc returns 0
-+ * Add stuff to allow compilation on non-ANSI compilers
-+ from kpv@research.att.com
-+
-+ V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
-+ * removed potential for odd address access in prev_chunk
-+ * removed dependency on getpagesize.h
-+ * misc cosmetics and a bit more internal documentation
-+ * anticosmetics: mangled names in macros to evade debugger strangeness
-+ * tested on sparc, hp-700, dec-mips, rs6000
-+ with gcc & native cc (hp, dec only) allowing
-+ Detlefs & Zorn comparison study (in SIGPLAN Notices.)
-+
-+ Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
-+ * Based loosely on libg++-1.2X malloc. (It retains some of the overall
-+ structure of old version, but most details differ.)
-+
-+*/
-+
-+#ifdef USE_PUBLIC_MALLOC_WRAPPERS
-+
-+#ifndef KDE_MALLOC_FULL
-+
-+#ifdef KDE_MALLOC_GLIBC
-+#include "glibc.h"
-+#else
-+/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/
-+#error Unknown libc
-+#endif
-+
-+/* 0 - uninitialized
-+ 1 - this malloc
-+ 2 - standard libc malloc*/
-+extern char* getenv(const char*);
-+static int malloc_type = 0;
-+static void init_malloc_type(void)
-+ {
-+ const char* const env = getenv( "KDE_MALLOC" );
-+ if( env == NULL )
-+ malloc_type = 1;
-+ else if( env[ 0 ] == '0' || env[ 0 ] == 'n' || env[ 0 ] == 'N' )
-+ malloc_type = 2;
-+ else
-+ malloc_type = 1;
-+ }
-+
-+#endif
-+
-+Void_t* public_mALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_malloc( bytes );
-+ init_malloc_type();
-+ return public_mALLOc( bytes );
-+#endif
-+}
-+
-+void public_fREe(Void_t* m) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ fREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+#ifndef KDE_MALLOC_FULL
-+ return;
-+ }
-+ if( malloc_type == 2 )
-+ {
-+ libc_free( m );
-+ return;
-+ }
-+ init_malloc_type();
-+ public_fREe( m );
-+#endif
-+}
-+
-+Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = rEALLOc(m, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_realloc( m, bytes );
-+ init_malloc_type();
-+ return public_rEALLOc( m, bytes );
-+#endif
-+}
-+
-+Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mEMALIGn(alignment, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_memalign( alignment, bytes );
-+ init_malloc_type();
-+ return public_mEMALIGn( alignment, bytes );
-+#endif
-+}
-+
-+Void_t* public_vALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = vALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_valloc( bytes );
-+ init_malloc_type();
-+ return public_vALLOc( bytes );
-+#endif
-+}
-+
-+Void_t* public_pVALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = pVALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_pvalloc( bytes );
-+ init_malloc_type();
-+ return public_pVALLOc( bytes );
-+#endif
-+}
-+
-+Void_t* public_cALLOc(size_t n, size_t elem_size) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = cALLOc(n, elem_size);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_calloc( n, elem_size );
-+ init_malloc_type();
-+ return public_cALLOc( n, elem_size );
-+#endif
-+}
-+
-+void public_cFREe(Void_t* m) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ cFREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+#ifndef KDE_MALLOC_FULL
-+ return;
-+ }
-+ if( malloc_type == 2 )
-+ {
-+ libc_cfree( m );
-+ return;
-+ }
-+ init_malloc_type();
-+ public_cFREe( m );
-+#endif
-+}
-+
-+struct mallinfo public_mALLINFo() {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ struct mallinfo m;
-+ if (MALLOC_PREACTION != 0) {
-+ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-+ return nm;
-+ }
-+ m = mALLINFo();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_mallinfo();
-+ init_malloc_type();
-+ return public_mALLINFo();
-+#endif
-+}
-+
-+int public_mALLOPt(int p, int v) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mALLOPt(p, v);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_mallopt( p, v );
-+ init_malloc_type();
-+ return public_mALLOPt( p, v );
-+#endif
-+}
-+#endif
-+
-+int
-+posix_memalign (void **memptr, size_t alignment, size_t size)
-+{
-+ void *mem;
-+
-+ /* Test whether the SIZE argument is valid. It must be a power of
-+ two multiple of sizeof (void *). */
-+ if (size % sizeof (void *) != 0 || (size & (size - 1)) != 0)
-+ return EINVAL;
-+
-+ mem = memalign (alignment, size);
-+
-+ if (mem != NULL) {
-+ *memptr = mem;
-+ return 0;
-+ }
-+
-+ return ENOMEM;
-+}
-+
-+#else
-+/* Some linkers (Solaris 2.6) don't like empty archives, but for
-+ easier Makefile's we want to link against libklmalloc.la every time,
-+ so simply make it non-empty. */
-+void kde_malloc_dummy_function ()
-+{
-+ return;
-+}
-+#endif
-diff -Nupr a/src/corelib/arch/avr32/qatomic.cpp b/src/corelib/arch/avr32/qatomic.cpp
---- a/src/corelib/arch/avr32/qatomic.cpp 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/qatomic.cpp 2006-07-26 11:02:43.000000000 +0200
-@@ -0,0 +1,24 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#include "QtCore/qatomic_avr32.h"
-+
-+Q_CORE_EXPORT long q_atomic_lock = 0;
-diff -Nupr a/src/corelib/arch/qatomic_arch.h b/src/corelib/arch/qatomic_arch.h
---- a/src/corelib/arch/qatomic_arch.h 2006-06-30 09:49:44.000000000 +0200
-+++ b/src/corelib/arch/qatomic_arch.h 2006-07-27 12:42:58.000000000 +0200
-@@ -32,6 +32,8 @@ QT_BEGIN_HEADER
- # include "QtCore/qatomic_alpha.h"
- #elif defined(QT_ARCH_ARM)
- # include "QtCore/qatomic_arm.h"
-+#elif defined(QT_ARCH_AVR32)
-+# include "QtCore/qatomic_avr32.h"
- #elif defined(QT_ARCH_BOUNDSCHECKER)
- # include "QtCore/qatomic_boundschecker.h"
- #elif defined(QT_ARCH_GENERIC)
-diff -Nupr a/src/corelib/arch/qatomic_avr32.h b/src/corelib/arch/qatomic_avr32.h
---- a/src/corelib/arch/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/qatomic_avr32.h 2006-07-28 10:30:08.000000000 +0200
-@@ -0,0 +1,113 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#ifndef AVR32_QATOMIC_H
-+#define AVR32_QATOMIC_H
-+
-+#include <QtCore/qglobal.h>
-+
-+QT_BEGIN_HEADER
-+
-+extern Q_CORE_EXPORT long q_atomic_lock;
-+
-+inline long q_atomic_swp(volatile long *ptr, long newval)
-+{
-+ register int ret;
-+ asm volatile("xchg %0,%1,%2"
-+ : "=&r"(ret)
-+ : "r"(ptr), "r"(newval)
-+ : "memory", "cc");
-+ return ret;
-+}
-+
-+inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
-+{
-+ int ret = 0;
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0);
-+ if (*ptr == expected) {
-+ *ptr = newval;
-+ ret = 1;
-+ }
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return ret;
-+}
-+
-+inline int q_atomic_test_and_set_acquire_int(volatile int *ptr, int expected, int newval)
-+{
-+ return q_atomic_test_and_set_int(ptr, expected, newval);
-+}
-+
-+inline int q_atomic_test_and_set_release_int(volatile int *ptr, int expected, int newval)
-+{
-+ return q_atomic_test_and_set_int(ptr, expected, newval);
-+}
-+
-+inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
-+{
-+ int ret = 0;
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ if (*reinterpret_cast<void * volatile *>(ptr) == expected) {
-+ *reinterpret_cast<void * volatile *>(ptr) = newval;
-+ ret = 1;
-+ }
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return ret;
-+}
-+
-+inline int q_atomic_increment(volatile int *ptr)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = originalValue + 1;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue != -1;
-+}
-+
-+inline int q_atomic_decrement(volatile int *ptr)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = originalValue - 1;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue != 1;
-+}
-+
-+inline int q_atomic_set_int(volatile int *ptr, int newval)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = newval;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue;
-+}
-+
-+inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ void *originalValue = *reinterpret_cast<void * volatile *>(ptr);
-+ *reinterpret_cast<void * volatile *>(ptr) = newval;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue;
-+}
-+
-+QT_END_HEADER
-+
-+#endif // AVR32_QATOMIC_H
-diff -Nupr a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
---- a/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-06-30 09:49:45.000000000 +0200
-+++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-07-27 13:24:27.000000000 +0200
-@@ -72,6 +72,10 @@
- # define __NR_inotify_init 316
- # define __NR_inotify_add_watch 317
- # define __NR_inotify_rm_watch 318
-+#elif defined (__avr32__)
-+# define __NR_inotify_init 240
-+# define __NR_inotify_add_watch 241
-+# define __NR_inotify_rm_watch 242
- #elif defined (__SH4__)
- # define __NR_inotify_init 290
- # define __NR_inotify_add_watch 291
-diff -uprN a/mkspecs/qws/linux-avr32-g++/qmake.conf b/mkspecs/qws/linux-avr32-g++/qmake.conf
---- a/mkspecs/qws/linux-avr32-g++/qmake.conf 1970-01-01 01:00:00.000000000 +0100
-+++ b/mkspecs/qws/linux-avr32-g++/qmake.conf 2006-08-01 08:47:12.000000000 +0200
-@@ -0,0 +1,85 @@
-+#
-+# qmake configuration for linux-g++ using the avr32-linux-g++ crosscompiler
-+#
-+
-+MAKEFILE_GENERATOR = UNIX
-+TEMPLATE = app
-+CONFIG += qt warn_on release link_prl
-+QT += core gui network
-+QMAKE_INCREMENTAL_STYLE = sublib
-+
-+QMAKE_CC = avr32-linux-gcc
-+QMAKE_LEX = flex
-+QMAKE_LEXFLAGS =
-+QMAKE_YACC = yacc
-+QMAKE_YACCFLAGS = -d
-+QMAKE_CFLAGS = -pipe
-+QMAKE_CFLAGS_WARN_ON = -Wall -W
-+QMAKE_CFLAGS_WARN_OFF =
-+QMAKE_CFLAGS_RELEASE = -O2
-+QMAKE_CFLAGS_DEBUG = -g -O2
-+QMAKE_CFLAGS_SHLIB = -fPIC
-+QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
-+QMAKE_CFLAGS_THREAD = -D_REENTRANT
-+QMAKE_CFLAGS_HIDESYMS = -fvisibility=hidden
-+
-+QMAKE_CXX = avr32-linux-g++
-+QMAKE_CXXFLAGS = $$QMAKE_CFLAGS -fno-exceptions
-+QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
-+QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
-+QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
-+QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
-+QMAKE_CXXFLAGS_SHLIB = $$QMAKE_CFLAGS_SHLIB
-+QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
-+QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD
-+QMAKE_CXXFLAGS_HIDESYMS = $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden
-+
-+QMAKE_INCDIR =
-+QMAKE_LIBDIR =
-+QMAKE_INCDIR_X11 =
-+QMAKE_LIBDIR_X11 =
-+QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
-+QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
-+QMAKE_INCDIR_OPENGL =
-+QMAKE_LIBDIR_OPENGL =
-+QMAKE_INCDIR_QTOPIA = $(QPEDIR)/include
-+QMAKE_LIBDIR_QTOPIA = $(QPEDIR)/lib
-+
-+QMAKE_LINK = avr32-linux-g++
-+QMAKE_LINK_SHLIB = avr32-linux-g++
-+QMAKE_LFLAGS =
-+QMAKE_LFLAGS_RELEASE =
-+QMAKE_LFLAGS_DEBUG =
-+QMAKE_LFLAGS_SHLIB = -shared
-+QMAKE_LFLAGS_PLUGIN = $$QMAKE_LFLAGS_SHLIB
-+QMAKE_LFLAGS_SONAME = -Wl,-soname,
-+QMAKE_LFLAGS_THREAD =
-+QMAKE_RPATH = -Wl,-rpath,
-+
-+QMAKE_LIBS =
-+QMAKE_LIBS_DYNLOAD = -ldl
-+QMAKE_LIBS_X11 =
-+QMAKE_LIBS_X11SM =
-+QMAKE_LIBS_QT = -lqte
-+QMAKE_LIBS_QT_THREAD = -lqte-mt
-+QMAKE_LIBS_QT_OPENGL = -lqgl
-+QMAKE_LIBS_QTOPIA = -lqpe -lqtopia
-+QMAKE_LIBS_THREAD = -lpthread
-+
-+QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
-+QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
-+
-+QMAKE_AR = avr32-linux-ar cqs
-+QMAKE_RANLIB = avr32-linux-ranlib
-+
-+QMAKE_TAR = tar -cf
-+QMAKE_GZIP = gzip -9f
-+
-+QMAKE_COPY = cp -f
-+QMAKE_MOVE = mv -f
-+QMAKE_DEL_FILE = rm -f
-+QMAKE_DEL_DIR = rmdir
-+QMAKE_STRIP = avr32-linux-strip
-+QMAKE_CHK_DIR_EXISTS = test -d
-+QMAKE_MKDIR = mkdir -p
-+load(qt_config)
-diff -uprN a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h
---- a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 2006-07-26 09:16:52.000000000 +0200
-@@ -0,0 +1,22 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the qmake spec of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#include "../../linux-g++/qplatformdefs.h"
--- /dev/null
+diff -Nupr a/include/Qt/qatomic_avr32.h b/include/Qt/qatomic_avr32.h
+--- a/include/Qt/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/include/Qt/qatomic_avr32.h 2006-07-27 07:55:09.000000000 +0200
+@@ -0,0 +1 @@
++#include "../../src/corelib/arch/qatomic_avr32.h"
+diff -Nupr a/include/QtCore/qatomic_avr32.h b/include/QtCore/qatomic_avr32.h
+--- a/include/QtCore/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/include/QtCore/qatomic_avr32.h 2006-07-27 07:55:28.000000000 +0200
+@@ -0,0 +1 @@
++#include "../../src/corelib/arch/qatomic_avr32.h"
+diff -Nupr a/src/corelib/arch/arch.pri b/src/corelib/arch/arch.pri
+--- a/src/corelib/arch/arch.pri 2006-06-30 09:49:44.000000000 +0200
++++ b/src/corelib/arch/arch.pri 2006-07-26 11:03:43.000000000 +0200
+@@ -13,6 +13,7 @@ mac:HEADERS += arch/qatomic_macosx.h \
+ arch/qatomic_generic.h \
+ arch/qatomic_powerpc.h \
+ arch/qatomic_arm.h \
++ arch/qatomic_avr32.h \
+ arch/qatomic_i386.h \
+ arch/qatomic_mips.h \
+ arch/qatomic_s390.h \
+diff -Nupr a/src/corelib/arch/avr32/arch.pri b/src/corelib/arch/avr32/arch.pri
+--- a/src/corelib/arch/avr32/arch.pri 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/arch.pri 2006-07-26 11:02:16.000000000 +0200
+@@ -0,0 +1,5 @@
++#
++# AVR32 architecture
++#
++SOURCES += $$QT_ARCH_CPP/qatomic.cpp \
++ $$QT_ARCH_CPP/malloc.c
+diff -Nupr a/src/corelib/arch/avr32/malloc.c b/src/corelib/arch/avr32/malloc.c
+--- a/src/corelib/arch/avr32/malloc.c 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/malloc.c 2006-07-28 10:29:44.000000000 +0200
+@@ -0,0 +1,5819 @@
++/****************************************************************************
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** This file contains third party code which is not governed by the Qt
++** Commercial License Agreement. Please read the license headers below
++** for more information.
++**
++** Further information about Qt licensing is available at:
++** http://www.trolltech.com/products/qt/licensing.html or by
++** contacting info@trolltech.com.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++/* ---- config.h */
++#define KDE_MALLOC
++#define KDE_MALLOC_FULL
++#define KDE_MALLOC_AVR32
++/* ---- */
++
++#ifdef KDE_MALLOC
++
++#ifdef KDE_MALLOC_DEBUG
++#define DEBUG
++#endif
++
++#define USE_MALLOC_LOCK
++#define INLINE __inline__
++/*#define INLINE*/
++#define USE_MEMCPY 0
++#define MMAP_CLEARS 1
++
++/*
++ This is a version (aka dlmalloc) of malloc/free/realloc written by
++ Doug Lea and released to the public domain. Use, modify, and
++ redistribute this code without permission or acknowledgment in any
++ way you wish. Send questions, comments, complaints, performance
++ data, etc to dl@cs.oswego.edu
++
++* VERSION 2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
++
++ Note: There may be an updated version of this malloc obtainable at
++ ftp://gee.cs.oswego.edu/pub/misc/malloc.c
++ Check before installing!
++
++* Quickstart
++
++ This library is all in one file to simplify the most common usage:
++ ftp it, compile it (-O), and link it into another program. All
++ of the compile-time options default to reasonable values for use on
++ most unix platforms. Compile -DWIN32 for reasonable defaults on windows.
++ You might later want to step through various compile-time and dynamic
++ tuning options.
++
++ For convenience, an include file for code using this malloc is at:
++ ftp://gee.cs.oswego.edu/pub/misc/malloc-2.7.0.h
++ You don't really need this .h file unless you call functions not
++ defined in your system include files. The .h file contains only the
++ excerpts from this file needed for using this malloc on ANSI C/C++
++ systems, so long as you haven't changed compile-time options about
++ naming and tuning parameters. If you do, then you can create your
++ own malloc.h that does include all settings by cutting at the point
++ indicated below.
++
++* Why use this malloc?
++
++ This is not the fastest, most space-conserving, most portable, or
++ most tunable malloc ever written. However it is among the fastest
++ while also being among the most space-conserving, portable and tunable.
++ Consistent balance across these factors results in a good general-purpose
++ allocator for malloc-intensive programs.
++
++ The main properties of the algorithms are:
++ * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
++ with ties normally decided via FIFO (i.e. least recently used).
++ * For small (<= 64 bytes by default) requests, it is a caching
++ allocator, that maintains pools of quickly recycled chunks.
++ * In between, and for combinations of large and small requests, it does
++ the best it can trying to meet both goals at once.
++ * For very large requests (>= 128KB by default), it relies on system
++ memory mapping facilities, if supported.
++
++ For a longer but slightly out of date high-level description, see
++ http://gee.cs.oswego.edu/dl/html/malloc.html
++
++ You may already by default be using a C library containing a malloc
++ that is based on some version of this malloc (for example in
++ linux). You might still want to use the one in this file in order to
++ customize settings or to avoid overheads associated with library
++ versions.
++
++* Contents, described in more detail in "description of public routines" below.
++
++ Standard (ANSI/SVID/...) functions:
++ malloc(size_t n);
++ calloc(size_t n_elements, size_t element_size);
++ free(Void_t* p);
++ realloc(Void_t* p, size_t n);
++ memalign(size_t alignment, size_t n);
++ valloc(size_t n);
++ mallinfo()
++ mallopt(int parameter_number, int parameter_value)
++
++ Additional functions:
++ independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);
++ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
++ pvalloc(size_t n);
++ cfree(Void_t* p);
++ malloc_trim(size_t pad);
++ malloc_usable_size(Void_t* p);
++ malloc_stats();
++
++* Vital statistics:
++
++ Supported pointer representation: 4 or 8 bytes
++ Supported size_t representation: 4 or 8 bytes
++ Note that size_t is allowed to be 4 bytes even if pointers are 8.
++ You can adjust this by defining INTERNAL_SIZE_T
++
++ Alignment: 2 * sizeof(size_t) (default)
++ (i.e., 8 byte alignment with 4byte size_t). This suffices for
++ nearly all current machines and C compilers. However, you can
++ define MALLOC_ALIGNMENT to be wider than this if necessary.
++
++ Minimum overhead per allocated chunk: 4 or 8 bytes
++ Each malloced chunk has a hidden word of overhead holding size
++ and status information.
++
++ Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
++ 8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
++
++ When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
++ ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
++ needed; 4 (8) for a trailing size field and 8 (16) bytes for
++ free list pointers. Thus, the minimum allocatable size is
++ 16/24/32 bytes.
++
++ Even a request for zero bytes (i.e., malloc(0)) returns a
++ pointer to something of the minimum allocatable size.
++
++ The maximum overhead wastage (i.e., number of extra bytes
++ allocated than were requested in malloc) is less than or equal
++ to the minimum size, except for requests >= mmap_threshold that
++ are serviced via mmap(), where the worst case wastage is 2 *
++ sizeof(size_t) bytes plus the remainder from a system page (the
++ minimal mmap unit); typically 4096 or 8192 bytes.
++
++ Maximum allocated size: 4-byte size_t: 2^32 minus about two pages
++ 8-byte size_t: 2^64 minus about two pages
++
++ It is assumed that (possibly signed) size_t values suffice to
++ represent chunk sizes. `Possibly signed' is due to the fact
++ that `size_t' may be defined on a system as either a signed or
++ an unsigned type. The ISO C standard says that it must be
++ unsigned, but a few systems are known not to adhere to this.
++ Additionally, even when size_t is unsigned, sbrk (which is by
++ default used to obtain memory from system) accepts signed
++ arguments, and may not be able to handle size_t-wide arguments
++ with negative sign bit. Generally, values that would
++ appear as negative after accounting for overhead and alignment
++ are supported only via mmap(), which does not have this
++ limitation.
++
++ Requests for sizes outside the allowed range will perform an optional
++ failure action and then return null. (Requests may also
++ also fail because a system is out of memory.)
++
++ Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined
++
++ When USE_MALLOC_LOCK is defined, wrappers are created to
++ surround every public call with either a pthread mutex or
++ a win32 spinlock (depending on WIN32). This is not
++ especially fast, and can be a major bottleneck.
++ It is designed only to provide minimal protection
++ in concurrent environments, and to provide a basis for
++ extensions. If you are using malloc in a concurrent program,
++ you would be far better off obtaining ptmalloc, which is
++ derived from a version of this malloc, and is well-tuned for
++ concurrent programs. (See http://www.malloc.de)
++
++ Compliance: I believe it is compliant with the 1997 Single Unix Specification
++ (See http://www.opennc.org). Also SVID/XPG, ANSI C, and probably
++ others as well.
++
++* Synopsis of compile-time options:
++
++ People have reported using previous versions of this malloc on all
++ versions of Unix, sometimes by tweaking some of the defines
++ below. It has been tested most extensively on Solaris and
++ Linux. It is also reported to work on WIN32 platforms.
++ People also report using it in stand-alone embedded systems.
++
++ The implementation is in straight, hand-tuned ANSI C. It is not
++ at all modular. (Sorry!) It uses a lot of macros. To be at all
++ usable, this code should be compiled using an optimizing compiler
++ (for example gcc -O3) that can simplify expressions and control
++ paths. (FAQ: some macros import variables as arguments rather than
++ declare locals because people reported that some debuggers
++ otherwise get confused.)
++
++ OPTION DEFAULT VALUE
++
++ Compilation Environment options:
++
++ __STD_C derived from C compiler defines
++ WIN32 NOT defined
++ HAVE_MEMCPY defined
++ USE_MEMCPY 1 if HAVE_MEMCPY is defined
++ HAVE_MMAP defined as 1
++ MMAP_CLEARS 1
++ HAVE_MREMAP 0 unless linux defined
++ malloc_getpagesize derived from system #includes, or 4096 if not
++ HAVE_USR_INCLUDE_MALLOC_H NOT defined
++ LACKS_UNISTD_H NOT defined unless WIN32
++ LACKS_SYS_PARAM_H NOT defined unless WIN32
++ LACKS_SYS_MMAN_H NOT defined unless WIN32
++
++ Changing default word sizes:
++
++ INTERNAL_SIZE_T size_t
++ MALLOC_ALIGNMENT 2 * sizeof(INTERNAL_SIZE_T)
++
++ Configuration and functionality options:
++
++ USE_DL_PREFIX NOT defined
++ USE_PUBLIC_MALLOC_WRAPPERS NOT defined
++ USE_MALLOC_LOCK NOT defined
++ DEBUG NOT defined
++ REALLOC_ZERO_BYTES_FREES NOT defined
++ MALLOC_FAILURE_ACTION errno = ENOMEM, if __STD_C defined, else no-op
++ TRIM_FASTBINS 0
++
++ Options for customizing MORECORE:
++
++ MORECORE sbrk
++ MORECORE_CONTIGUOUS 1
++ MORECORE_CANNOT_TRIM NOT defined
++ MMAP_AS_MORECORE_SIZE (1024 * 1024)
++
++ Tuning options that are also dynamically changeable via mallopt:
++
++ DEFAULT_MXFAST 64
++ DEFAULT_TRIM_THRESHOLD 128 * 1024
++ DEFAULT_TOP_PAD 0
++ DEFAULT_MMAP_THRESHOLD 128 * 1024
++ DEFAULT_MMAP_MAX 65536
++
++ There are several other #defined constants and macros that you
++ probably don't want to touch unless you are extending or adapting malloc.
++*/
++
++/*
++ WIN32 sets up defaults for MS environment and compilers.
++ Otherwise defaults are for unix.
++*/
++
++/* #define WIN32 */
++
++#ifdef WIN32
++
++#define WIN32_LEAN_AND_MEAN
++#include <windows.h>
++
++/* Win32 doesn't supply or need the following headers */
++#define LACKS_UNISTD_H
++#define LACKS_SYS_PARAM_H
++#define LACKS_SYS_MMAN_H
++
++/* Use the supplied emulation of sbrk */
++#define MORECORE sbrk
++#define MORECORE_CONTIGUOUS 1
++#define MORECORE_FAILURE ((void*)(-1))
++
++/* Use the supplied emulation of mmap and munmap */
++#define HAVE_MMAP 1
++#define MUNMAP_FAILURE (-1)
++#define MMAP_CLEARS 1
++
++/* These values don't really matter in windows mmap emulation */
++#define MAP_PRIVATE 1
++#define MAP_ANONYMOUS 2
++#define PROT_READ 1
++#define PROT_WRITE 2
++
++/* Emulation functions defined at the end of this file */
++
++/* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */
++#ifdef USE_MALLOC_LOCK
++static int slwait(int *sl);
++static int slrelease(int *sl);
++#endif
++
++static long getpagesize(void);
++static long getregionsize(void);
++static void *sbrk(long size);
++static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg);
++static long munmap(void *ptr, long size);
++
++static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed);
++static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user);
++
++#endif
++
++/*
++ __STD_C should be nonzero if using ANSI-standard C compiler, a C++
++ compiler, or a C compiler sufficiently close to ANSI to get away
++ with it.
++*/
++
++#ifndef __STD_C
++#if defined(__STDC__) || defined(_cplusplus)
++#define __STD_C 1
++#else
++#define __STD_C 0
++#endif
++#endif /*__STD_C*/
++
++
++/*
++ Void_t* is the pointer type that malloc should say it returns
++*/
++
++#ifndef Void_t
++#if (__STD_C || defined(WIN32))
++#define Void_t void
++#else
++#define Void_t char
++#endif
++#endif /*Void_t*/
++
++#if __STD_C
++#include <stddef.h> /* for size_t */
++#else
++#include <sys/types.h>
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */
++
++/* #define LACKS_UNISTD_H */
++
++#ifndef LACKS_UNISTD_H
++#include <unistd.h>
++#endif
++
++/* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */
++
++/* #define LACKS_SYS_PARAM_H */
++
++
++#include <stdio.h> /* needed for malloc_stats */
++#include <errno.h> /* needed for optional MALLOC_FAILURE_ACTION */
++
++
++/*
++ Debugging:
++
++ Because freed chunks may be overwritten with bookkeeping fields, this
++ malloc will often die when freed memory is overwritten by user
++ programs. This can be very effective (albeit in an annoying way)
++ in helping track down dangling pointers.
++
++ If you compile with -DDEBUG, a number of assertion checks are
++ enabled that will catch more memory errors. You probably won't be
++ able to make much sense of the actual assertion errors, but they
++ should help you locate incorrectly overwritten memory. The
++ checking is fairly extensive, and will slow down execution
++ noticeably. Calling malloc_stats or mallinfo with DEBUG set will
++ attempt to check every non-mmapped allocated and free chunk in the
++ course of computing the summmaries. (By nature, mmapped regions
++ cannot be checked very much automatically.)
++
++ Setting DEBUG may also be helpful if you are trying to modify
++ this code. The assertions in the check routines spell out in more
++ detail the assumptions and invariants underlying the algorithms.
++
++ Setting DEBUG does NOT provide an automated mechanism for checking
++ that all accesses to malloced memory stay within their
++ bounds. However, there are several add-ons and adaptations of this
++ or other mallocs available that do this.
++*/
++
++#ifdef DEBUG
++#include <assert.h>
++#else
++#define assert(x) ((void)0)
++#endif
++
++
++/*
++ INTERNAL_SIZE_T is the word-size used for internal bookkeeping
++ of chunk sizes.
++
++ The default version is the same as size_t.
++
++ While not strictly necessary, it is best to define this as an
++ unsigned type, even if size_t is a signed type. This may avoid some
++ artificial size limitations on some systems.
++
++ On a 64-bit machine, you may be able to reduce malloc overhead by
++ defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the
++ expense of not being able to handle more than 2^32 of malloced
++ space. If this limitation is acceptable, you are encouraged to set
++ this unless you are on a platform requiring 16byte alignments. In
++ this case the alignment requirements turn out to negate any
++ potential advantages of decreasing size_t word size.
++
++ Implementors: Beware of the possible combinations of:
++ - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,
++ and might be the same width as int or as long
++ - size_t might have different width and signedness as INTERNAL_SIZE_T
++ - int and long might be 32 or 64 bits, and might be the same width
++ To deal with this, most comparisons and difference computations
++ among INTERNAL_SIZE_Ts should cast them to unsigned long, being
++ aware of the fact that casting an unsigned int to a wider long does
++ not sign-extend. (This also makes checking for negative numbers
++ awkward.) Some of these casts result in harmless compiler warnings
++ on some systems.
++*/
++
++#ifndef INTERNAL_SIZE_T
++#define INTERNAL_SIZE_T size_t
++#endif
++
++/* The corresponding word size */
++#define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
++
++
++/*
++ MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
++ It must be a power of two at least 2 * SIZE_SZ, even on machines
++ for which smaller alignments would suffice. It may be defined as
++ larger than this though. Note however that code and data structures
++ are optimized for the case of 8-byte alignment.
++*/
++
++
++#ifndef MALLOC_ALIGNMENT
++#define MALLOC_ALIGNMENT (2 * SIZE_SZ)
++#endif
++
++/* The corresponding bit mask value */
++#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
++
++
++
++/*
++ REALLOC_ZERO_BYTES_FREES should be set if a call to
++ realloc with zero bytes should be the same as a call to free.
++ Some people think it should. Otherwise, since this malloc
++ returns a unique pointer for malloc(0), so does realloc(p, 0).
++*/
++
++/* #define REALLOC_ZERO_BYTES_FREES */
++
++/*
++ TRIM_FASTBINS controls whether free() of a very small chunk can
++ immediately lead to trimming. Setting to true (1) can reduce memory
++ footprint, but will almost always slow down programs that use a lot
++ of small chunks.
++
++ Define this only if you are willing to give up some speed to more
++ aggressively reduce system-level memory footprint when releasing
++ memory in programs that use many small chunks. You can get
++ essentially the same effect by setting MXFAST to 0, but this can
++ lead to even greater slowdowns in programs using many small chunks.
++ TRIM_FASTBINS is an in-between compile-time option, that disables
++ only those chunks bordering topmost memory from being placed in
++ fastbins.
++*/
++
++#ifndef TRIM_FASTBINS
++#define TRIM_FASTBINS 0
++#endif
++
++
++/*
++ USE_DL_PREFIX will prefix all public routines with the string 'dl'.
++ This is necessary when you only want to use this malloc in one part
++ of a program, using your regular system malloc elsewhere.
++*/
++
++/* #define USE_DL_PREFIX */
++
++
++/*
++ USE_MALLOC_LOCK causes wrapper functions to surround each
++ callable routine with pthread mutex lock/unlock.
++
++ USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined
++*/
++
++
++/* #define USE_MALLOC_LOCK */
++
++
++/*
++ If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is
++ actually a wrapper function that first calls MALLOC_PREACTION, then
++ calls the internal routine, and follows it with
++ MALLOC_POSTACTION. This is needed for locking, but you can also use
++ this, without USE_MALLOC_LOCK, for purposes of interception,
++ instrumentation, etc. It is a sad fact that using wrappers often
++ noticeably degrades performance of malloc-intensive programs.
++*/
++
++#ifdef USE_MALLOC_LOCK
++#define USE_PUBLIC_MALLOC_WRAPPERS
++#else
++/* #define USE_PUBLIC_MALLOC_WRAPPERS */
++#endif
++
++
++/*
++ Two-phase name translation.
++ All of the actual routines are given mangled names.
++ When wrappers are used, they become the public callable versions.
++ When DL_PREFIX is used, the callable names are prefixed.
++*/
++
++#ifndef USE_PUBLIC_MALLOC_WRAPPERS
++#define cALLOc public_cALLOc
++#define fREe public_fREe
++#define cFREe public_cFREe
++#define mALLOc public_mALLOc
++#define mEMALIGn public_mEMALIGn
++#define rEALLOc public_rEALLOc
++#define vALLOc public_vALLOc
++#define pVALLOc public_pVALLOc
++#define mALLINFo public_mALLINFo
++#define mALLOPt public_mALLOPt
++#define mTRIm public_mTRIm
++#define mSTATs public_mSTATs
++#define mUSABLe public_mUSABLe
++#define iCALLOc public_iCALLOc
++#define iCOMALLOc public_iCOMALLOc
++#endif
++
++#ifdef USE_DL_PREFIX
++#define public_cALLOc dlcalloc
++#define public_fREe dlfree
++#define public_cFREe dlcfree
++#define public_mALLOc dlmalloc
++#define public_mEMALIGn dlmemalign
++#define public_rEALLOc dlrealloc
++#define public_vALLOc dlvalloc
++#define public_pVALLOc dlpvalloc
++#define public_mALLINFo dlmallinfo
++#define public_mALLOPt dlmallopt
++#define public_mTRIm dlmalloc_trim
++#define public_mSTATs dlmalloc_stats
++#define public_mUSABLe dlmalloc_usable_size
++#define public_iCALLOc dlindependent_calloc
++#define public_iCOMALLOc dlindependent_comalloc
++#else /* USE_DL_PREFIX */
++#define public_cALLOc calloc
++#define public_fREe free
++#define public_cFREe cfree
++#define public_mALLOc malloc
++#define public_mEMALIGn memalign
++#define public_rEALLOc realloc
++#define public_vALLOc valloc
++#define public_pVALLOc pvalloc
++#define public_mALLINFo mallinfo
++#define public_mALLOPt mallopt
++#define public_mTRIm malloc_trim
++#define public_mSTATs malloc_stats
++#define public_mUSABLe malloc_usable_size
++#define public_iCALLOc independent_calloc
++#define public_iCOMALLOc independent_comalloc
++#endif /* USE_DL_PREFIX */
++
++
++/*
++ HAVE_MEMCPY should be defined if you are not otherwise using
++ ANSI STD C, but still have memcpy and memset in your C library
++ and want to use them in calloc and realloc. Otherwise simple
++ macro versions are defined below.
++
++ USE_MEMCPY should be defined as 1 if you actually want to
++ have memset and memcpy called. People report that the macro
++ versions are faster than libc versions on some systems.
++
++ Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks
++ (of <= 36 bytes) are manually unrolled in realloc and calloc.
++*/
++
++/* If it's available it's defined in config.h. */
++/* #define HAVE_MEMCPY */
++
++#ifndef USE_MEMCPY
++#ifdef HAVE_MEMCPY
++#define USE_MEMCPY 1
++#else
++#define USE_MEMCPY 0
++#endif
++#endif
++
++
++#if (__STD_C || defined(HAVE_MEMCPY))
++
++#ifdef WIN32
++/* On Win32 memset and memcpy are already declared in windows.h */
++#else
++#if __STD_C
++void* memset(void*, int, size_t);
++void* memcpy(void*, const void*, size_t);
++#else
++Void_t* memset();
++Void_t* memcpy();
++#endif
++#endif
++#endif
++
++/*
++ MALLOC_FAILURE_ACTION is the action to take before "return 0" when
++ malloc fails to be able to return memory, either because memory is
++ exhausted or because of illegal arguments.
++
++ By default, sets errno if running on STD_C platform, else does nothing.
++*/
++
++#ifndef MALLOC_FAILURE_ACTION
++#if __STD_C
++#define MALLOC_FAILURE_ACTION \
++ errno = ENOMEM;
++
++#else
++#define MALLOC_FAILURE_ACTION
++#endif
++#endif
++
++/*
++ MORECORE-related declarations. By default, rely on sbrk
++*/
++
++
++#ifdef LACKS_UNISTD_H
++#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
++#if __STD_C
++extern Void_t* sbrk(ptrdiff_t);
++#else
++extern Void_t* sbrk();
++#endif
++#endif
++#endif
++
++/*
++ MORECORE is the name of the routine to call to obtain more memory
++ from the system. See below for general guidance on writing
++ alternative MORECORE functions, as well as a version for WIN32 and a
++ sample version for pre-OSX macos.
++*/
++
++#ifndef MORECORE
++#define MORECORE sbrk
++#endif
++
++/*
++ MORECORE_FAILURE is the value returned upon failure of MORECORE
++ as well as mmap. Since it cannot be an otherwise valid memory address,
++ and must reflect values of standard sys calls, you probably ought not
++ try to redefine it.
++*/
++
++#ifndef MORECORE_FAILURE
++#define MORECORE_FAILURE (-1)
++#endif
++
++/*
++ If MORECORE_CONTIGUOUS is true, take advantage of fact that
++ consecutive calls to MORECORE with positive arguments always return
++ contiguous increasing addresses. This is true of unix sbrk. Even
++ if not defined, when regions happen to be contiguous, malloc will
++ permit allocations spanning regions obtained from different
++ calls. But defining this when applicable enables some stronger
++ consistency checks and space efficiencies.
++*/
++
++#ifndef MORECORE_CONTIGUOUS
++#define MORECORE_CONTIGUOUS 1
++#endif
++
++/*
++ Define MORECORE_CANNOT_TRIM if your version of MORECORE
++ cannot release space back to the system when given negative
++ arguments. This is generally necessary only if you are using
++ a hand-crafted MORECORE function that cannot handle negative arguments.
++*/
++
++/* #define MORECORE_CANNOT_TRIM */
++
++
++/*
++ Define HAVE_MMAP as true to optionally make malloc() use mmap() to
++ allocate very large blocks. These will be returned to the
++ operating system immediately after a free(). Also, if mmap
++ is available, it is used as a backup strategy in cases where
++ MORECORE fails to provide space from system.
++
++ This malloc is best tuned to work with mmap for large requests.
++ If you do not have mmap, operations involving very large chunks (1MB
++ or so) may be slower than you'd like.
++*/
++
++#ifndef HAVE_MMAP
++#define HAVE_MMAP 1
++#endif
++
++#if HAVE_MMAP
++/*
++ Standard unix mmap using /dev/zero clears memory so calloc doesn't
++ need to.
++*/
++
++#ifndef MMAP_CLEARS
++#define MMAP_CLEARS 1
++#endif
++
++#else /* no mmap */
++#ifndef MMAP_CLEARS
++#define MMAP_CLEARS 0
++#endif
++#endif
++
++
++/*
++ MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if
++ sbrk fails, and mmap is used as a backup (which is done only if
++ HAVE_MMAP). The value must be a multiple of page size. This
++ backup strategy generally applies only when systems have "holes" in
++ address space, so sbrk cannot perform contiguous expansion, but
++ there is still space available on system. On systems for which
++ this is known to be useful (i.e. most linux kernels), this occurs
++ only when programs allocate huge amounts of memory. Between this,
++ and the fact that mmap regions tend to be limited, the size should
++ be large, to avoid too many mmap calls and thus avoid running out
++ of kernel resources.
++*/
++
++#ifndef MMAP_AS_MORECORE_SIZE
++#define MMAP_AS_MORECORE_SIZE (1024 * 1024)
++#endif
++
++/*
++ Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
++ large blocks. This is currently only possible on Linux with
++ kernel versions newer than 1.3.77.
++*/
++
++#ifndef HAVE_MREMAP
++#if defined(linux) || defined(__linux__) || defined(__linux)
++#define HAVE_MREMAP 1
++#else
++#define HAVE_MREMAP 0
++#endif
++
++#endif /* HAVE_MMAP */
++
++
++/*
++ The system page size. To the extent possible, this malloc manages
++ memory from the system in page-size units. Note that this value is
++ cached during initialization into a field of malloc_state. So even
++ if malloc_getpagesize is a function, it is only called once.
++
++ The following mechanics for getpagesize were adapted from bsd/gnu
++ getpagesize.h. If none of the system-probes here apply, a value of
++ 4096 is used, which should be OK: If they don't apply, then using
++ the actual value probably doesn't impact performance.
++*/
++
++
++#ifndef malloc_getpagesize
++
++#ifndef LACKS_UNISTD_H
++# include <unistd.h>
++#endif
++
++# 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 */
++# define malloc_getpagesize getpagesize()
++# else
++# ifndef LACKS_SYS_PARAM_H
++# include <sys/param.h>
++# endif
++# ifdef EXEC_PAGESIZE
++# define malloc_getpagesize EXEC_PAGESIZE
++# else
++# ifdef NBPG
++# ifndef CLSIZE
++# define malloc_getpagesize NBPG
++# else
++# define malloc_getpagesize (NBPG * CLSIZE)
++# endif
++# else
++# ifdef NBPC
++# define malloc_getpagesize NBPC
++# else
++# ifdef PAGESIZE
++# define malloc_getpagesize PAGESIZE
++# else /* just guess */
++# define malloc_getpagesize (4096)
++# endif
++# endif
++# endif
++# endif
++# endif
++# endif
++# endif
++#endif
++
++/*
++ This version of malloc supports the standard SVID/XPG mallinfo
++ routine that returns a struct containing usage properties and
++ statistics. It should work on any SVID/XPG compliant system that has
++ a /usr/include/malloc.h defining struct mallinfo. (If you'd like to
++ install such a thing yourself, cut out the preliminary declarations
++ as described above and below and save them in a malloc.h file. But
++ there's no compelling reason to bother to do this.)
++
++ The main declaration needed is the mallinfo struct that is returned
++ (by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a
++ bunch of field that are not even meaningful in this version of
++ malloc. These fields are are instead filled by mallinfo() with
++ other numbers that might be of interest.
++
++ HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
++ /usr/include/malloc.h file that includes a declaration of struct
++ mallinfo. If so, it is included; else an SVID2/XPG2 compliant
++ version is declared below. These must be precisely the same for
++ mallinfo() to work. The original SVID version of this struct,
++ defined on most systems with mallinfo, declares all fields as
++ ints. But some others define as unsigned long. If your system
++ defines the fields using a type of different width than listed here,
++ you must #include your system version and #define
++ HAVE_USR_INCLUDE_MALLOC_H.
++*/
++
++/* #define HAVE_USR_INCLUDE_MALLOC_H */
++
++/*#ifdef HAVE_USR_INCLUDE_MALLOC_H*/
++#if 0
++#include "/usr/include/malloc.h"
++#else
++
++/* SVID2/XPG mallinfo structure */
++
++struct mallinfo {
++ int arena; /* non-mmapped space allocated from system */
++ int ordblks; /* number of free chunks */
++ int smblks; /* number of fastbin blocks */
++ int hblks; /* number of mmapped regions */
++ int hblkhd; /* space in mmapped regions */
++ int usmblks; /* maximum total allocated space */
++ int fsmblks; /* space available in freed fastbin blocks */
++ int uordblks; /* total allocated space */
++ int fordblks; /* total free space */
++ int keepcost; /* top-most, releasable (via malloc_trim) space */
++};
++
++/*
++ SVID/XPG defines four standard parameter numbers for mallopt,
++ normally defined in malloc.h. Only one of these (M_MXFAST) is used
++ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
++ so setting them has no effect. But this malloc also supports other
++ options in mallopt described below.
++*/
++#endif
++
++
++/* ---------- description of public routines ------------ */
++
++/*
++ malloc(size_t n)
++ Returns a pointer to a newly allocated chunk of at least n bytes, or null
++ if no space is available. Additionally, on failure, errno is
++ set to ENOMEM on ANSI C systems.
++
++ If n is zero, malloc returns a minumum-sized chunk. (The minimum
++ size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
++ systems.) On most systems, size_t is an unsigned type, so calls
++ with negative arguments 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.
++*/
++#if __STD_C
++Void_t* public_mALLOc(size_t);
++#else
++Void_t* public_mALLOc();
++#endif
++
++/*
++ free(Void_t* 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. It can have arbitrary (i.e., bad!)
++ effects if p has already been freed.
++
++ Unless disabled (using mallopt), freeing very large spaces will
++ when possible, automatically trigger operations that give
++ back unused memory to the system, thus reducing program footprint.
++*/
++#if __STD_C
++void public_fREe(Void_t*);
++#else
++void public_fREe();
++#endif
++
++/*
++ calloc(size_t n_elements, size_t element_size);
++ Returns a pointer to n_elements * element_size bytes, with all locations
++ set to zero.
++*/
++#if __STD_C
++Void_t* public_cALLOc(size_t, size_t);
++#else
++Void_t* public_cALLOc();
++#endif
++
++/*
++ realloc(Void_t* 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
++ if no space is available.
++
++ The returned pointer may or may not be the same as p. The algorithm
++ prefers extending p when possible, otherwise it employs the
++ equivalent of a malloc-copy-free sequence.
++
++ If p is null, realloc is equivalent to malloc.
++
++ If space is not available, realloc returns null, errno is set (if on
++ ANSI) and p is NOT freed.
++
++ if n is for fewer bytes than already held by p, the newly unused
++ space is lopped off and freed if possible. Unless the #define
++ REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of
++ zero (re)allocates a minimum-sized chunk.
++
++ Large chunks that were internally obtained via mmap will always
++ be reallocated using malloc-copy-free sequences unless
++ the system supports MREMAP (currently only linux).
++
++ The old unix realloc convention of allowing the last-free'd chunk
++ to be used as an argument to realloc is not supported.
++*/
++#if __STD_C
++Void_t* public_rEALLOc(Void_t*, size_t);
++#else
++Void_t* public_rEALLOc();
++#endif
++
++/*
++ 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.
++
++ The alignment argument should be a power of two. If the argument is
++ not a power of two, the nearest greater power is used.
++ 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.
++*/
++#if __STD_C
++Void_t* public_mEMALIGn(size_t, size_t);
++#else
++Void_t* public_mEMALIGn();
++#endif
++
++/*
++ 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.
++*/
++#if __STD_C
++Void_t* public_vALLOc(size_t);
++#else
++Void_t* public_vALLOc();
++#endif
++
++
++
++/*
++ 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
++ corresponding parameter to the argument value if it can (i.e., so
++ long as the value is meaningful), and returns 1 if successful else
++ 0. SVID/XPG/ANSI defines four standard param numbers for mallopt,
++ normally defined in malloc.h. Only one of these (M_MXFAST) is used
++ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
++ so setting them has no effect. But this malloc also supports four
++ other options in mallopt. See below for details. Briefly, supported
++ parameters are as follows (listed defaults are for "typical"
++ configurations).
++
++ Symbol param # default allowed param values
++ M_MXFAST 1 64 0-80 (0 disables fastbins)
++ M_TRIM_THRESHOLD -1 128*1024 any (-1U disables trimming)
++ M_TOP_PAD -2 0 any
++ M_MMAP_THRESHOLD -3 128*1024 any (or 0 if no MMAP support)
++ M_MMAP_MAX -4 65536 any (0 disables use of mmap)
++*/
++#if __STD_C
++int public_mALLOPt(int, int);
++#else
++int public_mALLOPt();
++#endif
++
++
++/*
++ mallinfo()
++ Returns (by copy) a struct containing various summary statistics:
++
++ arena: current total non-mmapped bytes allocated from system
++ ordblks: the number of free chunks
++ smblks: the number of fastbin blocks (i.e., small chunks that
++ have been freed but not use resused or consolidated)
++ hblks: current number of mmapped regions
++ hblkhd: total bytes held in mmapped regions
++ usmblks: the maximum total allocated space. This will be greater
++ than current total if trimming has occurred.
++ fsmblks: total bytes held in fastbin blocks
++ uordblks: current total allocated space (normal or mmapped)
++ fordblks: total free space
++ keepcost: the maximum number of bytes that could ideally be released
++ back to system via malloc_trim. ("ideally" means that
++ it ignores page restrictions etc.)
++
++ Because these fields are ints, but internal bookkeeping may
++ be kept as longs, the reported values may wrap around zero and
++ thus be inaccurate.
++*/
++#if __STD_C
++struct mallinfo public_mALLINFo(void);
++#else
++struct mallinfo public_mALLINFo();
++#endif
++
++/*
++ independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
++
++ independent_calloc is similar to calloc, but instead of returning a
++ single cleared space, it returns an array of pointers to n_elements
++ independent elements that can hold contents of size elem_size, each
++ of which starts out cleared, and can be independently freed,
++ realloc'ed etc. The elements are guaranteed to be adjacently
++ allocated (this is not guaranteed to occur with multiple callocs or
++ mallocs), which may also improve cache locality in some
++ applications.
++
++ The "chunks" argument is optional (i.e., may be null, which is
++ probably the most typical usage). If it is null, the returned array
++ is itself dynamically allocated and should also be freed when it is
++ no longer needed. Otherwise, the chunks array must be of at least
++ n_elements in length. It is filled in with the pointers to the
++ chunks.
++
++ In either case, independent_calloc returns this pointer array, or
++ null if the allocation failed. If n_elements is zero and "chunks"
++ is null, it returns a chunk representing an array with zero elements
++ (which should be freed if not wanted).
++
++ Each element must be individually freed when it is no longer
++ needed. If you'd like to instead be able to free all at once, you
++ should instead use regular calloc and assign pointers into this
++ space to represent elements. (In this case though, you cannot
++ independently free elements.)
++
++ independent_calloc simplifies and speeds up implementations of many
++ kinds of pools. It may also be useful when constructing large data
++ structures that initially have a fixed number of fixed-sized nodes,
++ but the number is not known at compile time, and some of the nodes
++ may later need to be freed. For example:
++
++ struct Node { int item; struct Node* next; };
++
++ struct Node* build_list() {
++ struct Node** pool;
++ int n = read_number_of_nodes_needed();
++ if (n <= 0) return 0;
++ pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
++ if (pool == 0) die();
++ // organize into a linked list...
++ struct Node* first = pool[0];
++ for (i = 0; i < n-1; ++i)
++ pool[i]->next = pool[i+1];
++ free(pool); // Can now free the array (or not, if it is needed later)
++ return first;
++ }
++*/
++#if __STD_C
++Void_t** public_iCALLOc(size_t, size_t, Void_t**);
++#else
++Void_t** public_iCALLOc();
++#endif
++
++/*
++ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
++
++ independent_comalloc allocates, all at once, a set of n_elements
++ chunks with sizes indicated in the "sizes" array. It returns
++ an array of pointers to these elements, each of which can be
++ independently freed, realloc'ed etc. The elements are guaranteed to
++ be adjacently allocated (this is not guaranteed to occur with
++ multiple callocs or mallocs), which may also improve cache locality
++ in some applications.
++
++ The "chunks" argument is optional (i.e., may be null). If it is null
++ the returned array is itself dynamically allocated and should also
++ be freed when it is no longer needed. Otherwise, the chunks array
++ must be of at least n_elements in length. It is filled in with the
++ pointers to the chunks.
++
++ In either case, independent_comalloc returns this pointer array, or
++ null if the allocation failed. If n_elements is zero and chunks is
++ null, it returns a chunk representing an array with zero elements
++ (which should be freed if not wanted).
++
++ Each element must be individually freed when it is no longer
++ needed. If you'd like to instead be able to free all at once, you
++ should instead use a single regular malloc, and assign pointers at
++ particular offsets in the aggregate space. (In this case though, you
++ cannot independently free elements.)
++
++ independent_comallac differs from independent_calloc in that each
++ element may have a different size, and also that it does not
++ automatically clear elements.
++
++ independent_comalloc can be used to speed up allocation in cases
++ where several structs or objects must always be allocated at the
++ same time. For example:
++
++ struct Head { ... }
++ struct Foot { ... }
++
++ void send_message(char* msg) {
++ int msglen = strlen(msg);
++ size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
++ void* chunks[3];
++ if (independent_comalloc(3, sizes, chunks) == 0)
++ die();
++ struct Head* head = (struct Head*)(chunks[0]);
++ char* body = (char*)(chunks[1]);
++ struct Foot* foot = (struct Foot*)(chunks[2]);
++ // ...
++ }
++
++ In general though, independent_comalloc is worth using only for
++ larger values of n_elements. For small values, you probably won't
++ detect enough difference from series of malloc calls to bother.
++
++ 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.
++*/
++#if __STD_C
++Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
++#else
++Void_t** public_iCOMALLOc();
++#endif
++
++
++/*
++ pvalloc(size_t n);
++ Equivalent to valloc(minimum-page-that-holds(n)), that is,
++ round up n to nearest pagesize.
++ */
++#if __STD_C
++Void_t* public_pVALLOc(size_t);
++#else
++Void_t* public_pVALLOc();
++#endif
++
++/*
++ cfree(Void_t* p);
++ Equivalent to free(p).
++
++ cfree is needed/defined on some systems that pair it with calloc,
++ for odd historical reasons (such as: cfree is used in example
++ code in the first edition of K&R).
++*/
++#if __STD_C
++void public_cFREe(Void_t*);
++#else
++void public_cFREe();
++#endif
++
++/*
++ malloc_trim(size_t pad);
++
++ If possible, gives memory back to the system (via negative
++ arguments to sbrk) if there is unused memory at the `high' end of
++ the malloc pool. You can call this after freeing large blocks of
++ memory to potentially reduce the system-level memory requirements
++ of a program. However, it cannot guarantee to reduce memory. Under
++ some allocation patterns, some large free blocks of memory will be
++ locked between two used chunks, so they cannot be given back to
++ the system.
++
++ The `pad' argument to malloc_trim represents the amount of free
++ trailing space to leave untrimmed. If this argument is zero,
++ only the minimum amount of memory to maintain internal data
++ structures will be left (one page or less). Non-zero arguments
++ can be supplied to maintain enough 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.
++ On systems that do not support "negative sbrks", it will always
++ rreturn 0.
++*/
++#if __STD_C
++int public_mTRIm(size_t);
++#else
++int public_mTRIm();
++#endif
++
++/*
++ malloc_usable_size(Void_t* p);
++
++ Returns the number of bytes you can actually use in
++ an allocated chunk, which may be more than you requested (although
++ often not) due to alignment and minimum size constraints.
++ You can use this many bytes without worrying about
++ overwriting other allocated objects. This is not a particularly great
++ programming practice. malloc_usable_size can be more useful in
++ debugging and assertions, for example:
++
++ p = malloc(n);
++ assert(malloc_usable_size(p) >= 256);
++
++*/
++#if __STD_C
++size_t public_mUSABLe(Void_t*);
++#else
++size_t public_mUSABLe();
++#endif
++
++/*
++ 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
++ current if malloc_trim and/or munmap got called), and the current
++ number of bytes allocated via malloc (or realloc, etc) but not yet
++ freed. Note that this is the number of bytes allocated, not the
++ number requested. It will be larger than the number requested
++ because of alignment and bookkeeping overhead. Because it includes
++ alignment wastage as being in use, this figure may be greater than
++ zero even when no user-level chunks are allocated.
++
++ The reported current and maximum system memory can be inaccurate if
++ a program makes other calls to system memory allocation functions
++ (normally sbrk) outside of malloc.
++
++ malloc_stats prints only the most commonly interesting statistics.
++ More information can be obtained by calling mallinfo.
++
++*/
++#if __STD_C
++void public_mSTATs();
++#else
++void public_mSTATs();
++#endif
++
++/* mallopt tuning options */
++
++/*
++ M_MXFAST is the maximum request size used for "fastbins", special bins
++ that hold returned chunks without consolidating their spaces. This
++ enables future requests for chunks of the same size to be handled
++ very quickly, but can increase fragmentation, and thus increase the
++ overall memory footprint of a program.
++
++ This malloc manages fastbins very conservatively yet still
++ efficiently, so fragmentation is rarely a problem for values less
++ than or equal to the default. The maximum supported value of MXFAST
++ is 80. You wouldn't want it any higher than this anyway. Fastbins
++ are designed especially for use with many small structs, objects or
++ strings -- the default handles structs/objects/arrays with sizes up
++ to 8 4byte fields, or small strings representing words, tokens,
++ etc. Using fastbins for larger objects normally worsens
++ fragmentation without improving speed.
++
++ M_MXFAST is set in REQUEST size units. It is internally used in
++ chunksize units, which adds padding and alignment. You can reduce
++ M_MXFAST to 0 to disable all use of fastbins. This causes the malloc
++ algorithm to be a closer approximation of fifo-best-fit in all cases,
++ not just for larger requests, but will generally cause it to be
++ slower.
++*/
++
++
++/* M_MXFAST is a standard SVID/XPG tuning option, usually listed in malloc.h */
++#ifndef M_MXFAST
++#define M_MXFAST 1
++#endif
++
++#ifndef DEFAULT_MXFAST
++#define DEFAULT_MXFAST 64
++#endif
++
++
++/*
++ M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
++ to keep before releasing via malloc_trim in free().
++
++ Automatic trimming is mainly useful in long-lived programs.
++ Because trimming via sbrk can be slow on some systems, and can
++ sometimes be wasteful (in cases where programs immediately
++ afterward allocate more large chunks) the value should be high
++ enough so that your overall system performance would improve by
++ releasing this much memory.
++
++ The trim threshold and the mmap control parameters (see below)
++ can be traded off with one another. Trimming and mmapping are
++ two different ways of releasing unused memory back to the
++ system. Between these two, it is often possible to keep
++ system-level demands of a long-lived program down to a bare
++ minimum. For example, in one test suite of sessions measuring
++ the XF86 X server on Linux, using a trim threshold of 128K and a
++ mmap threshold of 192K led to near-minimal long term resource
++ consumption.
++
++ If you are using this malloc in a long-lived program, it should
++ pay to experiment with these values. As a rough guide, you
++ might set to a value close to the average size of a process
++ (program) running on your system. Releasing this much memory
++ would allow such a process to run in memory. Generally, it's
++ worth it to tune for trimming rather tham memory mapping when a
++ program undergoes phases where several large chunks are
++ allocated and released in ways that can reuse each other's
++ storage, perhaps mixed with phases where there are no such
++ chunks at all. And in well-behaved long-lived programs,
++ controlling release of large blocks via trimming versus mapping
++ is usually faster.
++
++ However, in most programs, these parameters serve mainly as
++ protection against the system-level effects of carrying around
++ massive amounts of unneeded memory. Since frequent calls to
++ sbrk, mmap, and munmap otherwise degrade performance, the default
++ parameters are set to relatively high values that serve only as
++ safeguards.
++
++ The trim value It must be greater than page size to have any useful
++ effect. To disable trimming completely, you can set to
++ (unsigned long)(-1)
++
++ Trim settings interact with fastbin (MXFAST) settings: Unless
++ TRIM_FASTBINS is defined, automatic trimming never takes place upon
++ freeing a chunk with size less than or equal to MXFAST. Trimming is
++ instead delayed until subsequent freeing of larger chunks. However,
++ you can still force an attempted trim by calling malloc_trim.
++
++ Also, trimming is not generally possible in cases where
++ the main arena is obtained via mmap.
++
++ Note that the trick some people use of mallocing a huge space and
++ then freeing it at program startup, in an attempt to reserve system
++ memory, doesn't have the intended effect under automatic trimming,
++ since that memory will immediately be returned to the system.
++*/
++
++#define M_TRIM_THRESHOLD -1
++
++#ifndef DEFAULT_TRIM_THRESHOLD
++#define DEFAULT_TRIM_THRESHOLD (128 * 1024)
++#endif
++
++/*
++ M_TOP_PAD is the amount of extra `padding' space to allocate or
++ retain whenever sbrk is called. It is used in two ways internally:
++
++ * When sbrk is called to extend the top of the arena to satisfy
++ a new malloc request, this much padding is added to the sbrk
++ request.
++
++ * When malloc_trim is called automatically from free(),
++ it is used as the `pad' argument.
++
++ In both cases, the actual amount of padding is rounded
++ so that the end of the arena is always a system page boundary.
++
++ The main reason for using padding is to avoid calling sbrk so
++ often. Having even a small pad greatly reduces the likelihood
++ that nearly every malloc request during program start-up (or
++ after trimming) will invoke sbrk, which needlessly wastes
++ time.
++
++ Automatic rounding-up to page-size units is normally sufficient
++ to avoid measurable overhead, so the default is 0. However, in
++ systems where sbrk is relatively slow, it can pay to increase
++ this value, at the expense of carrying around more memory than
++ the program needs.
++*/
++
++#define M_TOP_PAD -2
++
++#ifndef DEFAULT_TOP_PAD
++#define DEFAULT_TOP_PAD (0)
++#endif
++
++/*
++ M_MMAP_THRESHOLD is the request size threshold for using mmap()
++ to service a request. Requests of at least this size that cannot
++ be allocated using already-existing space will be serviced via mmap.
++ (If enough normal freed space already exists it is used instead.)
++
++ Using mmap segregates relatively large chunks of memory so that
++ they can be individually obtained and released from the host
++ system. A request serviced through mmap is never reused by any
++ other request (at least not directly; the system may just so
++ happen to remap successive requests to the same locations).
++
++ Segregating space in this way has the benefits that:
++
++ 1. Mmapped space can ALWAYS be individually released back
++ to the system, which helps keep the system level memory
++ demands of a long-lived program low.
++ 2. Mapped memory can never become `locked' between
++ other chunks, as can happen with normally allocated chunks, which
++ means that even trimming via malloc_trim would not release them.
++ 3. On some systems with "holes" in address spaces, mmap can obtain
++ memory that sbrk cannot.
++
++ However, it has the disadvantages that:
++
++ 1. The space cannot be reclaimed, consolidated, and then
++ used to service later requests, as happens with normal chunks.
++ 2. It can lead to more wastage because of mmap page alignment
++ requirements
++ 3. It causes malloc performance to be more dependent on host
++ system memory management support routines which may vary in
++ implementation quality and may impose arbitrary
++ limitations. Generally, servicing a request via normal
++ malloc steps is faster than going through a system's mmap.
++
++ The advantages of mmap nearly always outweigh disadvantages for
++ "large" chunks, but the value of "large" varies across systems. The
++ default is an empirically derived value that works well in most
++ systems.
++*/
++
++#define M_MMAP_THRESHOLD -3
++
++#ifndef DEFAULT_MMAP_THRESHOLD
++#define DEFAULT_MMAP_THRESHOLD (128 * 1024)
++#endif
++
++/*
++ M_MMAP_MAX is the maximum number of requests to simultaneously
++ service using mmap. This parameter exists because
++. Some systems have a limited number of internal tables for
++ use by mmap, and using more than a few of them may degrade
++ performance.
++
++ The default is set to a value that serves only as a safeguard.
++ Setting to 0 disables use of mmap for servicing large requests. If
++ HAVE_MMAP is not set, the default value is 0, and attempts to set it
++ to non-zero values in mallopt will fail.
++*/
++
++#define M_MMAP_MAX -4
++
++#ifndef DEFAULT_MMAP_MAX
++#if HAVE_MMAP
++#define DEFAULT_MMAP_MAX (65536)
++#else
++#define DEFAULT_MMAP_MAX (0)
++#endif
++#endif
++
++#ifdef __cplusplus
++}; /* end of extern "C" */
++#endif
++
++/*
++ ========================================================================
++ To make a fully customizable malloc.h header file, cut everything
++ above this line, put into file malloc.h, edit to suit, and #include it
++ on the next line, as well as in programs that use this malloc.
++ ========================================================================
++*/
++
++/* #include "malloc.h" */
++
++/* --------------------- public wrappers ---------------------- */
++
++#ifdef USE_PUBLIC_MALLOC_WRAPPERS
++
++/* Declare all routines as internal */
++#if __STD_C
++static Void_t* mALLOc(size_t);
++static void fREe(Void_t*);
++static Void_t* rEALLOc(Void_t*, size_t);
++static Void_t* mEMALIGn(size_t, size_t);
++static Void_t* vALLOc(size_t);
++static Void_t* pVALLOc(size_t);
++static Void_t* cALLOc(size_t, size_t);
++static Void_t** iCALLOc(size_t, size_t, Void_t**);
++static Void_t** iCOMALLOc(size_t, size_t*, Void_t**);
++static void cFREe(Void_t*);
++static int mTRIm(size_t);
++static size_t mUSABLe(Void_t*);
++static void mSTATs();
++static int mALLOPt(int, int);
++static struct mallinfo mALLINFo(void);
++#else
++static Void_t* mALLOc();
++static void fREe();
++static Void_t* rEALLOc();
++static Void_t* mEMALIGn();
++static Void_t* vALLOc();
++static Void_t* pVALLOc();
++static Void_t* cALLOc();
++static Void_t** iCALLOc();
++static Void_t** iCOMALLOc();
++static void cFREe();
++static int mTRIm();
++static size_t mUSABLe();
++static void mSTATs();
++static int mALLOPt();
++static struct mallinfo mALLINFo();
++#endif
++
++/*
++ MALLOC_PREACTION and MALLOC_POSTACTION should be
++ defined to return 0 on success, and nonzero on failure.
++ The return value of MALLOC_POSTACTION is currently ignored
++ in wrapper functions since there is no reasonable default
++ action to take on failure.
++*/
++
++
++#ifdef USE_MALLOC_LOCK
++
++#ifdef WIN32
++
++static int mALLOC_MUTEx;
++#define MALLOC_PREACTION slwait(&mALLOC_MUTEx)
++#define MALLOC_POSTACTION slrelease(&mALLOC_MUTEx)
++
++#else
++
++#if 0
++#include <pthread.h>
++
++static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER;
++
++#define MALLOC_PREACTION pthread_mutex_lock(&mALLOC_MUTEx)
++#define MALLOC_POSTACTION pthread_mutex_unlock(&mALLOC_MUTEx)
++
++#else
++
++#ifdef KDE_MALLOC_X86
++#include "x86.h"
++#elif defined(KDE_MALLOC_AVR32)
++
++#include <sched.h>
++#include <time.h>
++
++static __inline__ int q_atomic_swp(volatile unsigned int *ptr,
++ unsigned int newval)
++{
++ register int ret;
++ asm volatile("xchg %0,%1,%2"
++ : "=&r"(ret)
++ : "r"(ptr), "r"(newval)
++ : "memory", "cc");
++ return ret;
++}
++
++typedef struct {
++ volatile unsigned int lock;
++ int pad0_;
++} mutex_t;
++
++#define MUTEX_INITIALIZER { 0, 0 }
++
++static __inline__ int lock(mutex_t *m) {
++ int cnt = 0;
++ struct timespec tm;
++
++ for(;;) {
++ if (q_atomic_swp(&m->lock, 1) == 0)
++ return 0;
++#ifdef _POSIX_PRIORITY_SCHEDULING
++ if(cnt < 50) {
++ sched_yield();
++ cnt++;
++ } else
++#endif
++ {
++ tm.tv_sec = 0;
++ tm.tv_nsec = 2000001;
++ nanosleep(&tm, NULL);
++ cnt = 0;
++ }
++ }
++}
++
++static __inline__ int unlock(mutex_t *m) {
++ m->lock = 0;
++ return 0;
++}
++
++#else
++#error Unknown spinlock implementation
++#endif
++
++static mutex_t spinlock = MUTEX_INITIALIZER;
++
++#define MALLOC_PREACTION lock( &spinlock )
++#define MALLOC_POSTACTION unlock( &spinlock )
++
++#endif
++
++#endif /* USE_MALLOC_LOCK */
++
++#else
++
++/* Substitute anything you like for these */
++
++#define MALLOC_PREACTION (0)
++#define MALLOC_POSTACTION (0)
++
++#endif
++
++#if 0
++Void_t* public_mALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++void public_fREe(Void_t* m) {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ fREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = rEALLOc(m, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mEMALIGn(alignment, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_vALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = vALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_pVALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = pVALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_cALLOc(size_t n, size_t elem_size) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = cALLOc(n, elem_size);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++
++Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {
++ Void_t** m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = iCALLOc(n, elem_size, chunks);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {
++ Void_t** m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = iCOMALLOc(n, sizes, chunks);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++void public_cFREe(Void_t* m) {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ cFREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++int public_mTRIm(size_t s) {
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mTRIm(s);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++
++size_t public_mUSABLe(Void_t* m) {
++ size_t result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mUSABLe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++
++void public_mSTATs() {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ mSTATs();
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++struct mallinfo public_mALLINFo() {
++ struct mallinfo m;
++ if (MALLOC_PREACTION != 0) {
++ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
++ return nm;
++ }
++ m = mALLINFo();
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++int public_mALLOPt(int p, int v) {
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mALLOPt(p, v);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++#endif
++
++#endif
++
++
++
++/* ------------- Optional versions of memcopy ---------------- */
++
++
++#if USE_MEMCPY
++
++/*
++ Note: memcpy is ONLY invoked with non-overlapping regions,
++ so the (usually slower) memmove is not needed.
++*/
++
++#define MALLOC_COPY(dest, src, nbytes) memcpy(dest, src, nbytes)
++#define MALLOC_ZERO(dest, nbytes) memset(dest, 0, nbytes)
++
++#else /* !USE_MEMCPY */
++
++/* Use Duff's device for good zeroing/copying performance. */
++
++#define MALLOC_ZERO(charp, nbytes) \
++do { \
++ INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \
++ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
++ long mcn; \
++ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
++ switch (mctmp) { \
++ case 0: for(;;) { *mzp++ = 0; \
++ case 7: *mzp++ = 0; \
++ case 6: *mzp++ = 0; \
++ case 5: *mzp++ = 0; \
++ case 4: *mzp++ = 0; \
++ case 3: *mzp++ = 0; \
++ case 2: *mzp++ = 0; \
++ case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \
++ } \
++} while(0)
++
++#define MALLOC_COPY(dest,src,nbytes) \
++do { \
++ INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \
++ INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \
++ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
++ long mcn; \
++ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
++ switch (mctmp) { \
++ case 0: for(;;) { *mcdst++ = *mcsrc++; \
++ case 7: *mcdst++ = *mcsrc++; \
++ case 6: *mcdst++ = *mcsrc++; \
++ case 5: *mcdst++ = *mcsrc++; \
++ case 4: *mcdst++ = *mcsrc++; \
++ case 3: *mcdst++ = *mcsrc++; \
++ case 2: *mcdst++ = *mcsrc++; \
++ case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \
++ } \
++} while(0)
++
++#endif
++
++/* ------------------ MMAP support ------------------ */
++
++
++#if HAVE_MMAP
++
++#include <fcntl.h>
++#ifndef LACKS_SYS_MMAN_H
++#include <sys/mman.h>
++#endif
++
++#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
++#define MAP_ANONYMOUS MAP_ANON
++#endif
++
++/*
++ Nearly all versions of mmap support MAP_ANONYMOUS,
++ so the following is unlikely to be needed, but is
++ supplied just in case.
++*/
++
++#ifndef MAP_ANONYMOUS
++
++static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
++
++#define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? \
++ (dev_zero_fd = open("/dev/zero", O_RDWR), \
++ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : \
++ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0))
++
++#else
++
++#define MMAP(addr, size, prot, flags) \
++ (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0))
++
++#endif
++
++
++#endif /* HAVE_MMAP */
++
++
++/*
++ ----------------------- Chunk representations -----------------------
++*/
++
++
++/*
++ This struct declaration is misleading (but accurate and necessary).
++ It declares a "view" into memory allowing access to necessary
++ fields at known offsets from a given base. See explanation below.
++*/
++
++struct malloc_chunk {
++
++ INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
++ INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
++
++ struct malloc_chunk* fd; /* double links -- used only if free. */
++ struct malloc_chunk* bk;
++};
++
++
++typedef struct malloc_chunk* mchunkptr;
++
++/*
++ malloc_chunk details:
++
++ (The following includes lightly edited explanations by Colin Plumb.)
++
++ Chunks of memory are maintained using a `boundary tag' method as
++ described in e.g., Knuth or Standish. (See the paper by Paul
++ Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
++ survey of such techniques.) Sizes of free chunks are stored both
++ in the front of each chunk and at the end. This makes
++ consolidating fragmented chunks into bigger chunks very fast. The
++ size fields also hold bits representing whether chunks are free or
++ in use.
++
++ An allocated chunk looks like this:
++
++
++ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of previous chunk, if allocated | |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of chunk, in bytes |P|
++ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | User data starts here... .
++ . .
++ . (malloc_usable_space() bytes) .
++ . |
++nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of chunk |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++
++
++ Where "chunk" is the front of the chunk for the purpose of most of
++ the malloc code, but "mem" is the pointer that is returned to the
++ user. "Nextchunk" is the beginning of the next contiguous chunk.
++
++ Chunks always begin on even word boundaries, so the mem portion
++ (which is returned to the user) is also on an even word boundary, and
++ thus at least double-word aligned.
++
++ Free chunks are stored in circular doubly-linked lists, and look like this:
++
++ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of previous chunk |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ `head:' | Size of chunk, in bytes |P|
++ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Forward pointer to next chunk in list |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Back pointer to previous chunk in list |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Unused space (may be 0 bytes long) .
++ . .
++ . |
++nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ `foot:' | Size of chunk, in bytes |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++
++ The P (PREV_INUSE) bit, stored in the unused low-order bit of the
++ chunk size (which is always a multiple of two words), is an in-use
++ bit for the *previous* chunk. If that bit is *clear*, then the
++ word before the current chunk size contains the previous chunk
++ size, and can be used to find the front of the previous chunk.
++ The very first chunk allocated always has this bit set,
++ preventing access to non-existent (or non-owned) memory. If
++ prev_inuse is set for any given chunk, then you CANNOT determine
++ the size of the previous chunk, and might even get a memory
++ addressing fault when trying to do so.
++
++ Note that the `foot' of the current chunk is actually represented
++ as the prev_size of the NEXT chunk. This makes it easier to
++ deal with alignments etc but can be very confusing when trying
++ to extend or adapt this code.
++
++ The two exceptions to all this are
++
++ 1. The special chunk `top' doesn't bother using the
++ trailing size field since there is no next contiguous chunk
++ that would have to index off it. After initialization, `top'
++ is forced to always exist. If it would become less than
++ MINSIZE bytes long, it is replenished.
++
++ 2. Chunks allocated via mmap, which have the second-lowest-order
++ bit (IS_MMAPPED) set in their size fields. Because they are
++ allocated one-by-one, each must contain its own trailing size field.
++
++*/
++
++/*
++ ---------- Size and alignment checks and conversions ----------
++*/
++
++/* conversion from malloc headers to user pointers, and back */
++
++#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ))
++#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
++
++/* The smallest possible chunk */
++#define MIN_CHUNK_SIZE (sizeof(struct malloc_chunk))
++
++/* The smallest size we can malloc is an aligned minimal chunk */
++
++#define MINSIZE \
++ (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
++
++/* Check if m has acceptable alignment */
++
++#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
++
++
++/*
++ Check if a request is so large that it would wrap around zero when
++ padded and aligned. To simplify some other code, the bound is made
++ low enough so that adding MINSIZE will also not wrap around zero.
++*/
++
++#define REQUEST_OUT_OF_RANGE(req) \
++ ((unsigned long)(req) >= \
++ (unsigned long)(INTERNAL_SIZE_T)(-2 * MINSIZE))
++
++/* pad request bytes into a usable size -- internal version */
++
++#define request2size(req) \
++ (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \
++ MINSIZE : \
++ ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
++
++/* Same, except also perform argument check */
++
++#define checked_request2size(req, sz) \
++ if (REQUEST_OUT_OF_RANGE(req)) { \
++ MALLOC_FAILURE_ACTION; \
++ return 0; \
++ } \
++ (sz) = request2size(req);
++
++/*
++ --------------- Physical chunk operations ---------------
++*/
++
++
++/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
++#define PREV_INUSE 0x1
++
++/* extract inuse bit of previous chunk */
++#define prev_inuse(p) ((p)->size & PREV_INUSE)
++
++
++/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
++#define IS_MMAPPED 0x2
++
++/* check for mmap()'ed chunk */
++#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
++
++/*
++ Bits to mask off when extracting size
++
++ Note: IS_MMAPPED is intentionally not masked off from size field in
++ macros for which mmapped chunks should never be seen. This should
++ cause helpful core dumps to occur if it is tried by accident by
++ people extending or adapting this malloc.
++*/
++#define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
++
++/* Get size, ignoring use bits */
++#define chunksize(p) ((p)->size & ~(SIZE_BITS))
++
++
++/* Ptr to next physical malloc_chunk. */
++#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
++
++/* Ptr to previous physical malloc_chunk */
++#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
++
++/* Treat space at ptr + offset as a chunk */
++#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
++
++/* extract p's inuse bit */
++#define inuse(p)\
++((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
++
++/* set/clear chunk as being inuse without otherwise disturbing */
++#define set_inuse(p)\
++((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
++
++#define clear_inuse(p)\
++((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
++
++
++/* check/set/clear inuse bits in known places */
++#define inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
++
++#define set_inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
++
++#define clear_inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
++
++
++/* Set size at head, without disturbing its use bit */
++#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s)))
++
++/* Set size/use field */
++#define set_head(p, s) ((p)->size = (s))
++
++/* Set size at footer (only when chunk is not in use) */
++#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
++
++
++/*
++ -------------------- Internal data structures --------------------
++
++ All internal state is held in an instance of malloc_state defined
++ below. There are no other static variables, except in two optional
++ cases:
++ * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
++ * If HAVE_MMAP is true, but mmap doesn't support
++ MAP_ANONYMOUS, a dummy file descriptor for mmap.
++
++ Beware of lots of tricks that minimize the total bookkeeping space
++ requirements. The result is a little over 1K bytes (for 4byte
++ pointers and size_t.)
++*/
++
++/*
++ Bins
++
++ An array of bin headers for free chunks. Each bin is doubly
++ linked. The bins are approximately proportionally (log) spaced.
++ There are a lot of these bins (128). This may look excessive, but
++ works very well in practice. Most bins hold sizes that are
++ unusual as malloc request sizes, but are more usual for fragments
++ and consolidated sets of chunks, which is what these bins hold, so
++ they can be found quickly. All procedures maintain the invariant
++ that no consolidated chunk physically borders another one, so each
++ chunk in a list is known to be preceded and followed by either
++ inuse chunks or the ends of memory.
++
++ Chunks in bins are kept in size order, with ties going to the
++ approximately least recently used chunk. Ordering isn't needed
++ for the small bins, which all contain the same-sized chunks, but
++ facilitates best-fit allocation for larger chunks. These lists
++ are just sequential. Keeping them in order almost never requires
++ enough traversal to warrant using fancier ordered data
++ structures.
++
++ Chunks of the same size are linked with the most
++ recently freed at the front, and allocations are taken from the
++ back. This results in LRU (FIFO) allocation order, which tends
++ to give each chunk an equal opportunity to be consolidated with
++ adjacent freed chunks, resulting in larger free chunks and less
++ fragmentation.
++
++ To simplify use in double-linked lists, each bin header acts
++ as a malloc_chunk. This avoids special-casing for headers.
++ But to conserve space and improve locality, we allocate
++ only the fd/bk pointers of bins, and then use repositioning tricks
++ to treat these as the fields of a malloc_chunk*.
++*/
++
++typedef struct malloc_chunk* mbinptr;
++
++/* addressing -- note that bin_at(0) does not exist */
++#define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1)))
++
++/* analog of ++bin */
++#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
++
++/* Reminders about list directionality within bins */
++#define first(b) ((b)->fd)
++#define last(b) ((b)->bk)
++
++/* Take a chunk off a bin list */
++#define unlink(P, BK, FD) { \
++ FD = P->fd; \
++ BK = P->bk; \
++ FD->bk = BK; \
++ BK->fd = FD; \
++}
++
++/*
++ Indexing
++
++ Bins for sizes < 512 bytes contain chunks of all the same size, spaced
++ 8 bytes apart. Larger bins are approximately logarithmically spaced:
++
++ 64 bins of size 8
++ 32 bins of size 64
++ 16 bins of size 512
++ 8 bins of size 4096
++ 4 bins of size 32768
++ 2 bins of size 262144
++ 1 bin of size what's left
++
++ There is actually a little bit of slop in the numbers in bin_index
++ for the sake of speed. This makes no difference elsewhere.
++
++ The bins top out around 1MB because we expect to service large
++ requests via mmap.
++*/
++
++#define NBINS 128
++#define NSMALLBINS 64
++#define SMALLBIN_WIDTH 8
++#define MIN_LARGE_SIZE 512
++
++#define in_smallbin_range(sz) \
++ ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
++
++#define smallbin_index(sz) (((unsigned)(sz)) >> 3)
++
++#define largebin_index(sz) \
++(((((unsigned long)(sz)) >> 6) <= 32)? 56 + (((unsigned long)(sz)) >> 6): \
++ ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
++ ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
++ ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
++ ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
++ 126)
++
++#define bin_index(sz) \
++ ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
++
++
++/*
++ Unsorted chunks
++
++ All remainders from chunk splits, as well as all returned chunks,
++ are first placed in the "unsorted" bin. They are then placed
++ in regular bins after malloc gives them ONE chance to be used before
++ binning. So, basically, the unsorted_chunks list acts as a queue,
++ with chunks being placed on it in free (and malloc_consolidate),
++ and taken off (to be either used or placed in bins) in malloc.
++*/
++
++/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
++#define unsorted_chunks(M) (bin_at(M, 1))
++
++/*
++ Top
++
++ The top-most available chunk (i.e., the one bordering the end of
++ available memory) is treated specially. It is never included in
++ any bin, is used only if no other chunk is available, and is
++ released back to the system if it is very large (see
++ M_TRIM_THRESHOLD). Because top initially
++ points to its own bin with initial zero size, thus forcing
++ extension on the first malloc request, we avoid having any special
++ code in malloc to check whether it even exists yet. But we still
++ need to do so when getting memory from system, so we make
++ initial_top treat the bin as a legal but unusable chunk during the
++ interval between initialization and the first call to
++ sYSMALLOc. (This is somewhat delicate, since it relies on
++ the 2 preceding words to be zero during this interval as well.)
++*/
++
++/* Conveniently, the unsorted bin can be used as dummy top on first call */
++#define initial_top(M) (unsorted_chunks(M))
++
++/*
++ Binmap
++
++ To help compensate for the large number of bins, a one-level index
++ structure is used for bin-by-bin searching. `binmap' is a
++ bitvector recording whether bins are definitely empty so they can
++ be skipped over during during traversals. The bits are NOT always
++ cleared as soon as bins are empty, but instead only
++ when they are noticed to be empty during traversal in malloc.
++*/
++
++/* Conservatively use 32 bits per map word, even if on 64bit system */
++#define BINMAPSHIFT 5
++#define BITSPERMAP (1U << BINMAPSHIFT)
++#define BINMAPSIZE (NBINS / BITSPERMAP)
++
++#define idx2block(i) ((i) >> BINMAPSHIFT)
++#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
++
++#define mark_bin(m,i) ((m)->binmap[idx2block(i)] |= idx2bit(i))
++#define unmark_bin(m,i) ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
++#define get_binmap(m,i) ((m)->binmap[idx2block(i)] & idx2bit(i))
++
++/*
++ Fastbins
++
++ An array of lists holding recently freed small chunks. Fastbins
++ are not doubly linked. It is faster to single-link them, and
++ since chunks are never removed from the middles of these lists,
++ double linking is not necessary. Also, unlike regular bins, they
++ are not even processed in FIFO order (they use faster LIFO) since
++ ordering doesn't much matter in the transient contexts in which
++ fastbins are normally used.
++
++ Chunks in fastbins keep their inuse bit set, so they cannot
++ be consolidated with other free chunks. malloc_consolidate
++ releases all chunks in fastbins and consolidates them with
++ other free chunks.
++*/
++
++typedef struct malloc_chunk* mfastbinptr;
++
++/* offset 2 to use otherwise unindexable first 2 bins */
++#define fastbin_index(sz) ((((unsigned int)(sz)) >> 3) - 2)
++
++/* The maximum fastbin request size we support */
++#define MAX_FAST_SIZE 80
++
++#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE))+1)
++
++/*
++ FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
++ that triggers automatic consolidation of possibly-surrounding
++ fastbin chunks. This is a heuristic, so the exact value should not
++ matter too much. It is defined at half the default trim threshold as a
++ compromise heuristic to only attempt consolidation if it is likely
++ to lead to trimming. However, it is not dynamically tunable, since
++ consolidation reduces fragmentation surrounding loarge chunks even
++ if trimming is not used.
++*/
++
++#define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL)
++
++/*
++ Since the lowest 2 bits in max_fast don't matter in size comparisons,
++ they are used as flags.
++*/
++
++/*
++ FASTCHUNKS_BIT held in max_fast indicates that there are probably
++ some fastbin chunks. It is set true on entering a chunk into any
++ fastbin, and cleared only in malloc_consolidate.
++
++ The truth value is inverted so that have_fastchunks will be true
++ upon startup (since statics are zero-filled), simplifying
++ initialization checks.
++*/
++
++#define FASTCHUNKS_BIT (1U)
++
++#define have_fastchunks(M) (((M)->max_fast & FASTCHUNKS_BIT) == 0)
++#define clear_fastchunks(M) ((M)->max_fast |= FASTCHUNKS_BIT)
++#define set_fastchunks(M) ((M)->max_fast &= ~FASTCHUNKS_BIT)
++
++/*
++ NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
++ regions. Otherwise, contiguity is exploited in merging together,
++ when possible, results from consecutive MORECORE calls.
++
++ The initial value comes from MORECORE_CONTIGUOUS, but is
++ changed dynamically if mmap is ever used as an sbrk substitute.
++*/
++
++#define NONCONTIGUOUS_BIT (2U)
++
++#define contiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) == 0)
++#define noncontiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) != 0)
++#define set_noncontiguous(M) ((M)->max_fast |= NONCONTIGUOUS_BIT)
++#define set_contiguous(M) ((M)->max_fast &= ~NONCONTIGUOUS_BIT)
++
++/*
++ Set value of max_fast.
++ Use impossibly small value if 0.
++ Precondition: there are no existing fastbin chunks.
++ Setting the value clears fastchunk bit but preserves noncontiguous bit.
++*/
++
++#define set_max_fast(M, s) \
++ (M)->max_fast = (((s) == 0)? SMALLBIN_WIDTH: request2size(s)) | \
++ FASTCHUNKS_BIT | \
++ ((M)->max_fast & NONCONTIGUOUS_BIT)
++
++
++/*
++ ----------- Internal state representation and initialization -----------
++*/
++
++struct malloc_state {
++
++ /* The maximum chunk size to be eligible for fastbin */
++ INTERNAL_SIZE_T max_fast; /* low 2 bits used as flags */
++
++ /* Fastbins */
++ mfastbinptr fastbins[NFASTBINS];
++
++ /* Base of the topmost chunk -- not otherwise kept in a bin */
++ mchunkptr top;
++
++ /* The remainder from the most recent split of a small request */
++ mchunkptr last_remainder;
++
++ /* Normal bins packed as described above */
++ mchunkptr bins[NBINS * 2];
++
++ /* Bitmap of bins */
++ unsigned int binmap[BINMAPSIZE];
++
++ /* Tunable parameters */
++ unsigned long trim_threshold;
++ INTERNAL_SIZE_T top_pad;
++ INTERNAL_SIZE_T mmap_threshold;
++
++ /* Memory map support */
++ int n_mmaps;
++ int n_mmaps_max;
++ int max_n_mmaps;
++
++ /* Cache malloc_getpagesize */
++ unsigned int pagesize;
++
++ /* Statistics */
++ INTERNAL_SIZE_T mmapped_mem;
++ INTERNAL_SIZE_T sbrked_mem;
++ INTERNAL_SIZE_T max_sbrked_mem;
++ INTERNAL_SIZE_T max_mmapped_mem;
++ INTERNAL_SIZE_T max_total_mem;
++};
++
++typedef struct malloc_state *mstate;
++
++/*
++ There is exactly one instance of this struct in this malloc.
++ If you are adapting this malloc in a way that does NOT use a static
++ malloc_state, you MUST explicitly zero-fill it before using. This
++ malloc relies on the property that malloc_state is initialized to
++ all zeroes (as is true of C statics).
++*/
++
++static struct malloc_state av_; /* never directly referenced */
++
++/*
++ All uses of av_ are via get_malloc_state().
++ At most one "call" to get_malloc_state is made per invocation of
++ the public versions of malloc and free, but other routines
++ that in turn invoke malloc and/or free may call more then once.
++ Also, it is called in check* routines if DEBUG is set.
++*/
++
++#define get_malloc_state() (&(av_))
++
++/*
++ Initialize a malloc_state struct.
++
++ This is called only from within malloc_consolidate, which needs
++ be called in the same contexts anyway. It is never called directly
++ outside of malloc_consolidate because some optimizing compilers try
++ to inline it at all call points, which turns out not to be an
++ optimization at all. (Inlining it in malloc_consolidate is fine though.)
++*/
++
++#if __STD_C
++static void malloc_init_state(mstate av)
++#else
++static void malloc_init_state(av) mstate av;
++#endif
++{
++ int i;
++ mbinptr bin;
++
++ /* Establish circular links for normal bins */
++ for (i = 1; i < NBINS; ++i) {
++ bin = bin_at(av,i);
++ bin->fd = bin->bk = bin;
++ }
++
++ av->top_pad = DEFAULT_TOP_PAD;
++ av->n_mmaps_max = DEFAULT_MMAP_MAX;
++ av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
++ av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
++
++#if !MORECORE_CONTIGUOUS
++ set_noncontiguous(av);
++#endif
++
++ set_max_fast(av, DEFAULT_MXFAST);
++
++ av->top = initial_top(av);
++ av->pagesize = malloc_getpagesize;
++}
++
++/*
++ Other internal utilities operating on mstates
++*/
++
++#if __STD_C
++static Void_t* sYSMALLOc(INTERNAL_SIZE_T, mstate);
++static int sYSTRIm(size_t, mstate);
++static void malloc_consolidate(mstate);
++static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
++#else
++static Void_t* sYSMALLOc();
++static int sYSTRIm();
++static void malloc_consolidate();
++static Void_t** iALLOc();
++#endif
++
++/*
++ Debugging support
++
++ These routines make a number of assertions about the states
++ of data structures that should be true at all times. If any
++ are not true, it's very likely that a user program has somehow
++ trashed memory. (It's also possible that there is a coding error
++ in malloc. In which case, please report it!)
++*/
++
++#ifndef DEBUG
++
++#define check_chunk(P)
++#define check_free_chunk(P)
++#define check_inuse_chunk(P)
++#define check_remalloced_chunk(P,N)
++#define check_malloced_chunk(P,N)
++#define check_malloc_state()
++
++#else
++#define check_chunk(P) do_check_chunk(P)
++#define check_free_chunk(P) do_check_free_chunk(P)
++#define check_inuse_chunk(P) do_check_inuse_chunk(P)
++#define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N)
++#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
++#define check_malloc_state() do_check_malloc_state()
++
++/*
++ Properties of all chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_chunk(mchunkptr p)
++#else
++static void do_check_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++ unsigned long sz = chunksize(p);
++ /* min and max possible addresses assuming contiguous allocation */
++ char* max_address = (char*)(av->top) + chunksize(av->top);
++ char* min_address = max_address - av->sbrked_mem;
++
++ if (!chunk_is_mmapped(p)) {
++
++ /* Has legal address ... */
++ if (p != av->top) {
++ if (contiguous(av)) {
++ assert(((char*)p) >= min_address);
++ assert(((char*)p + sz) <= ((char*)(av->top)));
++ }
++ }
++ else {
++ /* top size is always at least MINSIZE */
++ assert((unsigned long)(sz) >= MINSIZE);
++ /* top predecessor always marked inuse */
++ assert(prev_inuse(p));
++ }
++
++ }
++ else {
++#if HAVE_MMAP
++ /* address is outside main heap */
++ if (contiguous(av) && av->top != initial_top(av)) {
++ assert(((char*)p) < min_address || ((char*)p) > max_address);
++ }
++ /* chunk is page-aligned */
++ assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
++ /* mem is aligned */
++ assert(aligned_OK(chunk2mem(p)));
++#else
++ /* force an appropriate assert violation if debug set */
++ assert(!chunk_is_mmapped(p));
++#endif
++ }
++}
++
++/*
++ Properties of free chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_free_chunk(mchunkptr p)
++#else
++static void do_check_free_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
++ mchunkptr next = chunk_at_offset(p, sz);
++
++ do_check_chunk(p);
++
++ /* Chunk must claim to be free ... */
++ assert(!inuse(p));
++ assert (!chunk_is_mmapped(p));
++
++ /* Unless a special marker, must have OK fields */
++ if ((unsigned long)(sz) >= MINSIZE)
++ {
++ assert((sz & MALLOC_ALIGN_MASK) == 0);
++ assert(aligned_OK(chunk2mem(p)));
++ /* ... matching footer field */
++ assert(next->prev_size == sz);
++ /* ... and is fully consolidated */
++ assert(prev_inuse(p));
++ assert (next == av->top || inuse(next));
++
++ /* ... and has minimally sane links */
++ assert(p->fd->bk == p);
++ assert(p->bk->fd == p);
++ }
++ else /* markers are always of size SIZE_SZ */
++ assert(sz == SIZE_SZ);
++}
++
++/*
++ Properties of inuse chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_inuse_chunk(mchunkptr p)
++#else
++static void do_check_inuse_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++ mchunkptr next;
++ do_check_chunk(p);
++
++ if (chunk_is_mmapped(p))
++ return; /* mmapped chunks have no next/prev */
++
++ /* Check whether it claims to be in use ... */
++ assert(inuse(p));
++
++ next = next_chunk(p);
++
++ /* ... and is surrounded by OK chunks.
++ Since more things can be checked with free chunks than inuse ones,
++ if an inuse chunk borders them and debug is on, it's worth doing them.
++ */
++ if (!prev_inuse(p)) {
++ /* Note that we cannot even look at prev unless it is not inuse */
++ mchunkptr prv = prev_chunk(p);
++ assert(next_chunk(prv) == p);
++ do_check_free_chunk(prv);
++ }
++
++ if (next == av->top) {
++ assert(prev_inuse(next));
++ assert(chunksize(next) >= MINSIZE);
++ }
++ else if (!inuse(next))
++ do_check_free_chunk(next);
++}
++
++/*
++ Properties of chunks recycled from fastbins
++*/
++
++INLINE
++#if __STD_C
++static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
++#else
++static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
++#endif
++{
++ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
++
++ do_check_inuse_chunk(p);
++
++ /* Legal size ... */
++ assert((sz & MALLOC_ALIGN_MASK) == 0);
++ assert((unsigned long)(sz) >= MINSIZE);
++ /* ... and alignment */
++ assert(aligned_OK(chunk2mem(p)));
++ /* chunk is less than MINSIZE more than request */
++ assert((long)(sz) - (long)(s) >= 0);
++ assert((long)(sz) - (long)(s + MINSIZE) < 0);
++}
++
++/*
++ Properties of nonrecycled chunks at the point they are malloced
++*/
++
++INLINE
++#if __STD_C
++static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
++#else
++static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
++#endif
++{
++ /* same as recycled case ... */
++ do_check_remalloced_chunk(p, s);
++
++ /*
++ ... plus, must obey implementation invariant that prev_inuse is
++ always true of any allocated chunk; i.e., that each allocated
++ chunk borders either a previously allocated and still in-use
++ chunk, or the base of its memory arena. This is ensured
++ by making all allocations from the the `lowest' part of any found
++ chunk. This does not necessarily hold however for chunks
++ recycled via fastbins.
++ */
++
++ assert(prev_inuse(p));
++}
++
++
++/*
++ Properties of malloc_state.
++
++ This may be useful for debugging malloc, as well as detecting user
++ programmer errors that somehow write into malloc_state.
++
++ If you are extending or experimenting with this malloc, you can
++ probably figure out how to hack this routine to print out or
++ display chunk addresses, sizes, bins, and other instrumentation.
++*/
++
++static void do_check_malloc_state()
++{
++ mstate av = get_malloc_state();
++ int i;
++ mchunkptr p;
++ mchunkptr q;
++ mbinptr b;
++ unsigned int binbit;
++ int empty;
++ unsigned int idx;
++ INTERNAL_SIZE_T size;
++ unsigned long total = 0;
++ int max_fast_bin;
++
++ /* internal size_t must be no wider than pointer type */
++ assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*));
++
++ /* alignment is a power of 2 */
++ assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0);
++
++ /* cannot run remaining checks until fully initialized */
++ if (av->top == 0 || av->top == initial_top(av))
++ return;
++
++ /* pagesize is a power of 2 */
++ assert((av->pagesize & (av->pagesize-1)) == 0);
++
++ /* properties of fastbins */
++
++ /* max_fast is in allowed range */
++ assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE));
++
++ max_fast_bin = fastbin_index(av->max_fast);
++
++ for (i = 0; i < NFASTBINS; ++i) {
++ p = av->fastbins[i];
++
++ /* all bins past max_fast are empty */
++ if (i > max_fast_bin)
++ assert(p == 0);
++
++ while (p != 0) {
++ /* each chunk claims to be inuse */
++ do_check_inuse_chunk(p);
++ total += chunksize(p);
++ /* chunk belongs in this bin */
++ assert(fastbin_index(chunksize(p)) == i);
++ p = p->fd;
++ }
++ }
++
++ if (total != 0)
++ assert(have_fastchunks(av));
++ else if (!have_fastchunks(av))
++ assert(total == 0);
++
++ /* check normal bins */
++ for (i = 1; i < NBINS; ++i) {
++ b = bin_at(av,i);
++
++ /* binmap is accurate (except for bin 1 == unsorted_chunks) */
++ if (i >= 2) {
++ binbit = get_binmap(av,i);
++ empty = last(b) == b;
++ if (!binbit)
++ assert(empty);
++ else if (!empty)
++ assert(binbit);
++ }
++
++ for (p = last(b); p != b; p = p->bk) {
++ /* each chunk claims to be free */
++ do_check_free_chunk(p);
++ size = chunksize(p);
++ total += size;
++ if (i >= 2) {
++ /* chunk belongs in bin */
++ idx = bin_index(size);
++ assert(idx == i);
++ /* lists are sorted */
++ assert(p->bk == b ||
++ (unsigned long)chunksize(p->bk) >= (unsigned long)chunksize(p));
++ }
++ /* chunk is followed by a legal chain of inuse chunks */
++ for (q = next_chunk(p);
++ (q != av->top && inuse(q) &&
++ (unsigned long)(chunksize(q)) >= MINSIZE);
++ q = next_chunk(q))
++ do_check_inuse_chunk(q);
++ }
++ }
++
++ /* top chunk is OK */
++ check_chunk(av->top);
++
++ /* sanity checks for statistics */
++
++ assert(total <= (unsigned long)(av->max_total_mem));
++ assert(av->n_mmaps >= 0);
++ assert(av->n_mmaps <= av->n_mmaps_max);
++ assert(av->n_mmaps <= av->max_n_mmaps);
++
++ assert((unsigned long)(av->sbrked_mem) <=
++ (unsigned long)(av->max_sbrked_mem));
++
++ assert((unsigned long)(av->mmapped_mem) <=
++ (unsigned long)(av->max_mmapped_mem));
++
++ assert((unsigned long)(av->max_total_mem) >=
++ (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
++}
++#endif
++
++
++/* ----------- Routines dealing with system allocation -------------- */
++
++/*
++ sYSTRIm is an inverse of sorts to sYSMALLOc. It gives memory back
++ to the system (via negative arguments to sbrk) if there is unused
++ memory at the `high' end of the malloc pool. It is called
++ automatically by free() when top space exceeds the trim
++ threshold. It is also called by the public malloc_trim routine. It
++ returns 1 if it actually released any memory, else 0.
++*/
++
++INLINE
++#if __STD_C
++static int sYSTRIm(size_t pad, mstate av)
++#else
++static int sYSTRIm(pad, av) size_t pad; mstate av;
++#endif
++{
++ long top_size; /* Amount of top-most memory */
++ long extra; /* Amount to release */
++ long released; /* Amount actually released */
++ char* current_brk; /* address returned by pre-check sbrk call */
++ char* new_brk; /* address returned by post-check sbrk call */
++ size_t pagesz;
++
++ pagesz = av->pagesize;
++ top_size = chunksize(av->top);
++
++ /* Release in pagesize units, keeping at least one page */
++ extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
++
++ if (extra > 0) {
++
++ /*
++ Only proceed if end of memory is where we last set it.
++ This avoids problems if there were foreign sbrk calls.
++ */
++ current_brk = (char*)(MORECORE(0));
++ if (current_brk == (char*)(av->top) + top_size) {
++
++ /*
++ Attempt to release memory. We ignore MORECORE return value,
++ and instead call again to find out where new end of memory is.
++ This avoids problems if first call releases less than we asked,
++ of if failure somehow altered brk value. (We could still
++ encounter problems if it altered brk in some very bad way,
++ but the only thing we can do is adjust anyway, which will cause
++ some downstream failure.)
++ */
++
++ MORECORE(-extra);
++ new_brk = (char*)(MORECORE(0));
++
++ if (new_brk != (char*)MORECORE_FAILURE) {
++ released = (long)(current_brk - new_brk);
++
++ if (released != 0) {
++ /* Success. Adjust top. */
++ av->sbrked_mem -= released;
++ set_head(av->top, (top_size - released) | PREV_INUSE);
++ check_malloc_state();
++ return 1;
++ }
++ }
++ }
++ }
++ return 0;
++}
++
++/*
++ ------------------------- malloc_consolidate -------------------------
++
++ malloc_consolidate is a specialized version of free() that tears
++ down chunks held in fastbins. Free itself cannot be used for this
++ purpose since, among other things, it might place chunks back onto
++ fastbins. So, instead, we need to use a minor variant of the same
++ code.
++
++ Also, because this routine needs to be called the first time through
++ malloc anyway, it turns out to be the perfect place to trigger
++ initialization code.
++*/
++
++INLINE
++#if __STD_C
++static void malloc_consolidate(mstate av)
++#else
++static void malloc_consolidate(av) mstate av;
++#endif
++{
++ mfastbinptr* fb; /* current fastbin being consolidated */
++ mfastbinptr* maxfb; /* last fastbin (for loop control) */
++ mchunkptr p; /* current chunk being consolidated */
++ mchunkptr nextp; /* next chunk to consolidate */
++ mchunkptr unsorted_bin; /* bin header */
++ mchunkptr first_unsorted; /* chunk to link to */
++
++ /* These have same use as in free() */
++ mchunkptr nextchunk;
++ INTERNAL_SIZE_T size;
++ INTERNAL_SIZE_T nextsize;
++ INTERNAL_SIZE_T prevsize;
++ int nextinuse;
++ mchunkptr bck;
++ mchunkptr fwd;
++
++ /*
++ If max_fast is 0, we know that av hasn't
++ yet been initialized, in which case do so below
++ */
++
++ if (av->max_fast != 0) {
++ clear_fastchunks(av);
++
++ unsorted_bin = unsorted_chunks(av);
++
++ /*
++ Remove each chunk from fast bin and consolidate it, placing it
++ then in unsorted bin. Among other reasons for doing this,
++ placing in unsorted bin avoids needing to calculate actual bins
++ until malloc is sure that chunks aren't immediately going to be
++ reused anyway.
++ */
++
++ maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
++ fb = &(av->fastbins[0]);
++ do {
++ if ( (p = *fb) != 0) {
++ *fb = 0;
++
++ do {
++ check_inuse_chunk(p);
++ nextp = p->fd;
++
++ /* Slightly streamlined version of consolidation code in free() */
++ size = p->size & ~PREV_INUSE;
++ nextchunk = chunk_at_offset(p, size);
++ nextsize = chunksize(nextchunk);
++
++ if (!prev_inuse(p)) {
++ prevsize = p->prev_size;
++ size += prevsize;
++ p = chunk_at_offset(p, -((long) prevsize));
++ unlink(p, bck, fwd);
++ }
++
++ if (nextchunk != av->top) {
++ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
++ set_head(nextchunk, nextsize);
++
++ if (!nextinuse) {
++ size += nextsize;
++ unlink(nextchunk, bck, fwd);
++ }
++
++ first_unsorted = unsorted_bin->fd;
++ unsorted_bin->fd = p;
++ first_unsorted->bk = p;
++
++ set_head(p, size | PREV_INUSE);
++ p->bk = unsorted_bin;
++ p->fd = first_unsorted;
++ set_foot(p, size);
++ }
++
++ else {
++ size += nextsize;
++ set_head(p, size | PREV_INUSE);
++ av->top = p;
++ }
++
++ } while ( (p = nextp) != 0);
++
++ }
++ } while (fb++ != maxfb);
++ }
++ else {
++ malloc_init_state(av);
++ check_malloc_state();
++ }
++}
++
++/*
++ ------------------------------ free ------------------------------
++*/
++
++INLINE
++#if __STD_C
++void fREe(Void_t* mem)
++#else
++void fREe(mem) Void_t* mem;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ mchunkptr p; /* chunk corresponding to mem */
++ INTERNAL_SIZE_T size; /* its size */
++ mfastbinptr* fb; /* associated fastbin */
++ mchunkptr nextchunk; /* next contiguous chunk */
++ INTERNAL_SIZE_T nextsize; /* its size */
++ int nextinuse; /* true if nextchunk is used */
++ INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
++ mchunkptr bck; /* misc temp for linking */
++ mchunkptr fwd; /* misc temp for linking */
++
++
++ /* free(0) has no effect */
++ if (mem != 0) {
++ p = mem2chunk(mem);
++ size = chunksize(p);
++
++ check_inuse_chunk(p);
++
++ /*
++ If eligible, place chunk on a fastbin so it can be found
++ and used quickly in malloc.
++ */
++
++ if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
++
++#if TRIM_FASTBINS
++ /*
++ If TRIM_FASTBINS set, don't place chunks
++ bordering top into fastbins
++ */
++ && (chunk_at_offset(p, size) != av->top)
++#endif
++ ) {
++
++ set_fastchunks(av);
++ fb = &(av->fastbins[fastbin_index(size)]);
++ p->fd = *fb;
++ *fb = p;
++ }
++
++ /*
++ Consolidate other non-mmapped chunks as they arrive.
++ */
++
++ else if (!chunk_is_mmapped(p)) {
++ nextchunk = chunk_at_offset(p, size);
++ nextsize = chunksize(nextchunk);
++
++ /* consolidate backward */
++ if (!prev_inuse(p)) {
++ prevsize = p->prev_size;
++ size += prevsize;
++ p = chunk_at_offset(p, -((long) prevsize));
++ unlink(p, bck, fwd);
++ }
++
++ if (nextchunk != av->top) {
++ /* get and clear inuse bit */
++ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
++ set_head(nextchunk, nextsize);
++
++ /* consolidate forward */
++ if (!nextinuse) {
++ unlink(nextchunk, bck, fwd);
++ size += nextsize;
++ }
++
++ /*
++ Place the chunk in unsorted chunk list. Chunks are
++ not placed into regular bins until after they have
++ been given one chance to be used in malloc.
++ */
++
++ bck = unsorted_chunks(av);
++ fwd = bck->fd;
++ p->bk = bck;
++ p->fd = fwd;
++ bck->fd = p;
++ fwd->bk = p;
++
++ set_head(p, size | PREV_INUSE);
++ set_foot(p, size);
++
++ check_free_chunk(p);
++ }
++
++ /*
++ If the chunk borders the current high end of memory,
++ consolidate into top
++ */
++
++ else {
++ size += nextsize;
++ set_head(p, size | PREV_INUSE);
++ av->top = p;
++ check_chunk(p);
++ }
++
++ /*
++ If freeing a large space, consolidate possibly-surrounding
++ chunks. Then, if the total unused topmost memory exceeds trim
++ threshold, ask malloc_trim to reduce top.
++
++ Unless max_fast is 0, we don't know if there are fastbins
++ bordering top, so we cannot tell for sure whether threshold
++ has been reached unless fastbins are consolidated. But we
++ don't want to consolidate on each free. As a compromise,
++ consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
++ is reached.
++ */
++
++ if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
++ if (have_fastchunks(av))
++ malloc_consolidate(av);
++
++#ifndef MORECORE_CANNOT_TRIM
++ if ((unsigned long)(chunksize(av->top)) >=
++ (unsigned long)(av->trim_threshold))
++ sYSTRIm(av->top_pad, av);
++#endif
++ }
++
++ }
++ /*
++ If the chunk was allocated via mmap, release via munmap()
++ Note that if HAVE_MMAP is false but chunk_is_mmapped is
++ true, then user must have overwritten memory. There's nothing
++ we can do to catch this error unless DEBUG is set, in which case
++ check_inuse_chunk (above) will have triggered error.
++ */
++
++ else {
++#if HAVE_MMAP
++ int ret;
++ INTERNAL_SIZE_T offset = p->prev_size;
++ av->n_mmaps--;
++ av->mmapped_mem -= (size + offset);
++ ret = munmap((char*)p - offset, size + offset);
++ /* munmap returns non-zero on failure */
++ assert(ret == 0);
++#endif
++ }
++ }
++}
++
++/*
++ sysmalloc handles malloc cases requiring more memory from the system.
++ On entry, it is assumed that av->top does not have enough
++ space to service request for nb bytes, thus requiring that av->top
++ be extended or replaced.
++*/
++
++INLINE
++#if __STD_C
++static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
++#else
++static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
++#endif
++{
++ mchunkptr old_top; /* incoming value of av->top */
++ INTERNAL_SIZE_T old_size; /* its size */
++ char* old_end; /* its end address */
++
++ long size; /* arg to first MORECORE or mmap call */
++ char* brk; /* return value from MORECORE */
++
++ long correction; /* arg to 2nd MORECORE call */
++ char* snd_brk; /* 2nd return val */
++
++ INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
++ INTERNAL_SIZE_T end_misalign; /* partial page left at end of new space */
++ char* aligned_brk; /* aligned offset into brk */
++
++ mchunkptr p; /* the allocated/returned chunk */
++ mchunkptr remainder; /* remainder from allocation */
++ unsigned long remainder_size; /* its size */
++
++ unsigned long sum; /* for updating stats */
++
++ size_t pagemask = av->pagesize - 1;
++
++
++#if HAVE_MMAP
++
++ /*
++ If have mmap, and the request size meets the mmap threshold, and
++ the system supports mmap, and there are few enough currently
++ allocated mmapped regions, try to directly map this request
++ rather than expanding top.
++ */
++
++ if ((unsigned long)(nb) >= (unsigned long)(av->mmap_threshold) &&
++ (av->n_mmaps < av->n_mmaps_max)) {
++
++ char* mm; /* return value from mmap call*/
++
++ /*
++ Round up size to nearest page. For mmapped chunks, the overhead
++ is one SIZE_SZ unit larger than for normal chunks, because there
++ is no following chunk whose prev_size field could be used.
++ */
++ size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
++
++ /* Don't try if size wraps around 0 */
++ if ((unsigned long)(size) > (unsigned long)(nb)) {
++
++ mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
++
++ if (mm != (char*)(MORECORE_FAILURE)) {
++
++ /*
++ The offset to the start of the mmapped region is stored
++ in the prev_size field of the chunk. This allows us to adjust
++ returned start address to meet alignment requirements here
++ and in memalign(), and still be able to compute proper
++ address argument for later munmap in free() and realloc().
++ */
++
++ front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK;
++ if (front_misalign > 0) {
++ correction = MALLOC_ALIGNMENT - front_misalign;
++ p = (mchunkptr)(mm + correction);
++ p->prev_size = correction;
++ set_head(p, (size - correction) |IS_MMAPPED);
++ }
++ else {
++ p = (mchunkptr)mm;
++ p->prev_size = 0;
++ set_head(p, size|IS_MMAPPED);
++ }
++
++ /* update statistics */
++
++ if (++av->n_mmaps > av->max_n_mmaps)
++ av->max_n_mmaps = av->n_mmaps;
++
++ sum = av->mmapped_mem += size;
++ if (sum > (unsigned long)(av->max_mmapped_mem))
++ av->max_mmapped_mem = sum;
++ sum += av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ check_chunk(p);
++
++ return chunk2mem(p);
++ }
++ }
++ }
++#endif
++
++ /* Record incoming configuration of top */
++
++ old_top = av->top;
++ old_size = chunksize(old_top);
++ old_end = (char*)(chunk_at_offset(old_top, old_size));
++
++ brk = snd_brk = (char*)(MORECORE_FAILURE);
++
++ /*
++ If not the first time through, we require old_size to be
++ at least MINSIZE and to have prev_inuse set.
++ */
++
++ assert((old_top == initial_top(av) && old_size == 0) ||
++ ((unsigned long) (old_size) >= MINSIZE &&
++ prev_inuse(old_top)));
++
++ /* Precondition: not enough current space to satisfy nb request */
++ assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
++
++ /* Precondition: all fastbins are consolidated */
++ assert(!have_fastchunks(av));
++
++
++ /* Request enough space for nb + pad + overhead */
++
++ size = nb + av->top_pad + MINSIZE;
++
++ /*
++ If contiguous, we can subtract out existing space that we hope to
++ combine with new space. We add it back later only if
++ we don't actually get contiguous space.
++ */
++
++ if (contiguous(av))
++ size -= old_size;
++
++ /*
++ Round to a multiple of page size.
++ If MORECORE is not contiguous, this ensures that we only call it
++ with whole-page arguments. And if MORECORE is contiguous and
++ this is not first time through, this preserves page-alignment of
++ previous calls. Otherwise, we correct to page-align below.
++ */
++
++ size = (size + pagemask) & ~pagemask;
++
++ /*
++ Don't try to call MORECORE if argument is so big as to appear
++ negative. Note that since mmap takes size_t arg, it may succeed
++ below even if we cannot call MORECORE.
++ */
++
++ if (size > 0)
++ brk = (char*)(MORECORE(size));
++
++ /*
++ If have mmap, try using it as a backup when MORECORE fails or
++ cannot be used. This is worth doing on systems that have "holes" in
++ address space, so sbrk cannot extend to give contiguous space, but
++ space is available elsewhere. Note that we ignore mmap max count
++ and threshold limits, since the space will not be used as a
++ segregated mmap region.
++ */
++
++#if HAVE_MMAP
++ if (brk == (char*)(MORECORE_FAILURE)) {
++
++ /* Cannot merge with old top, so add its size back in */
++ if (contiguous(av))
++ size = (size + old_size + pagemask) & ~pagemask;
++
++ /* If we are relying on mmap as backup, then use larger units */
++ if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
++ size = MMAP_AS_MORECORE_SIZE;
++
++ /* Don't try if size wraps around 0 */
++ if ((unsigned long)(size) > (unsigned long)(nb)) {
++
++ brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
++
++ if (brk != (char*)(MORECORE_FAILURE)) {
++
++ /* We do not need, and cannot use, another sbrk call to find end */
++ snd_brk = brk + size;
++
++ /*
++ Record that we no longer have a contiguous sbrk region.
++ After the first time mmap is used as backup, we do not
++ ever rely on contiguous space since this could incorrectly
++ bridge regions.
++ */
++ set_noncontiguous(av);
++ }
++ }
++ }
++#endif
++
++ if (brk != (char*)(MORECORE_FAILURE)) {
++ av->sbrked_mem += size;
++
++ /*
++ If MORECORE extends previous space, we can likewise extend top size.
++ */
++
++ if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
++ set_head(old_top, (size + old_size) | PREV_INUSE);
++ }
++
++ /*
++ Otherwise, make adjustments:
++
++ * If the first time through or noncontiguous, we need to call sbrk
++ just to find out where the end of memory lies.
++
++ * We need to ensure that all returned chunks from malloc will meet
++ MALLOC_ALIGNMENT
++
++ * If there was an intervening foreign sbrk, we need to adjust sbrk
++ request size to account for fact that we will not be able to
++ combine new space with existing space in old_top.
++
++ * Almost all systems internally allocate whole pages at a time, in
++ which case we might as well use the whole last page of request.
++ So we allocate enough more memory to hit a page boundary now,
++ which in turn causes future contiguous calls to page-align.
++ */
++
++ else {
++ front_misalign = 0;
++ end_misalign = 0;
++ correction = 0;
++ aligned_brk = brk;
++
++ /* handle contiguous cases */
++ if (contiguous(av)) {
++
++ /* Guarantee alignment of first new chunk made from this space */
++
++ front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
++ if (front_misalign > 0) {
++
++ /*
++ Skip over some bytes to arrive at an aligned position.
++ We don't need to specially mark these wasted front bytes.
++ They will never be accessed anyway because
++ prev_inuse of av->top (and any chunk created from its start)
++ is always true after initialization.
++ */
++
++ correction = MALLOC_ALIGNMENT - front_misalign;
++ aligned_brk += correction;
++ }
++
++ /*
++ If this isn't adjacent to existing space, then we will not
++ be able to merge with old_top space, so must add to 2nd request.
++ */
++
++ correction += old_size;
++
++ /* Extend the end address to hit a page boundary */
++ end_misalign = (INTERNAL_SIZE_T)(brk + size + correction);
++ correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
++
++ assert(correction >= 0);
++ snd_brk = (char*)(MORECORE(correction));
++
++ /*
++ If can't allocate correction, try to at least find out current
++ brk. It might be enough to proceed without failing.
++
++ Note that if second sbrk did NOT fail, we assume that space
++ is contiguous with first sbrk. This is a safe assumption unless
++ program is multithreaded but doesn't use locks and a foreign sbrk
++ occurred between our first and second calls.
++ */
++
++ if (snd_brk == (char*)(MORECORE_FAILURE)) {
++ correction = 0;
++ snd_brk = (char*)(MORECORE(0));
++ }
++ }
++
++ /* handle non-contiguous cases */
++ else {
++ /* MORECORE/mmap must correctly align */
++ assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
++
++ /* Find out current end of memory */
++ if (snd_brk == (char*)(MORECORE_FAILURE)) {
++ snd_brk = (char*)(MORECORE(0));
++ }
++ }
++
++ /* Adjust top based on results of second sbrk */
++ if (snd_brk != (char*)(MORECORE_FAILURE)) {
++ av->top = (mchunkptr)aligned_brk;
++ set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
++ av->sbrked_mem += correction;
++
++ /*
++ If not the first time through, we either have a
++ gap due to foreign sbrk or a non-contiguous region. Insert a
++ double fencepost at old_top to prevent consolidation with space
++ we don't own. These fenceposts are artificial chunks that are
++ marked as inuse and are in any case too small to use. We need
++ two to make sizes and alignments work out.
++ */
++
++ if (old_size != 0) {
++ /*
++ Shrink old_top to insert fenceposts, keeping size a
++ multiple of MALLOC_ALIGNMENT. We know there is at least
++ enough space in old_top to do this.
++ */
++ old_size = (old_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
++ set_head(old_top, old_size | PREV_INUSE);
++
++ /*
++ Note that the following assignments completely overwrite
++ old_top when old_size was previously MINSIZE. This is
++ intentional. We need the fencepost, even if old_top otherwise gets
++ lost.
++ */
++ chunk_at_offset(old_top, old_size )->size =
++ SIZE_SZ|PREV_INUSE;
++
++ chunk_at_offset(old_top, old_size + SIZE_SZ)->size =
++ SIZE_SZ|PREV_INUSE;
++
++ /* If possible, release the rest. */
++ if (old_size >= MINSIZE) {
++ fREe(chunk2mem(old_top));
++ }
++
++ }
++ }
++ }
++
++ /* Update statistics */
++ sum = av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_sbrked_mem))
++ av->max_sbrked_mem = sum;
++
++ sum += av->mmapped_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ check_malloc_state();
++
++ /* finally, do the allocation */
++ p = av->top;
++ size = chunksize(p);
++
++ /* check that one of the above allocation paths succeeded */
++ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(p, nb);
++ av->top = remainder;
++ set_head(p, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ check_malloced_chunk(p, nb);
++ return chunk2mem(p);
++ }
++ }
++
++ /* catch all failure paths */
++ MALLOC_FAILURE_ACTION;
++ return 0;
++}
++
++
++/*
++ ------------------------------ malloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* mALLOc(size_t bytes)
++#else
++ Void_t* mALLOc(bytes) size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T nb; /* normalized request size */
++ unsigned int idx; /* associated bin index */
++ mbinptr bin; /* associated bin */
++ mfastbinptr* fb; /* associated fastbin */
++
++ mchunkptr victim; /* inspected/selected chunk */
++ INTERNAL_SIZE_T size; /* its size */
++ int victim_index; /* its bin index */
++
++ mchunkptr remainder; /* remainder from a split */
++ unsigned long remainder_size; /* its size */
++
++ unsigned int block; /* bit map traverser */
++ unsigned int bit; /* bit map traverser */
++ unsigned int map; /* current word of binmap */
++
++ mchunkptr fwd; /* misc temp for linking */
++ mchunkptr bck; /* misc temp for linking */
++
++ /*
++ Convert request size to internal form by adding SIZE_SZ bytes
++ overhead plus possibly more to obtain necessary alignment and/or
++ to obtain a size of at least MINSIZE, the smallest allocatable
++ size. Also, checked_request2size traps (returning 0) request sizes
++ that are so large that they wrap around zero when padded and
++ aligned.
++ */
++
++ checked_request2size(bytes, nb);
++
++ /*
++ If the size qualifies as a fastbin, first check corresponding bin.
++ This code is safe to execute even if av is not yet initialized, so we
++ can try it without checking, which saves some time on this fast path.
++ */
++
++ if ((unsigned long)(nb) <= (unsigned long)(av->max_fast)) {
++ fb = &(av->fastbins[(fastbin_index(nb))]);
++ if ( (victim = *fb) != 0) {
++ *fb = victim->fd;
++ check_remalloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++
++ /*
++ If a small request, check regular bin. Since these "smallbins"
++ hold one size each, no searching within bins is necessary.
++ (For a large request, we need to wait until unsorted chunks are
++ processed to find best fit. But for small ones, fits are exact
++ anyway, so we can check now, which is faster.)
++ */
++
++ if (in_smallbin_range(nb)) {
++ idx = smallbin_index(nb);
++ bin = bin_at(av,idx);
++
++ if ( (victim = last(bin)) != bin) {
++ if (victim == 0) /* initialization check */
++ malloc_consolidate(av);
++ else {
++ bck = victim->bk;
++ set_inuse_bit_at_offset(victim, nb);
++ bin->bk = bck;
++ bck->fd = bin;
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ /*
++ If this is a large request, consolidate fastbins before continuing.
++ While it might look excessive to kill all fastbins before
++ even seeing if there is space available, this avoids
++ fragmentation problems normally associated with fastbins.
++ Also, in practice, programs tend to have runs of either small or
++ large requests, but less often mixtures, so consolidation is not
++ invoked all that often in most programs. And the programs that
++ it is called frequently in otherwise tend to fragment.
++ */
++
++ else {
++ idx = largebin_index(nb);
++ if (have_fastchunks(av))
++ malloc_consolidate(av);
++ }
++
++ /*
++ Process recently freed or remaindered chunks, taking one only if
++ it is exact fit, or, if this a small request, the chunk is remainder from
++ the most recent non-exact fit. Place other traversed chunks in
++ bins. Note that this step is the only place in any routine where
++ chunks are placed in bins.
++
++ The outer loop here is needed because we might not realize until
++ near the end of malloc that we should have consolidated, so must
++ do so and retry. This happens at most once, and only when we would
++ otherwise need to expand memory to service a "small" request.
++ */
++
++ for(;;) {
++
++ while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
++ bck = victim->bk;
++ size = chunksize(victim);
++
++ /*
++ If a small request, try to use last remainder if it is the
++ only chunk in unsorted bin. This helps promote locality for
++ runs of consecutive small requests. This is the only
++ exception to best-fit, and applies only when there is
++ no exact fit for a small chunk.
++ */
++
++ if (in_smallbin_range(nb) &&
++ bck == unsorted_chunks(av) &&
++ victim == av->last_remainder &&
++ (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
++
++ /* split and reattach remainder */
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(victim, nb);
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ av->last_remainder = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* remove from unsorted list */
++ unsorted_chunks(av)->bk = bck;
++ bck->fd = unsorted_chunks(av);
++
++ /* Take now instead of binning if exact fit */
++
++ if (size == nb) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* place chunk in bin */
++
++ if (in_smallbin_range(size)) {
++ victim_index = smallbin_index(size);
++ bck = bin_at(av, victim_index);
++ fwd = bck->fd;
++ }
++ else {
++ victim_index = largebin_index(size);
++ bck = bin_at(av, victim_index);
++ fwd = bck->fd;
++
++ /* maintain large bins in sorted order */
++ if (fwd != bck) {
++ size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
++ /* if smaller than smallest, bypass loop below */
++ if ((unsigned long)(size) <= (unsigned long)(bck->bk->size)) {
++ fwd = bck;
++ bck = bck->bk;
++ }
++ else {
++ while ((unsigned long)(size) < (unsigned long)(fwd->size))
++ fwd = fwd->fd;
++ bck = fwd->bk;
++ }
++ }
++ }
++
++ mark_bin(av, victim_index);
++ victim->bk = bck;
++ victim->fd = fwd;
++ fwd->bk = victim;
++ bck->fd = victim;
++ }
++
++ /*
++ If a large request, scan through the chunks of current bin in
++ sorted order to find smallest that fits. This is the only step
++ where an unbounded number of chunks might be scanned without doing
++ anything useful with them. However the lists tend to be short.
++ */
++
++ if (!in_smallbin_range(nb)) {
++ bin = bin_at(av, idx);
++
++ /* skip scan if empty or largest chunk is too small */
++ if ((victim = last(bin)) != bin &&
++ (unsigned long)(first(bin)->size) >= (unsigned long)(nb)) {
++
++ while (((unsigned long)(size = chunksize(victim)) <
++ (unsigned long)(nb)))
++ victim = victim->bk;
++
++ remainder_size = size - nb;
++ unlink(victim, bck, fwd);
++
++ /* Exhaust */
++ if (remainder_size < MINSIZE) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ /* Split */
++ else {
++ remainder = chunk_at_offset(victim, nb);
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ /*
++ Search for a chunk by scanning bins, starting with next largest
++ bin. This search is strictly by best-fit; i.e., the smallest
++ (with ties going to approximately the least recently used) chunk
++ that fits is selected.
++
++ The bitmap avoids needing to check that most blocks are nonempty.
++ The particular case of skipping all bins during warm-up phases
++ when no chunks have been returned yet is faster than it might look.
++ */
++
++ ++idx;
++ bin = bin_at(av,idx);
++ block = idx2block(idx);
++ map = av->binmap[block];
++ bit = idx2bit(idx);
++
++ for (;;) {
++
++ /* Skip rest of block if there are no more set bits in this block. */
++ if (bit > map || bit == 0) {
++ do {
++ if (++block >= BINMAPSIZE) /* out of bins */
++ goto use_top;
++ } while ( (map = av->binmap[block]) == 0);
++
++ bin = bin_at(av, (block << BINMAPSHIFT));
++ bit = 1;
++ }
++
++ /* Advance to bin with set bit. There must be one. */
++ while ((bit & map) == 0) {
++ bin = next_bin(bin);
++ bit <<= 1;
++ assert(bit != 0);
++ }
++
++ /* Inspect the bin. It is likely to be non-empty */
++ victim = last(bin);
++
++ /* If a false alarm (empty bin), clear the bit. */
++ if (victim == bin) {
++ av->binmap[block] = map &= ~bit; /* Write through */
++ bin = next_bin(bin);
++ bit <<= 1;
++ }
++
++ else {
++ size = chunksize(victim);
++
++ /* We know the first chunk in this bin is big enough to use. */
++ assert((unsigned long)(size) >= (unsigned long)(nb));
++
++ remainder_size = size - nb;
++
++ /* unlink */
++ bck = victim->bk;
++ bin->bk = bck;
++ bck->fd = bin;
++
++ /* Exhaust */
++ if (remainder_size < MINSIZE) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* Split */
++ else {
++ remainder = chunk_at_offset(victim, nb);
++
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++ /* advertise as last remainder */
++ if (in_smallbin_range(nb))
++ av->last_remainder = remainder;
++
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ use_top:
++ /*
++ If large enough, split off the chunk bordering the end of memory
++ (held in av->top). Note that this is in accord with the best-fit
++ search rule. In effect, av->top is treated as larger (and thus
++ less well fitting) than any other available chunk since it can
++ be extended to be as large as necessary (up to system
++ limitations).
++
++ We require that av->top always exists (i.e., has size >=
++ MINSIZE) after initialization, so if it would otherwise be
++ exhuasted by current request, it is replenished. (The main
++ reason for ensuring it exists is that we may need MINSIZE space
++ to put in fenceposts in sysmalloc.)
++ */
++
++ victim = av->top;
++ size = chunksize(victim);
++
++ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(victim, nb);
++ av->top = remainder;
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /*
++ If there is space available in fastbins, consolidate and retry,
++ to possibly avoid expanding memory. This can occur only if nb is
++ in smallbin range so we didn't consolidate upon entry.
++ */
++
++ else if (have_fastchunks(av)) {
++ assert(in_smallbin_range(nb));
++ malloc_consolidate(av);
++ idx = smallbin_index(nb); /* restore original bin index */
++ }
++
++ /*
++ Otherwise, relay to handle system-dependent cases
++ */
++ else
++ return sYSMALLOc(nb, av);
++ }
++}
++
++/*
++ ------------------------------ realloc ------------------------------
++*/
++
++
++INLINE
++#if __STD_C
++Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
++#else
++Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T nb; /* padded request size */
++
++ mchunkptr oldp; /* chunk corresponding to oldmem */
++ INTERNAL_SIZE_T oldsize; /* its size */
++
++ mchunkptr newp; /* chunk to return */
++ INTERNAL_SIZE_T newsize; /* its size */
++ Void_t* newmem; /* corresponding user mem */
++
++ mchunkptr next; /* next contiguous chunk after oldp */
++
++ mchunkptr remainder; /* extra space at end of newp */
++ unsigned long remainder_size; /* its size */
++
++ mchunkptr bck; /* misc temp for linking */
++ mchunkptr fwd; /* misc temp for linking */
++
++ unsigned long copysize; /* bytes to copy */
++ unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
++ INTERNAL_SIZE_T* s; /* copy source */
++ INTERNAL_SIZE_T* d; /* copy destination */
++
++
++#ifdef REALLOC_ZERO_BYTES_FREES
++ if (bytes == 0) {
++ fREe(oldmem);
++ return 0;
++ }
++#endif
++
++ /* realloc of null is supposed to be same as malloc */
++ if (oldmem == 0) return mALLOc(bytes);
++
++ checked_request2size(bytes, nb);
++
++ oldp = mem2chunk(oldmem);
++ oldsize = chunksize(oldp);
++
++ check_inuse_chunk(oldp);
++
++ if (!chunk_is_mmapped(oldp)) {
++
++ if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
++ /* already big enough; split below */
++ newp = oldp;
++ newsize = oldsize;
++ }
++
++ else {
++ next = chunk_at_offset(oldp, oldsize);
++
++ /* Try to expand forward into top */
++ if (next == av->top &&
++ (unsigned long)(newsize = oldsize + chunksize(next)) >=
++ (unsigned long)(nb + MINSIZE)) {
++ set_head_size(oldp, nb);
++ av->top = chunk_at_offset(oldp, nb);
++ set_head(av->top, (newsize - nb) | PREV_INUSE);
++ return chunk2mem(oldp);
++ }
++
++ /* Try to expand forward into next chunk; split off remainder below */
++ else if (next != av->top &&
++ !inuse(next) &&
++ (unsigned long)(newsize = oldsize + chunksize(next)) >=
++ (unsigned long)(nb)) {
++ newp = oldp;
++ unlink(next, bck, fwd);
++ }
++
++ /* allocate, copy, free */
++ else {
++ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
++ if (newmem == 0)
++ return 0; /* propagate failure */
++
++ newp = mem2chunk(newmem);
++ newsize = chunksize(newp);
++
++ /*
++ Avoid copy if newp is next chunk after oldp.
++ */
++ if (newp == next) {
++ newsize += oldsize;
++ newp = oldp;
++ }
++ else {
++ /*
++ Unroll copy of <= 36 bytes (72 if 8byte sizes)
++ We know that contents have an odd number of
++ INTERNAL_SIZE_T-sized words; minimally 3.
++ */
++
++ copysize = oldsize - SIZE_SZ;
++ s = (INTERNAL_SIZE_T*)(oldmem);
++ d = (INTERNAL_SIZE_T*)(newmem);
++ ncopies = copysize / sizeof(INTERNAL_SIZE_T);
++ assert(ncopies >= 3);
++
++ if (ncopies > 9)
++ MALLOC_COPY(d, s, copysize);
++
++ else {
++ *(d+0) = *(s+0);
++ *(d+1) = *(s+1);
++ *(d+2) = *(s+2);
++ if (ncopies > 4) {
++ *(d+3) = *(s+3);
++ *(d+4) = *(s+4);
++ if (ncopies > 6) {
++ *(d+5) = *(s+5);
++ *(d+6) = *(s+6);
++ if (ncopies > 8) {
++ *(d+7) = *(s+7);
++ *(d+8) = *(s+8);
++ }
++ }
++ }
++ }
++
++ fREe(oldmem);
++ check_inuse_chunk(newp);
++ return chunk2mem(newp);
++ }
++ }
++ }
++
++ /* If possible, free extra space in old or extended chunk */
++
++ assert((unsigned long)(newsize) >= (unsigned long)(nb));
++
++ remainder_size = newsize - nb;
++
++ if (remainder_size < MINSIZE) { /* not enough extra to split off */
++ set_head_size(newp, newsize);
++ set_inuse_bit_at_offset(newp, newsize);
++ }
++ else { /* split remainder */
++ remainder = chunk_at_offset(newp, nb);
++ set_head_size(newp, nb);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ /* Mark remainder as inuse so free() won't complain */
++ set_inuse_bit_at_offset(remainder, remainder_size);
++ fREe(chunk2mem(remainder));
++ }
++
++ check_inuse_chunk(newp);
++ return chunk2mem(newp);
++ }
++
++ /*
++ Handle mmap cases
++ */
++
++ else {
++#if HAVE_MMAP
++
++#if HAVE_MREMAP
++ INTERNAL_SIZE_T offset = oldp->prev_size;
++ size_t pagemask = av->pagesize - 1;
++ char *cp;
++ unsigned long sum;
++
++ /* Note the extra SIZE_SZ overhead */
++ newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask;
++
++ /* don't need to remap if still within same page */
++ if (oldsize == newsize - offset)
++ return oldmem;
++
++ cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
++
++ if (cp != (char*)MORECORE_FAILURE) {
++
++ newp = (mchunkptr)(cp + offset);
++ set_head(newp, (newsize - offset)|IS_MMAPPED);
++
++ assert(aligned_OK(chunk2mem(newp)));
++ assert((newp->prev_size == offset));
++
++ /* update statistics */
++ sum = av->mmapped_mem += newsize - oldsize;
++ if (sum > (unsigned long)(av->max_mmapped_mem))
++ av->max_mmapped_mem = sum;
++ sum += av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ return chunk2mem(newp);
++ }
++#endif
++
++ /* Note the extra SIZE_SZ overhead. */
++ if ((unsigned long)(oldsize) >= (unsigned long)(nb + SIZE_SZ))
++ newmem = oldmem; /* do nothing */
++ else {
++ /* Must alloc, copy, free. */
++ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
++ if (newmem != 0) {
++ MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
++ fREe(oldmem);
++ }
++ }
++ return newmem;
++
++#else
++ /* If !HAVE_MMAP, but chunk_is_mmapped, user must have overwritten mem */
++ check_malloc_state();
++ MALLOC_FAILURE_ACTION;
++ return 0;
++#endif
++ }
++}
++
++/*
++ ------------------------------ memalign ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* mEMALIGn(size_t alignment, size_t bytes)
++#else
++Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
++#endif
++{
++ INTERNAL_SIZE_T nb; /* padded request size */
++ char* m; /* memory returned by malloc call */
++ mchunkptr p; /* corresponding chunk */
++ char* brk; /* alignment point within p */
++ mchunkptr newp; /* chunk to return */
++ INTERNAL_SIZE_T newsize; /* its size */
++ INTERNAL_SIZE_T leadsize; /* leading space before alignment point */
++ mchunkptr remainder; /* spare room at end to split off */
++ unsigned long remainder_size; /* its size */
++ INTERNAL_SIZE_T size;
++
++ /* If need less alignment than we give anyway, just relay to malloc */
++
++ if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
++
++ /* Otherwise, ensure that it is at least a minimum chunk size */
++
++ if (alignment < MINSIZE) alignment = MINSIZE;
++
++ /* Make sure alignment is power of 2 (in case MINSIZE is not). */
++ if ((alignment & (alignment - 1)) != 0) {
++ size_t a = MALLOC_ALIGNMENT * 2;
++ while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
++ alignment = a;
++ }
++
++ checked_request2size(bytes, nb);
++
++ /*
++ Strategy: find a spot within that chunk that meets the alignment
++ request, and then possibly free the leading and trailing space.
++ */
++
++
++ /* Call malloc with worst case padding to hit alignment. */
++
++ m = (char*)(mALLOc(nb + alignment + MINSIZE));
++
++ if (m == 0) return 0; /* propagate failure */
++
++ p = mem2chunk(m);
++
++ if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
++
++ /*
++ Find an aligned spot inside chunk. Since we need to give back
++ leading space in a chunk of at least MINSIZE, if the first
++ calculation places us at a spot with less than MINSIZE leader,
++ we can move to the next aligned spot -- we've allocated enough
++ total room so that this is always possible.
++ */
++
++ brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) &
++ -((signed long) alignment));
++ if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
++ brk += alignment;
++
++ newp = (mchunkptr)brk;
++ leadsize = brk - (char*)(p);
++ newsize = chunksize(p) - leadsize;
++
++ /* For mmapped chunks, just adjust offset */
++ if (chunk_is_mmapped(p)) {
++ newp->prev_size = p->prev_size + leadsize;
++ set_head(newp, newsize|IS_MMAPPED);
++ return chunk2mem(newp);
++ }
++
++ /* Otherwise, give back leader, use the rest */
++ set_head(newp, newsize | PREV_INUSE);
++ set_inuse_bit_at_offset(newp, newsize);
++ set_head_size(p, leadsize);
++ fREe(chunk2mem(p));
++ p = newp;
++
++ assert (newsize >= nb &&
++ (((unsigned long)(chunk2mem(p))) % alignment) == 0);
++ }
++
++ /* Also give back spare room at the end */
++ if (!chunk_is_mmapped(p)) {
++ size = chunksize(p);
++ if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(p, nb);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_head_size(p, nb);
++ fREe(chunk2mem(remainder));
++ }
++ }
++
++ check_inuse_chunk(p);
++ return chunk2mem(p);
++}
++
++/*
++ ------------------------------ calloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* cALLOc(size_t n_elements, size_t elem_size)
++#else
++Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size;
++#endif
++{
++ mchunkptr p;
++ unsigned long clearsize;
++ unsigned long nclears;
++ INTERNAL_SIZE_T* d;
++
++ Void_t* mem = mALLOc(n_elements * elem_size);
++
++ if (mem != 0) {
++ p = mem2chunk(mem);
++
++ if (!chunk_is_mmapped(p))
++ {
++ /*
++ Unroll clear of <= 36 bytes (72 if 8byte sizes)
++ We know that contents have an odd number of
++ INTERNAL_SIZE_T-sized words; minimally 3.
++ */
++
++ d = (INTERNAL_SIZE_T*)mem;
++ clearsize = chunksize(p) - SIZE_SZ;
++ nclears = clearsize / sizeof(INTERNAL_SIZE_T);
++ assert(nclears >= 3);
++
++ if (nclears > 9)
++ MALLOC_ZERO(d, clearsize);
++
++ else {
++ *(d+0) = 0;
++ *(d+1) = 0;
++ *(d+2) = 0;
++ if (nclears > 4) {
++ *(d+3) = 0;
++ *(d+4) = 0;
++ if (nclears > 6) {
++ *(d+5) = 0;
++ *(d+6) = 0;
++ if (nclears > 8) {
++ *(d+7) = 0;
++ *(d+8) = 0;
++ }
++ }
++ }
++ }
++ }
++#if ! MMAP_CLEARS
++ else
++ {
++ d = (INTERNAL_SIZE_T*)mem;
++ clearsize = chunksize(p) - 2 * SIZE_SZ;
++ MALLOC_ZERO(d, clearsize);
++ }
++#endif
++ }
++ return mem;
++}
++
++/*
++ ------------------------------ cfree ------------------------------
++*/
++
++INLINE
++#if __STD_C
++void cFREe(Void_t *mem)
++#else
++void cFREe(mem) Void_t *mem;
++#endif
++{
++ fREe(mem);
++}
++
++/*
++ ------------------------------ ialloc ------------------------------
++ ialloc 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
++*/
++
++
++INLINE
++#if __STD_C
++static Void_t** iALLOc(size_t n_elements,
++ size_t* sizes,
++ int opts,
++ Void_t* chunks[])
++#else
++static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];
++#endif
++{
++ mstate av = get_malloc_state();
++ INTERNAL_SIZE_T element_size; /* chunksize of each element, if all same */
++ INTERNAL_SIZE_T contents_size; /* total size of elements */
++ INTERNAL_SIZE_T array_size; /* request size of pointer array */
++ Void_t* mem; /* malloced aggregate space */
++ mchunkptr p; /* corresponding chunk */
++ INTERNAL_SIZE_T remainder_size; /* remaining bytes while splitting */
++ Void_t** marray; /* either "chunks" or malloced ptr array */
++ mchunkptr array_chunk; /* chunk for malloced ptr array */
++ int mmx; /* to disable mmap */
++ INTERNAL_SIZE_T size;
++ size_t i;
++
++ /* Ensure initialization/consolidation */
++ if (have_fastchunks(av)) malloc_consolidate(av);
++
++ /* 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_t**) mALLOc(0);
++ marray = 0;
++ array_size = request2size(n_elements * (sizeof(Void_t*)));
++ }
++
++ /* 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]);
++ }
++
++ /* subtract out alignment bytes from total to minimize overallocation */
++ size = contents_size + array_size - MALLOC_ALIGN_MASK;
++
++ /*
++ Allocate the aggregate chunk.
++ But first disable mmap so malloc won't use it, since
++ we would not be able to later free/realloc space internal
++ to a segregated mmap region.
++ */
++ mmx = av->n_mmaps_max; /* disable mmap */
++ av->n_mmaps_max = 0;
++ mem = mALLOc(size);
++ av->n_mmaps_max = mmx; /* reset mmap */
++ if (mem == 0)
++ return 0;
++
++ p = mem2chunk(mem);
++ assert(!chunk_is_mmapped(p));
++ remainder_size = chunksize(p);
++
++ if (opts & 0x2) { /* optionally clear the elements */
++ MALLOC_ZERO(mem, remainder_size - SIZE_SZ - array_size);
++ }
++
++ /* If not provided, allocate the pointer array as final part of chunk */
++ if (marray == 0) {
++ array_chunk = chunk_at_offset(p, contents_size);
++ marray = (Void_t**) (chunk2mem(array_chunk));
++ set_head(array_chunk, (remainder_size - contents_size) | PREV_INUSE);
++ 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_head(p, size | PREV_INUSE);
++ p = chunk_at_offset(p, size);
++ }
++ else { /* the final element absorbs any overallocation slop */
++ set_head(p, remainder_size | PREV_INUSE);
++ break;
++ }
++ }
++
++#ifdef 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(mem2chunk(marray));
++ }
++
++ for (i = 0; i != n_elements; ++i)
++ check_inuse_chunk(mem2chunk(marray[i]));
++#endif
++
++ return marray;
++}
++
++
++/*
++ ------------------------- independent_calloc -------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])
++#else
++Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];
++#endif
++{
++ size_t sz = elem_size; /* serves as 1-element array */
++ /* opts arg of 3 means all elements are same size, and should be cleared */
++ return iALLOc(n_elements, &sz, 3, chunks);
++}
++
++/*
++ ------------------------- independent_comalloc -------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])
++#else
++Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];
++#endif
++{
++ return iALLOc(n_elements, sizes, 0, chunks);
++}
++
++
++/*
++ ------------------------------ valloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* vALLOc(size_t bytes)
++#else
++Void_t* vALLOc(bytes) size_t bytes;
++#endif
++{
++ /* Ensure initialization/consolidation */
++ mstate av = get_malloc_state();
++ if (have_fastchunks(av)) malloc_consolidate(av);
++ return mEMALIGn(av->pagesize, bytes);
++}
++
++/*
++ ------------------------------ pvalloc ------------------------------
++*/
++
++
++#if __STD_C
++Void_t* pVALLOc(size_t bytes)
++#else
++Void_t* pVALLOc(bytes) size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++ size_t pagesz;
++
++ /* Ensure initialization/consolidation */
++ if (have_fastchunks(av)) malloc_consolidate(av);
++ pagesz = av->pagesize;
++ return mEMALIGn(pagesz, (bytes + pagesz - 1) & ~(pagesz - 1));
++}
++
++
++/*
++ ------------------------------ malloc_trim ------------------------------
++*/
++
++INLINE
++#if __STD_C
++int mTRIm(size_t pad)
++#else
++int mTRIm(pad) size_t pad;
++#endif
++{
++ mstate av = get_malloc_state();
++ /* Ensure initialization/consolidation */
++ malloc_consolidate(av);
++
++#ifndef MORECORE_CANNOT_TRIM
++ return sYSTRIm(pad, av);
++#else
++ return 0;
++#endif
++}
++
++
++/*
++ ------------------------- malloc_usable_size -------------------------
++*/
++
++INLINE
++#if __STD_C
++size_t mUSABLe(Void_t* mem)
++#else
++size_t mUSABLe(mem) Void_t* mem;
++#endif
++{
++ mchunkptr p;
++ if (mem != 0) {
++ p = mem2chunk(mem);
++ if (chunk_is_mmapped(p))
++ return chunksize(p) - 2*SIZE_SZ;
++ else if (inuse(p))
++ return chunksize(p) - SIZE_SZ;
++ }
++ return 0;
++}
++
++/*
++ ------------------------------ mallinfo ------------------------------
++*/
++
++struct mallinfo mALLINFo()
++{
++ mstate av = get_malloc_state();
++ struct mallinfo mi;
++ unsigned int i;
++ mbinptr b;
++ mchunkptr p;
++ INTERNAL_SIZE_T avail;
++ INTERNAL_SIZE_T fastavail;
++ int nblocks;
++ int nfastblocks;
++
++ /* Ensure initialization */
++ if (av->top == 0) malloc_consolidate(av);
++
++ check_malloc_state();
++
++ /* Account for top */
++ avail = chunksize(av->top);
++ nblocks = 1; /* top always exists */
++
++ /* traverse fastbins */
++ nfastblocks = 0;
++ fastavail = 0;
++
++ for (i = 0; i < NFASTBINS; ++i) {
++ for (p = av->fastbins[i]; p != 0; p = p->fd) {
++ ++nfastblocks;
++ fastavail += chunksize(p);
++ }
++ }
++
++ avail += fastavail;
++
++ /* traverse regular bins */
++ for (i = 1; i < NBINS; ++i) {
++ b = bin_at(av, i);
++ for (p = last(b); p != b; p = p->bk) {
++ ++nblocks;
++ avail += chunksize(p);
++ }
++ }
++
++ mi.smblks = nfastblocks;
++ mi.ordblks = nblocks;
++ mi.fordblks = avail;
++ mi.uordblks = av->sbrked_mem - avail;
++ mi.arena = av->sbrked_mem;
++ mi.hblks = av->n_mmaps;
++ mi.hblkhd = av->mmapped_mem;
++ mi.fsmblks = fastavail;
++ mi.keepcost = chunksize(av->top);
++ mi.usmblks = av->max_total_mem;
++ return mi;
++}
++
++/*
++ ------------------------------ malloc_stats ------------------------------
++*/
++
++void mSTATs()
++{
++ struct mallinfo mi = mALLINFo();
++
++#ifdef WIN32
++ {
++ unsigned long free, reserved, committed;
++ vminfo (&free, &reserved, &committed);
++ fprintf(stderr, "free bytes = %10lu\n",
++ free);
++ fprintf(stderr, "reserved bytes = %10lu\n",
++ reserved);
++ fprintf(stderr, "committed bytes = %10lu\n",
++ committed);
++ }
++#endif
++
++
++ fprintf(stderr, "max system bytes = %10lu\n",
++ (unsigned long)(mi.usmblks));
++ fprintf(stderr, "system bytes = %10lu\n",
++ (unsigned long)(mi.arena + mi.hblkhd));
++ fprintf(stderr, "in use bytes = %10lu\n",
++ (unsigned long)(mi.uordblks + mi.hblkhd));
++
++
++#ifdef WIN32
++ {
++ unsigned long kernel, user;
++ if (cpuinfo (TRUE, &kernel, &user)) {
++ fprintf(stderr, "kernel ms = %10lu\n",
++ kernel);
++ fprintf(stderr, "user ms = %10lu\n",
++ user);
++ }
++ }
++#endif
++}
++
++
++/*
++ ------------------------------ mallopt ------------------------------
++*/
++
++INLINE
++#if __STD_C
++int mALLOPt(int param_number, int value)
++#else
++int mALLOPt(param_number, value) int param_number; int value;
++#endif
++{
++ mstate av = get_malloc_state();
++ /* Ensure initialization/consolidation */
++ malloc_consolidate(av);
++
++ switch(param_number) {
++ case M_MXFAST:
++ if (value >= 0 && value <= MAX_FAST_SIZE) {
++ set_max_fast(av, value);
++ return 1;
++ }
++ else
++ return 0;
++
++ case M_TRIM_THRESHOLD:
++ av->trim_threshold = value;
++ return 1;
++
++ case M_TOP_PAD:
++ av->top_pad = value;
++ return 1;
++
++ case M_MMAP_THRESHOLD:
++ av->mmap_threshold = value;
++ return 1;
++
++ case M_MMAP_MAX:
++#if !HAVE_MMAP
++ if (value != 0)
++ return 0;
++#endif
++ av->n_mmaps_max = value;
++ return 1;
++
++ default:
++ return 0;
++ }
++}
++
++
++/*
++ -------------------- Alternative MORECORE functions --------------------
++*/
++
++
++/*
++ General Requirements for MORECORE.
++
++ The MORECORE function must have the following properties:
++
++ If MORECORE_CONTIGUOUS is false:
++
++ * MORECORE must allocate in multiples of pagesize. It will
++ only be called with arguments that are multiples of pagesize.
++
++ * MORECORE(0) must return an address that is at least
++ MALLOC_ALIGNMENT aligned. (Page-aligning always suffices.)
++
++ else (i.e. If MORECORE_CONTIGUOUS is true):
++
++ * Consecutive calls to MORECORE with positive arguments
++ return increasing addresses, indicating that space has been
++ contiguously extended.
++
++ * MORECORE need not allocate in multiples of pagesize.
++ Calls to MORECORE need not have args of multiples of pagesize.
++
++ * MORECORE need not page-align.
++
++ In either case:
++
++ * MORECORE may allocate more memory than requested. (Or even less,
++ but this will generally result in a malloc failure.)
++
++ * MORECORE must not allocate memory when given argument zero, but
++ instead return one past the end address of memory from previous
++ nonzero call. This malloc does NOT call MORECORE(0)
++ until at least one call with positive arguments is made, so
++ the initial value returned is not important.
++
++ * Even though consecutive calls to MORECORE need not return contiguous
++ addresses, it must be OK for malloc'ed chunks to span multiple
++ regions in those cases where they do happen to be contiguous.
++
++ * MORECORE need not handle negative arguments -- it may instead
++ just return MORECORE_FAILURE when given negative arguments.
++ Negative arguments are always multiples of pagesize. MORECORE
++ must not misinterpret negative args as large positive unsigned
++ args. You can suppress all such calls from even occurring by defining
++ MORECORE_CANNOT_TRIM,
++
++ There is some variation across systems about the type of the
++ argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
++ actually be size_t, because sbrk supports negative args, so it is
++ normally the signed type of the same width as size_t (sometimes
++ declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much
++ matter though. Internally, we use "long" as arguments, which should
++ work across all reasonable possibilities.
++
++ Additionally, if MORECORE ever returns failure for a positive
++ 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 map noncontiguous space.
++
++ If you'd like mmap to ALWAYS be used, you can define MORECORE to be
++ a function that always returns MORECORE_FAILURE.
++
++ If you are using this malloc with something other than sbrk (or its
++ emulation) to supply memory regions, you probably want to set
++ MORECORE_CONTIGUOUS as false. As an example, here is a custom
++ allocator kindly contributed for pre-OSX macOS. It uses virtually
++ but not necessarily physically contiguous non-paged memory (locked
++ in, present and won't get swapped out). You can use it by
++ uncommenting this section, adding some #includes, and setting up the
++ appropriate defines above:
++
++ #define MORECORE osMoreCore
++ #define MORECORE_CONTIGUOUS 0
++
++ There is also a shutdown routine that should somehow be called for
++ cleanup upon program exit.
++
++ #define MAX_POOL_ENTRIES 100
++ #define MINIMUM_MORECORE_SIZE (64 * 1024)
++ static int next_os_pool;
++ void *our_os_pools[MAX_POOL_ENTRIES];
++
++ void *osMoreCore(int size)
++ {
++ void *ptr = 0;
++ static void *sbrk_top = 0;
++
++ if (size > 0)
++ {
++ if (size < MINIMUM_MORECORE_SIZE)
++ size = MINIMUM_MORECORE_SIZE;
++ if (CurrentExecutionLevel() == kTaskLevel)
++ ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
++ if (ptr == 0)
++ {
++ return (void *) MORECORE_FAILURE;
++ }
++ // save ptrs so they can be freed during cleanup
++ our_os_pools[next_os_pool] = ptr;
++ next_os_pool++;
++ ptr = (void *) ((((unsigned long) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
++ sbrk_top = (char *) ptr + size;
++ return ptr;
++ }
++ else if (size < 0)
++ {
++ // we don't currently support shrink behavior
++ return (void *) MORECORE_FAILURE;
++ }
++ else
++ {
++ return sbrk_top;
++ }
++ }
++
++ // cleanup any allocated memory pools
++ // called as last thing before shutting down driver
++
++ void osCleanupMem(void)
++ {
++ void **ptr;
++
++ for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
++ if (*ptr)
++ {
++ PoolDeallocate(*ptr);
++ *ptr = 0;
++ }
++ }
++
++*/
++
++
++/*
++ --------------------------------------------------------------
++
++ Emulation of sbrk for win32.
++ Donated by J. Walter <Walter@GeNeSys-e.de>.
++ For additional information about this code, and malloc on Win32, see
++ http://www.genesys-e.de/jwalter/
++*/
++
++
++#ifdef WIN32
++
++#ifdef _DEBUG
++/* #define TRACE */
++#endif
++
++/* Support for USE_MALLOC_LOCK */
++#ifdef USE_MALLOC_LOCK
++
++/* Wait for spin lock */
++static int slwait (int *sl) {
++ while (InterlockedCompareExchange ((void **) sl, (void *) 1, (void *) 0) != 0)
++ Sleep (0);
++ return 0;
++}
++
++/* Release spin lock */
++static int slrelease (int *sl) {
++ InterlockedExchange (sl, 0);
++ return 0;
++}
++
++#ifdef NEEDED
++/* Spin lock for emulation code */
++static int g_sl;
++#endif
++
++#endif /* USE_MALLOC_LOCK */
++
++/* getpagesize for windows */
++static long getpagesize (void) {
++ static long g_pagesize = 0;
++ if (! g_pagesize) {
++ SYSTEM_INFO system_info;
++ GetSystemInfo (&system_info);
++ g_pagesize = system_info.dwPageSize;
++ }
++ return g_pagesize;
++}
++static long getregionsize (void) {
++ static long g_regionsize = 0;
++ if (! g_regionsize) {
++ SYSTEM_INFO system_info;
++ GetSystemInfo (&system_info);
++ g_regionsize = system_info.dwAllocationGranularity;
++ }
++ return g_regionsize;
++}
++
++/* A region list entry */
++typedef struct _region_list_entry {
++ void *top_allocated;
++ void *top_committed;
++ void *top_reserved;
++ long reserve_size;
++ struct _region_list_entry *previous;
++} region_list_entry;
++
++/* Allocate and link a region entry in the region list */
++static int region_list_append (region_list_entry **last, void *base_reserved, long reserve_size) {
++ region_list_entry *next = HeapAlloc (GetProcessHeap (), 0, sizeof (region_list_entry));
++ if (! next)
++ return FALSE;
++ next->top_allocated = (char *) base_reserved;
++ next->top_committed = (char *) base_reserved;
++ next->top_reserved = (char *) base_reserved + reserve_size;
++ next->reserve_size = reserve_size;
++ next->previous = *last;
++ *last = next;
++ return TRUE;
++}
++/* Free and unlink the last region entry from the region list */
++static int region_list_remove (region_list_entry **last) {
++ region_list_entry *previous = (*last)->previous;
++ if (! HeapFree (GetProcessHeap (), sizeof (region_list_entry), *last))
++ return FALSE;
++ *last = previous;
++ return TRUE;
++}
++
++#define CEIL(size,to) (((size)+(to)-1)&~((to)-1))
++#define FLOOR(size,to) ((size)&~((to)-1))
++
++#define SBRK_SCALE 0
++/* #define SBRK_SCALE 1 */
++/* #define SBRK_SCALE 2 */
++/* #define SBRK_SCALE 4 */
++
++/* sbrk for windows */
++static void *sbrk (long size) {
++ static long g_pagesize, g_my_pagesize;
++ static long g_regionsize, g_my_regionsize;
++ static region_list_entry *g_last;
++ void *result = (void *) MORECORE_FAILURE;
++#ifdef TRACE
++ printf ("sbrk %d\n", size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize) {
++ g_pagesize = getpagesize ();
++ g_my_pagesize = g_pagesize << SBRK_SCALE;
++ }
++ if (! g_regionsize) {
++ g_regionsize = getregionsize ();
++ g_my_regionsize = g_regionsize << SBRK_SCALE;
++ }
++ if (! g_last) {
++ if (! region_list_append (&g_last, 0, 0))
++ goto sbrk_exit;
++ }
++ /* Assert invariants */
++ assert (g_last);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
++ g_last->top_allocated <= g_last->top_committed);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
++ g_last->top_committed <= g_last->top_reserved &&
++ (unsigned) g_last->top_committed % g_pagesize == 0);
++ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
++ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
++ /* Allocation requested? */
++ if (size >= 0) {
++ /* Allocation size is the requested size */
++ long allocate_size = size;
++ /* Compute the size to commit */
++ long to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Do we reach the commit limit? */
++ if (to_commit > 0) {
++ /* Round size to commit */
++ long commit_size = CEIL (to_commit, g_my_pagesize);
++ /* Compute the size to reserve */
++ long to_reserve = (char *) g_last->top_committed + commit_size - (char *) g_last->top_reserved;
++ /* Do we reach the reserve limit? */
++ if (to_reserve > 0) {
++ /* Compute the remaining size to commit in the current region */
++ long remaining_commit_size = (char *) g_last->top_reserved - (char *) g_last->top_committed;
++ if (remaining_commit_size > 0) {
++ /* Assert preconditions */
++ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
++ assert (0 < remaining_commit_size && remaining_commit_size % g_pagesize == 0); {
++ /* Commit this */
++ void *base_committed = VirtualAlloc (g_last->top_committed, remaining_commit_size,
++ MEM_COMMIT, PAGE_READWRITE);
++ /* Check returned pointer for consistency */
++ if (base_committed != g_last->top_committed)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", base_committed, remaining_commit_size);
++#endif
++ /* Adjust the regions commit top */
++ g_last->top_committed = (char *) base_committed + remaining_commit_size;
++ }
++ } {
++ /* Now we are going to search and reserve. */
++ int contiguous = -1;
++ int found = FALSE;
++ MEMORY_BASIC_INFORMATION memory_info;
++ void *base_reserved;
++ long reserve_size;
++ do {
++ /* Assume contiguous memory */
++ contiguous = TRUE;
++ /* Round size to reserve */
++ reserve_size = CEIL (to_reserve, g_my_regionsize);
++ /* Start with the current region's top */
++ memory_info.BaseAddress = g_last->top_reserved;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
++ /* Assert postconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Query %p %d %s\n", memory_info.BaseAddress, memory_info.RegionSize,
++ memory_info.State == MEM_FREE ? "FREE":
++ (memory_info.State == MEM_RESERVE ? "RESERVED":
++ (memory_info.State == MEM_COMMIT ? "COMMITTED": "?")));
++#endif
++ /* Region is free, well aligned and big enough: we are done */
++ if (memory_info.State == MEM_FREE &&
++ (unsigned) memory_info.BaseAddress % g_regionsize == 0 &&
++ memory_info.RegionSize >= (unsigned) reserve_size) {
++ found = TRUE;
++ break;
++ }
++ /* From now on we can't get contiguous memory! */
++ contiguous = FALSE;
++ /* Recompute size to reserve */
++ reserve_size = CEIL (allocate_size, g_my_regionsize);
++ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ }
++ /* Search failed? */
++ if (! found)
++ goto sbrk_exit;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_regionsize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ /* Try to reserve this */
++ base_reserved = VirtualAlloc (memory_info.BaseAddress, reserve_size,
++ MEM_RESERVE, PAGE_NOACCESS);
++ if (! base_reserved) {
++ int rc = GetLastError ();
++ if (rc != ERROR_INVALID_ADDRESS)
++ goto sbrk_exit;
++ }
++ /* A null pointer signals (hopefully) a race condition with another thread. */
++ /* In this case, we try again. */
++ } while (! base_reserved);
++ /* Check returned pointer for consistency */
++ if (memory_info.BaseAddress && base_reserved != memory_info.BaseAddress)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_reserved % g_regionsize == 0);
++#ifdef TRACE
++ printf ("Reserve %p %d\n", base_reserved, reserve_size);
++#endif
++ /* Did we get contiguous memory? */
++ if (contiguous) {
++ long start_size = (char *) g_last->top_committed - (char *) g_last->top_allocated;
++ /* Adjust allocation size */
++ allocate_size -= start_size;
++ /* Adjust the regions allocation top */
++ g_last->top_allocated = g_last->top_committed;
++ /* Recompute the size to commit */
++ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Round size to commit */
++ commit_size = CEIL (to_commit, g_my_pagesize);
++ }
++ /* Append the new region to the list */
++ if (! region_list_append (&g_last, base_reserved, reserve_size))
++ goto sbrk_exit;
++ /* Didn't we get contiguous memory? */
++ if (! contiguous) {
++ /* Recompute the size to commit */
++ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Round size to commit */
++ commit_size = CEIL (to_commit, g_my_pagesize);
++ }
++ }
++ }
++ /* Assert preconditions */
++ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
++ assert (0 < commit_size && commit_size % g_pagesize == 0); {
++ /* Commit this */
++ void *base_committed = VirtualAlloc (g_last->top_committed, commit_size,
++ MEM_COMMIT, PAGE_READWRITE);
++ /* Check returned pointer for consistency */
++ if (base_committed != g_last->top_committed)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", base_committed, commit_size);
++#endif
++ /* Adjust the regions commit top */
++ g_last->top_committed = (char *) base_committed + commit_size;
++ }
++ }
++ /* Adjust the regions allocation top */
++ g_last->top_allocated = (char *) g_last->top_allocated + allocate_size;
++ result = (char *) g_last->top_allocated - size;
++ /* Deallocation requested? */
++ } else if (size < 0) {
++ long deallocate_size = - size;
++ /* As long as we have a region to release */
++ while ((char *) g_last->top_allocated - deallocate_size < (char *) g_last->top_reserved - g_last->reserve_size) {
++ /* Get the size to release */
++ long release_size = g_last->reserve_size;
++ /* Get the base address */
++ void *base_reserved = (char *) g_last->top_reserved - release_size;
++ /* Assert preconditions */
++ assert ((unsigned) base_reserved % g_regionsize == 0);
++ assert (0 < release_size && release_size % g_regionsize == 0); {
++ /* Release this */
++ int rc = VirtualFree (base_reserved, 0,
++ MEM_RELEASE);
++ /* Check returned code for consistency */
++ if (! rc)
++ goto sbrk_exit;
++#ifdef TRACE
++ printf ("Release %p %d\n", base_reserved, release_size);
++#endif
++ }
++ /* Adjust deallocation size */
++ deallocate_size -= (char *) g_last->top_allocated - (char *) base_reserved;
++ /* Remove the old region from the list */
++ if (! region_list_remove (&g_last))
++ goto sbrk_exit;
++ } {
++ /* Compute the size to decommit */
++ long to_decommit = (char *) g_last->top_committed - ((char *) g_last->top_allocated - deallocate_size);
++ if (to_decommit >= g_my_pagesize) {
++ /* Compute the size to decommit */
++ long decommit_size = FLOOR (to_decommit, g_my_pagesize);
++ /* Compute the base address */
++ void *base_committed = (char *) g_last->top_committed - decommit_size;
++ /* Assert preconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++ assert (0 < decommit_size && decommit_size % g_pagesize == 0); {
++ /* Decommit this */
++ int rc = VirtualFree ((char *) base_committed, decommit_size,
++ MEM_DECOMMIT);
++ /* Check returned code for consistency */
++ if (! rc)
++ goto sbrk_exit;
++#ifdef TRACE
++ printf ("Decommit %p %d\n", base_committed, decommit_size);
++#endif
++ }
++ /* Adjust deallocation size and regions commit and allocate top */
++ deallocate_size -= (char *) g_last->top_allocated - (char *) base_committed;
++ g_last->top_committed = base_committed;
++ g_last->top_allocated = base_committed;
++ }
++ }
++ /* Adjust regions allocate top */
++ g_last->top_allocated = (char *) g_last->top_allocated - deallocate_size;
++ /* Check for underflow */
++ if ((char *) g_last->top_reserved - g_last->reserve_size > (char *) g_last->top_allocated ||
++ g_last->top_allocated > g_last->top_committed) {
++ /* Adjust regions allocate top */
++ g_last->top_allocated = (char *) g_last->top_reserved - g_last->reserve_size;
++ goto sbrk_exit;
++ }
++ result = g_last->top_allocated;
++ }
++ /* Assert invariants */
++ assert (g_last);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
++ g_last->top_allocated <= g_last->top_committed);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
++ g_last->top_committed <= g_last->top_reserved &&
++ (unsigned) g_last->top_committed % g_pagesize == 0);
++ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
++ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
++
++sbrk_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return result;
++}
++
++/* mmap for windows */
++static void *mmap (void *ptr, long size, long prot, long type, long handle, long arg) {
++ static long g_pagesize;
++ static long g_regionsize;
++#ifdef TRACE
++ printf ("mmap %d\n", size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize)
++ g_pagesize = getpagesize ();
++ if (! g_regionsize)
++ g_regionsize = getregionsize ();
++ /* Assert preconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++ assert (size % g_pagesize == 0);
++ /* Allocate this */
++ ptr = VirtualAlloc (ptr, size,
++ MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE);
++ if (! ptr) {
++ ptr = (void *) MORECORE_FAILURE;
++ goto mmap_exit;
++ }
++ /* Assert postconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", ptr, size);
++#endif
++mmap_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return ptr;
++}
++
++/* munmap for windows */
++static long munmap (void *ptr, long size) {
++ static long g_pagesize;
++ static long g_regionsize;
++ int rc = MUNMAP_FAILURE;
++#ifdef TRACE
++ printf ("munmap %p %d\n", ptr, size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize)
++ g_pagesize = getpagesize ();
++ if (! g_regionsize)
++ g_regionsize = getregionsize ();
++ /* Assert preconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++ assert (size % g_pagesize == 0);
++ /* Free this */
++ if (! VirtualFree (ptr, 0,
++ MEM_RELEASE))
++ goto munmap_exit;
++ rc = 0;
++#ifdef TRACE
++ printf ("Release %p %d\n", ptr, size);
++#endif
++munmap_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return rc;
++}
++
++static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed) {
++ MEMORY_BASIC_INFORMATION memory_info;
++ memory_info.BaseAddress = 0;
++ *free = *reserved = *committed = 0;
++ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
++ switch (memory_info.State) {
++ case MEM_FREE:
++ *free += memory_info.RegionSize;
++ break;
++ case MEM_RESERVE:
++ *reserved += memory_info.RegionSize;
++ break;
++ case MEM_COMMIT:
++ *committed += memory_info.RegionSize;
++ break;
++ }
++ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
++ }
++}
++
++static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user) {
++ if (whole) {
++ __int64 creation64, exit64, kernel64, user64;
++ int rc = GetProcessTimes (GetCurrentProcess (),
++ (FILETIME *) &creation64,
++ (FILETIME *) &exit64,
++ (FILETIME *) &kernel64,
++ (FILETIME *) &user64);
++ if (! rc) {
++ *kernel = 0;
++ *user = 0;
++ return FALSE;
++ }
++ *kernel = (unsigned long) (kernel64 / 10000);
++ *user = (unsigned long) (user64 / 10000);
++ return TRUE;
++ } else {
++ __int64 creation64, exit64, kernel64, user64;
++ int rc = GetThreadTimes (GetCurrentThread (),
++ (FILETIME *) &creation64,
++ (FILETIME *) &exit64,
++ (FILETIME *) &kernel64,
++ (FILETIME *) &user64);
++ if (! rc) {
++ *kernel = 0;
++ *user = 0;
++ return FALSE;
++ }
++ *kernel = (unsigned long) (kernel64 / 10000);
++ *user = (unsigned long) (user64 / 10000);
++ return TRUE;
++ }
++}
++
++#endif /* WIN32 */
++
++/* ------------------------------------------------------------
++History:
++
++ V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
++ * Introduce independent_comalloc and independent_calloc.
++ Thanks to Michael Pachos for motivation and help.
++ * Make optional .h file available
++ * Allow > 2GB requests on 32bit systems.
++ * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>.
++ Thanks also to Andreas Mueller <a.mueller at paradatec.de>,
++ and Anonymous.
++ * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for
++ helping test this.)
++ * memalign: check alignment arg
++ * realloc: don't try to shift chunks backwards, since this
++ leads to more fragmentation in some programs and doesn't
++ seem to help in any others.
++ * Collect all cases in malloc requiring system memory into sYSMALLOc
++ * Use mmap as backup to sbrk
++ * Place all internal state in malloc_state
++ * Introduce fastbins (although similar to 2.5.1)
++ * Many minor tunings and cosmetic improvements
++ * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK
++ * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS
++ Thanks to Tony E. Bennett <tbennett@nvidia.com> and others.
++ * Include errno.h to support default failure action.
++
++ V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee)
++ * return null for negative arguments
++ * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com>
++ * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h'
++ (e.g. WIN32 platforms)
++ * Cleanup header file inclusion for WIN32 platforms
++ * Cleanup code to avoid Microsoft Visual C++ compiler complaints
++ * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing
++ memory allocation routines
++ * Set 'malloc_getpagesize' for WIN32 platforms (needs more work)
++ * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to
++ usage of 'assert' in non-WIN32 code
++ * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to
++ avoid infinite loop
++ * Always call 'fREe()' rather than 'free()'
++
++ V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee)
++ * Fixed ordering problem with boundary-stamping
++
++ V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
++ * Added pvalloc, as recommended by H.J. Liu
++ * Added 64bit pointer support mainly from Wolfram Gloger
++ * Added anonymously donated WIN32 sbrk emulation
++ * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
++ * malloc_extend_top: fix mask error that caused wastage after
++ foreign sbrks
++ * Add linux mremap support code from HJ Liu
++
++ V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
++ * Integrated most documentation with the code.
++ * Add support for mmap, with help from
++ Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
++ * Use last_remainder in more cases.
++ * Pack bins using idea from colin@nyx10.cs.du.edu
++ * Use ordered bins instead of best-fit threshold
++ * Eliminate block-local decls to simplify tracing and debugging.
++ * Support another case of realloc via move into top
++ * Fix error occurring when initial sbrk_base not word-aligned.
++ * Rely on page size for units instead of SBRK_UNIT to
++ avoid surprises about sbrk alignment conventions.
++ * Add mallinfo, mallopt. Thanks to Raymond Nijssen
++ (raymond@es.ele.tue.nl) for the suggestion.
++ * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
++ * More precautions for cases where other routines call sbrk,
++ courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
++ * Added macros etc., allowing use in linux libc from
++ H.J. Lu (hjl@gnu.ai.mit.edu)
++ * Inverted this history list
++
++ V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
++ * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
++ * Removed all preallocation code since under current scheme
++ the work required to undo bad preallocations exceeds
++ the work saved in good cases for most test programs.
++ * No longer use return list or unconsolidated bins since
++ no scheme using them consistently outperforms those that don't
++ given above changes.
++ * Use best fit for very large chunks to prevent some worst-cases.
++ * Added some support for debugging
++
++ V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
++ * Removed footers when chunks are in use. Thanks to
++ Paul Wilson (wilson@cs.texas.edu) for the suggestion.
++
++ V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
++ * Added malloc_trim, with help from Wolfram Gloger
++ (wmglo@Dent.MED.Uni-Muenchen.DE).
++
++ V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
++
++ V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
++ * realloc: try to expand in both directions
++ * malloc: swap order of clean-bin strategy;
++ * realloc: only conditionally expand backwards
++ * Try not to scavenge used bins
++ * Use bin counts as a guide to preallocation
++ * Occasionally bin return list chunks in first scan
++ * Add a few optimizations from colin@nyx10.cs.du.edu
++
++ V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
++ * faster bin computation & slightly different binning
++ * merged all consolidations to one part of malloc proper
++ (eliminating old malloc_find_space & malloc_clean_bin)
++ * Scan 2 returns chunks (not just 1)
++ * Propagate failure in realloc if malloc returns 0
++ * Add stuff to allow compilation on non-ANSI compilers
++ from kpv@research.att.com
++
++ V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
++ * removed potential for odd address access in prev_chunk
++ * removed dependency on getpagesize.h
++ * misc cosmetics and a bit more internal documentation
++ * anticosmetics: mangled names in macros to evade debugger strangeness
++ * tested on sparc, hp-700, dec-mips, rs6000
++ with gcc & native cc (hp, dec only) allowing
++ Detlefs & Zorn comparison study (in SIGPLAN Notices.)
++
++ Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
++ * Based loosely on libg++-1.2X malloc. (It retains some of the overall
++ structure of old version, but most details differ.)
++
++*/
++
++#ifdef USE_PUBLIC_MALLOC_WRAPPERS
++
++#ifndef KDE_MALLOC_FULL
++
++#ifdef KDE_MALLOC_GLIBC
++#include "glibc.h"
++#else
++/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/
++#error Unknown libc
++#endif
++
++/* 0 - uninitialized
++ 1 - this malloc
++ 2 - standard libc malloc*/
++extern char* getenv(const char*);
++static int malloc_type = 0;
++static void init_malloc_type(void)
++ {
++ const char* const env = getenv( "KDE_MALLOC" );
++ if( env == NULL )
++ malloc_type = 1;
++ else if( env[ 0 ] == '0' || env[ 0 ] == 'n' || env[ 0 ] == 'N' )
++ malloc_type = 2;
++ else
++ malloc_type = 1;
++ }
++
++#endif
++
++Void_t* public_mALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_malloc( bytes );
++ init_malloc_type();
++ return public_mALLOc( bytes );
++#endif
++}
++
++void public_fREe(Void_t* m) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ fREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++#ifndef KDE_MALLOC_FULL
++ return;
++ }
++ if( malloc_type == 2 )
++ {
++ libc_free( m );
++ return;
++ }
++ init_malloc_type();
++ public_fREe( m );
++#endif
++}
++
++Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = rEALLOc(m, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_realloc( m, bytes );
++ init_malloc_type();
++ return public_rEALLOc( m, bytes );
++#endif
++}
++
++Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mEMALIGn(alignment, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_memalign( alignment, bytes );
++ init_malloc_type();
++ return public_mEMALIGn( alignment, bytes );
++#endif
++}
++
++Void_t* public_vALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = vALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_valloc( bytes );
++ init_malloc_type();
++ return public_vALLOc( bytes );
++#endif
++}
++
++Void_t* public_pVALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = pVALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_pvalloc( bytes );
++ init_malloc_type();
++ return public_pVALLOc( bytes );
++#endif
++}
++
++Void_t* public_cALLOc(size_t n, size_t elem_size) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = cALLOc(n, elem_size);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_calloc( n, elem_size );
++ init_malloc_type();
++ return public_cALLOc( n, elem_size );
++#endif
++}
++
++void public_cFREe(Void_t* m) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ cFREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++#ifndef KDE_MALLOC_FULL
++ return;
++ }
++ if( malloc_type == 2 )
++ {
++ libc_cfree( m );
++ return;
++ }
++ init_malloc_type();
++ public_cFREe( m );
++#endif
++}
++
++struct mallinfo public_mALLINFo() {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ struct mallinfo m;
++ if (MALLOC_PREACTION != 0) {
++ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
++ return nm;
++ }
++ m = mALLINFo();
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_mallinfo();
++ init_malloc_type();
++ return public_mALLINFo();
++#endif
++}
++
++int public_mALLOPt(int p, int v) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mALLOPt(p, v);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_mallopt( p, v );
++ init_malloc_type();
++ return public_mALLOPt( p, v );
++#endif
++}
++#endif
++
++int
++posix_memalign (void **memptr, size_t alignment, size_t size)
++{
++ void *mem;
++
++ /* Test whether the SIZE argument is valid. It must be a power of
++ two multiple of sizeof (void *). */
++ if (size % sizeof (void *) != 0 || (size & (size - 1)) != 0)
++ return EINVAL;
++
++ mem = memalign (alignment, size);
++
++ if (mem != NULL) {
++ *memptr = mem;
++ return 0;
++ }
++
++ return ENOMEM;
++}
++
++#else
++/* Some linkers (Solaris 2.6) don't like empty archives, but for
++ easier Makefile's we want to link against libklmalloc.la every time,
++ so simply make it non-empty. */
++void kde_malloc_dummy_function ()
++{
++ return;
++}
++#endif
+diff -Nupr a/src/corelib/arch/avr32/qatomic.cpp b/src/corelib/arch/avr32/qatomic.cpp
+--- a/src/corelib/arch/avr32/qatomic.cpp 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/qatomic.cpp 2006-07-26 11:02:43.000000000 +0200
+@@ -0,0 +1,24 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#include "QtCore/qatomic_avr32.h"
++
++Q_CORE_EXPORT long q_atomic_lock = 0;
+diff -Nupr a/src/corelib/arch/qatomic_arch.h b/src/corelib/arch/qatomic_arch.h
+--- a/src/corelib/arch/qatomic_arch.h 2006-06-30 09:49:44.000000000 +0200
++++ b/src/corelib/arch/qatomic_arch.h 2006-07-27 12:42:58.000000000 +0200
+@@ -32,6 +32,8 @@ QT_BEGIN_HEADER
+ # include "QtCore/qatomic_alpha.h"
+ #elif defined(QT_ARCH_ARM)
+ # include "QtCore/qatomic_arm.h"
++#elif defined(QT_ARCH_AVR32)
++# include "QtCore/qatomic_avr32.h"
+ #elif defined(QT_ARCH_BOUNDSCHECKER)
+ # include "QtCore/qatomic_boundschecker.h"
+ #elif defined(QT_ARCH_GENERIC)
+diff -Nupr a/src/corelib/arch/qatomic_avr32.h b/src/corelib/arch/qatomic_avr32.h
+--- a/src/corelib/arch/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/qatomic_avr32.h 2006-07-28 10:30:08.000000000 +0200
+@@ -0,0 +1,113 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#ifndef AVR32_QATOMIC_H
++#define AVR32_QATOMIC_H
++
++#include <QtCore/qglobal.h>
++
++QT_BEGIN_HEADER
++
++extern Q_CORE_EXPORT long q_atomic_lock;
++
++inline long q_atomic_swp(volatile long *ptr, long newval)
++{
++ register int ret;
++ asm volatile("xchg %0,%1,%2"
++ : "=&r"(ret)
++ : "r"(ptr), "r"(newval)
++ : "memory", "cc");
++ return ret;
++}
++
++inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
++{
++ int ret = 0;
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0);
++ if (*ptr == expected) {
++ *ptr = newval;
++ ret = 1;
++ }
++ q_atomic_swp(&q_atomic_lock, 0);
++ return ret;
++}
++
++inline int q_atomic_test_and_set_acquire_int(volatile int *ptr, int expected, int newval)
++{
++ return q_atomic_test_and_set_int(ptr, expected, newval);
++}
++
++inline int q_atomic_test_and_set_release_int(volatile int *ptr, int expected, int newval)
++{
++ return q_atomic_test_and_set_int(ptr, expected, newval);
++}
++
++inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
++{
++ int ret = 0;
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ if (*reinterpret_cast<void * volatile *>(ptr) == expected) {
++ *reinterpret_cast<void * volatile *>(ptr) = newval;
++ ret = 1;
++ }
++ q_atomic_swp(&q_atomic_lock, 0);
++ return ret;
++}
++
++inline int q_atomic_increment(volatile int *ptr)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = originalValue + 1;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue != -1;
++}
++
++inline int q_atomic_decrement(volatile int *ptr)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = originalValue - 1;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue != 1;
++}
++
++inline int q_atomic_set_int(volatile int *ptr, int newval)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = newval;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue;
++}
++
++inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ void *originalValue = *reinterpret_cast<void * volatile *>(ptr);
++ *reinterpret_cast<void * volatile *>(ptr) = newval;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue;
++}
++
++QT_END_HEADER
++
++#endif // AVR32_QATOMIC_H
+diff -Nupr a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
+--- a/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-06-30 09:49:45.000000000 +0200
++++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-07-27 13:24:27.000000000 +0200
+@@ -72,6 +72,10 @@
+ # define __NR_inotify_init 316
+ # define __NR_inotify_add_watch 317
+ # define __NR_inotify_rm_watch 318
++#elif defined (__avr32__)
++# define __NR_inotify_init 240
++# define __NR_inotify_add_watch 241
++# define __NR_inotify_rm_watch 242
+ #elif defined (__SH4__)
+ # define __NR_inotify_init 290
+ # define __NR_inotify_add_watch 291
+diff -uprN a/mkspecs/qws/linux-avr32-g++/qmake.conf b/mkspecs/qws/linux-avr32-g++/qmake.conf
+--- a/mkspecs/qws/linux-avr32-g++/qmake.conf 1970-01-01 01:00:00.000000000 +0100
++++ b/mkspecs/qws/linux-avr32-g++/qmake.conf 2006-08-01 08:47:12.000000000 +0200
+@@ -0,0 +1,85 @@
++#
++# qmake configuration for linux-g++ using the avr32-linux-g++ crosscompiler
++#
++
++MAKEFILE_GENERATOR = UNIX
++TEMPLATE = app
++CONFIG += qt warn_on release link_prl
++QT += core gui network
++QMAKE_INCREMENTAL_STYLE = sublib
++
++QMAKE_CC = avr32-linux-gcc
++QMAKE_LEX = flex
++QMAKE_LEXFLAGS =
++QMAKE_YACC = yacc
++QMAKE_YACCFLAGS = -d
++QMAKE_CFLAGS = -pipe
++QMAKE_CFLAGS_WARN_ON = -Wall -W
++QMAKE_CFLAGS_WARN_OFF =
++QMAKE_CFLAGS_RELEASE = -O2
++QMAKE_CFLAGS_DEBUG = -g -O2
++QMAKE_CFLAGS_SHLIB = -fPIC
++QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
++QMAKE_CFLAGS_THREAD = -D_REENTRANT
++QMAKE_CFLAGS_HIDESYMS = -fvisibility=hidden
++
++QMAKE_CXX = avr32-linux-g++
++QMAKE_CXXFLAGS = $$QMAKE_CFLAGS -fno-exceptions
++QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
++QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
++QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
++QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
++QMAKE_CXXFLAGS_SHLIB = $$QMAKE_CFLAGS_SHLIB
++QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
++QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD
++QMAKE_CXXFLAGS_HIDESYMS = $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden
++
++QMAKE_INCDIR =
++QMAKE_LIBDIR =
++QMAKE_INCDIR_X11 =
++QMAKE_LIBDIR_X11 =
++QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
++QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
++QMAKE_INCDIR_OPENGL =
++QMAKE_LIBDIR_OPENGL =
++QMAKE_INCDIR_QTOPIA = $(QPEDIR)/include
++QMAKE_LIBDIR_QTOPIA = $(QPEDIR)/lib
++
++QMAKE_LINK = avr32-linux-g++
++QMAKE_LINK_SHLIB = avr32-linux-g++
++QMAKE_LFLAGS =
++QMAKE_LFLAGS_RELEASE =
++QMAKE_LFLAGS_DEBUG =
++QMAKE_LFLAGS_SHLIB = -shared
++QMAKE_LFLAGS_PLUGIN = $$QMAKE_LFLAGS_SHLIB
++QMAKE_LFLAGS_SONAME = -Wl,-soname,
++QMAKE_LFLAGS_THREAD =
++QMAKE_RPATH = -Wl,-rpath,
++
++QMAKE_LIBS =
++QMAKE_LIBS_DYNLOAD = -ldl
++QMAKE_LIBS_X11 =
++QMAKE_LIBS_X11SM =
++QMAKE_LIBS_QT = -lqte
++QMAKE_LIBS_QT_THREAD = -lqte-mt
++QMAKE_LIBS_QT_OPENGL = -lqgl
++QMAKE_LIBS_QTOPIA = -lqpe -lqtopia
++QMAKE_LIBS_THREAD = -lpthread
++
++QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
++QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
++
++QMAKE_AR = avr32-linux-ar cqs
++QMAKE_RANLIB = avr32-linux-ranlib
++
++QMAKE_TAR = tar -cf
++QMAKE_GZIP = gzip -9f
++
++QMAKE_COPY = cp -f
++QMAKE_MOVE = mv -f
++QMAKE_DEL_FILE = rm -f
++QMAKE_DEL_DIR = rmdir
++QMAKE_STRIP = avr32-linux-strip
++QMAKE_CHK_DIR_EXISTS = test -d
++QMAKE_MKDIR = mkdir -p
++load(qt_config)
+diff -uprN a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h
+--- a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 1970-01-01 01:00:00.000000000 +0100
++++ b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 2006-07-26 09:16:52.000000000 +0200
+@@ -0,0 +1,22 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the qmake spec of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#include "../../linux-g++/qplatformdefs.h"
+++ /dev/null
---- a/include/QtCore/headers.pri 2007-08-02 15:03:31.000000000 +0200
-+++ b/include/QtCore/headers.pri 2007-08-02 15:03:44.000000000 +0200
-@@ -1,2 +1,2 @@
--SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
-+SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_avr32.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
- SYNCQT.HEADER_CLASSES = ../../include/QtCore/QDataStream ../../include/QtCore/QtDebug ../../include/QtCore/QDebug ../../include/QtCore/QNoDebug ../../include/QtCore/QTextStream ../../include/QtCore/QTextStreamFunction ../../include/QtCore/QTextStreamManipulator ../../include/QtCore/QTS ../../include/QtCore/QTextIStream ../../include/QtCore/QTextOStream ../../include/QtCore/QTemporaryFile ../../include/QtCore/QFSFileEngine ../../include/QtCore/QIODevice ../../include/QtCore/Q_PID ../../include/QtCore/QProcess ../../include/QtCore/QResource ../../include/QtCore/QBuffer ../../include/QtCore/QFileSystemWatcher ../../include/QtCore/QDir ../../include/QtCore/QUrl ../../include/QtCore/QAbstractFileEngine ../../include/QtCore/QAbstractFileEngineHandler ../../include/QtCore/QFileInfo ../../include/QtCore/QFileInfoList ../../include/QtCore/QFileInfoListIterator ../../include/QtCore/QSettings ../../include/QtCore/QFile ../../include/QtCore/QBasicAtomic ../../include/QtCore/QBasicAtomicPointer ../../include/QtCore/QCache ../../include/QtCore/QLine ../../include/QtCore/QLineF ../../include/QtCore/QListData ../../include/QtCore/QList ../../include/QtCore/QListIterator ../../include/QtCore/QMutableListIterator ../../include/QtCore/QPair ../../include/QtCore/QPoint ../../include/QtCore/QPointF ../../include/QtCore/QRect ../../include/QtCore/QRectF ../../include/QtCore/QSize ../../include/QtCore/QSizeF ../../include/QtCore/QStringListIterator ../../include/QtCore/QMutableStringListIterator ../../include/QtCore/QStringList ../../include/QtCore/QStringMatcher ../../include/QtCore/QLinkedListData ../../include/QtCore/QLinkedListNode ../../include/QtCore/QLinkedList ../../include/QtCore/QLinkedListIterator ../../include/QtCore/QMutableLinkedListIterator ../../include/QtCore/QBitArray ../../include/QtCore/QBitRef ../../include/QtCore/QVectorData ../../include/QtCore/QVectorTypedData ../../include/QtCore/QVector ../../include/QtCore/QVectorIterator ../../include/QtCore/QMutableVectorIterator ../../include/QtCore/QByteArrayMatcher ../../include/QtCore/QQueue ../../include/QtCore/QByteArray ../../include/QtCore/QByteRef ../../include/QtCore/QtAlgorithms ../../include/QtCore/QVarLengthArray ../../include/QtCore/QSharedData ../../include/QtCore/QSharedDataPointer ../../include/QtCore/QLocale ../../include/QtCore/QSystemLocale ../../include/QtCore/QStack ../../include/QtCore/QMapData ../../include/QtCore/QMap ../../include/QtCore/QMultiMap ../../include/QtCore/QMapIterator ../../include/QtCore/QMutableMapIterator ../../include/QtCore/QSet ../../include/QtCore/QSetIterator ../../include/QtCore/QMutableSetIterator ../../include/QtCore/QDate ../../include/QtCore/QTime ../../include/QtCore/QDateTime ../../include/QtCore/QStdWString ../../include/QtCore/QString ../../include/QtCore/QLatin1String ../../include/QtCore/QCharRef ../../include/QtCore/QConstString ../../include/QtCore/QtContainerFwd ../../include/QtCore/QRegExp ../../include/QtCore/QLatin1Char ../../include/QtCore/QChar ../../include/QtCore/QHashData ../../include/QtCore/QHashDummyValue ../../include/QtCore/QHashDummyNode ../../include/QtCore/QHashNode ../../include/QtCore/QHash ../../include/QtCore/QMultiHash ../../include/QtCore/QHashIterator ../../include/QtCore/QMutableHashIterator ../../include/QtCore/QTimeLine ../../include/QtCore/QTextCodecFactoryInterface ../../include/QtCore/QTextCodecPlugin ../../include/QtCore/QTextCodec ../../include/QtCore/QTextEncoder ../../include/QtCore/QTextDecoder ../../include/QtCore/QLibraryInfo ../../include/QtCore/QtEndian ../../include/QtCore/QtGlobal ../../include/QtCore/QUintForSize ../../include/QtCore/QUintForType ../../include/QtCore/QIntForSize ../../include/QtCore/QIntForType ../../include/QtCore/QNoImplicitBoolCast ../../include/QtCore/Q_INT8 ../../include/QtCore/Q_UINT8 ../../include/QtCore/Q_INT16 ../../include/QtCore/Q_UINT16 ../../include/QtCore/Q_INT32 ../../include/QtCore/Q_UINT32 ../../include/QtCore/Q_INT64 ../../include/QtCore/Q_UINT64 ../../include/QtCore/Q_LLONG ../../include/QtCore/Q_ULLONG ../../include/QtCore/Q_LONG ../../include/QtCore/Q_ULONG ../../include/QtCore/QSysInfo ../../include/QtCore/QtMsgHandler ../../include/QtCore/QGlobalStatic ../../include/QtCore/QBool ../../include/QtCore/QTypeInfo ../../include/QtCore/QFlag ../../include/QtCore/QFlags ../../include/QtCore/QForeachContainer ../../include/QtCore/QForeachContainerBase ../../include/QtCore/Qt ../../include/QtCore/QInternal ../../include/QtCore/QCOORD ../../include/QtCore/QTranslator ../../include/QtCore/QVariant ../../include/QtCore/QVariantList ../../include/QtCore/QVariantMap ../../include/QtCore/QVariantComparisonHelper ../../include/QtCore/QMimeData ../../include/QtCore/QEventLoop ../../include/QtCore/QCoreApplication ../../include/QtCore/QtCleanUpFunction ../../include/QtCore/QModelIndex ../../include/QtCore/QPersistentModelIndex ../../include/QtCore/QModelIndexList ../../include/QtCore/QAbstractItemModel ../../include/QtCore/QAbstractTableModel ../../include/QtCore/QAbstractListModel ../../include/QtCore/QSignalMapper ../../include/QtCore/QObjectCleanupHandler ../../include/QtCore/QBasicTimer ../../include/QtCore/QSocketNotifier ../../include/QtCore/QObjectList ../../include/QtCore/QObjectData ../../include/QtCore/QObject ../../include/QtCore/QObjectUserData ../../include/QtCore/QTimer ../../include/QtCore/QMetaType ../../include/QtCore/QMetaTypeId ../../include/QtCore/QMetaTypeId2 ../../include/QtCore/QAbstractEventDispatcher ../../include/QtCore/QPointer ../../include/QtCore/QMetaMethod ../../include/QtCore/QMetaEnum ../../include/QtCore/QMetaProperty ../../include/QtCore/QMetaClassInfo ../../include/QtCore/QEvent ../../include/QtCore/QTimerEvent ../../include/QtCore/QChildEvent ../../include/QtCore/QCustomEvent ../../include/QtCore/QDynamicPropertyChangeEvent ../../include/QtCore/QGenericArgument ../../include/QtCore/QGenericReturnArgument ../../include/QtCore/QArgument ../../include/QtCore/QReturnArgument ../../include/QtCore/QMetaObject ../../include/QtCore/QPluginLoader ../../include/QtCore/QUuid ../../include/QtCore/QLibrary ../../include/QtCore/QtPlugin ../../include/QtCore/QtPluginInstanceFunction ../../include/QtCore/QFactoryInterface ../../include/QtCore/QSemaphore ../../include/QtCore/QThreadStorageData ../../include/QtCore/QThreadStorage ../../include/QtCore/QWaitCondition ../../include/QtCore/QThread ../../include/QtCore/QMutex ../../include/QtCore/QMutexLocker ../../include/QtCore/QReadWriteLock ../../include/QtCore/QReadLocker ../../include/QtCore/QWriteLocker ../../include/QtCore/QAtomic ../../include/QtCore/QAtomicPointer
--- /dev/null
+--- a/include/QtCore/headers.pri 2007-08-02 15:03:31.000000000 +0200
++++ b/include/QtCore/headers.pri 2007-08-02 15:03:44.000000000 +0200
+@@ -1,2 +1,2 @@
+-SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
++SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_avr32.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
+ SYNCQT.HEADER_CLASSES = ../../include/QtCore/QDataStream ../../include/QtCore/QtDebug ../../include/QtCore/QDebug ../../include/QtCore/QNoDebug ../../include/QtCore/QTextStream ../../include/QtCore/QTextStreamFunction ../../include/QtCore/QTextStreamManipulator ../../include/QtCore/QTS ../../include/QtCore/QTextIStream ../../include/QtCore/QTextOStream ../../include/QtCore/QTemporaryFile ../../include/QtCore/QFSFileEngine ../../include/QtCore/QIODevice ../../include/QtCore/Q_PID ../../include/QtCore/QProcess ../../include/QtCore/QResource ../../include/QtCore/QBuffer ../../include/QtCore/QFileSystemWatcher ../../include/QtCore/QDir ../../include/QtCore/QUrl ../../include/QtCore/QAbstractFileEngine ../../include/QtCore/QAbstractFileEngineHandler ../../include/QtCore/QFileInfo ../../include/QtCore/QFileInfoList ../../include/QtCore/QFileInfoListIterator ../../include/QtCore/QSettings ../../include/QtCore/QFile ../../include/QtCore/QBasicAtomic ../../include/QtCore/QBasicAtomicPointer ../../include/QtCore/QCache ../../include/QtCore/QLine ../../include/QtCore/QLineF ../../include/QtCore/QListData ../../include/QtCore/QList ../../include/QtCore/QListIterator ../../include/QtCore/QMutableListIterator ../../include/QtCore/QPair ../../include/QtCore/QPoint ../../include/QtCore/QPointF ../../include/QtCore/QRect ../../include/QtCore/QRectF ../../include/QtCore/QSize ../../include/QtCore/QSizeF ../../include/QtCore/QStringListIterator ../../include/QtCore/QMutableStringListIterator ../../include/QtCore/QStringList ../../include/QtCore/QStringMatcher ../../include/QtCore/QLinkedListData ../../include/QtCore/QLinkedListNode ../../include/QtCore/QLinkedList ../../include/QtCore/QLinkedListIterator ../../include/QtCore/QMutableLinkedListIterator ../../include/QtCore/QBitArray ../../include/QtCore/QBitRef ../../include/QtCore/QVectorData ../../include/QtCore/QVectorTypedData ../../include/QtCore/QVector ../../include/QtCore/QVectorIterator ../../include/QtCore/QMutableVectorIterator ../../include/QtCore/QByteArrayMatcher ../../include/QtCore/QQueue ../../include/QtCore/QByteArray ../../include/QtCore/QByteRef ../../include/QtCore/QtAlgorithms ../../include/QtCore/QVarLengthArray ../../include/QtCore/QSharedData ../../include/QtCore/QSharedDataPointer ../../include/QtCore/QLocale ../../include/QtCore/QSystemLocale ../../include/QtCore/QStack ../../include/QtCore/QMapData ../../include/QtCore/QMap ../../include/QtCore/QMultiMap ../../include/QtCore/QMapIterator ../../include/QtCore/QMutableMapIterator ../../include/QtCore/QSet ../../include/QtCore/QSetIterator ../../include/QtCore/QMutableSetIterator ../../include/QtCore/QDate ../../include/QtCore/QTime ../../include/QtCore/QDateTime ../../include/QtCore/QStdWString ../../include/QtCore/QString ../../include/QtCore/QLatin1String ../../include/QtCore/QCharRef ../../include/QtCore/QConstString ../../include/QtCore/QtContainerFwd ../../include/QtCore/QRegExp ../../include/QtCore/QLatin1Char ../../include/QtCore/QChar ../../include/QtCore/QHashData ../../include/QtCore/QHashDummyValue ../../include/QtCore/QHashDummyNode ../../include/QtCore/QHashNode ../../include/QtCore/QHash ../../include/QtCore/QMultiHash ../../include/QtCore/QHashIterator ../../include/QtCore/QMutableHashIterator ../../include/QtCore/QTimeLine ../../include/QtCore/QTextCodecFactoryInterface ../../include/QtCore/QTextCodecPlugin ../../include/QtCore/QTextCodec ../../include/QtCore/QTextEncoder ../../include/QtCore/QTextDecoder ../../include/QtCore/QLibraryInfo ../../include/QtCore/QtEndian ../../include/QtCore/QtGlobal ../../include/QtCore/QUintForSize ../../include/QtCore/QUintForType ../../include/QtCore/QIntForSize ../../include/QtCore/QIntForType ../../include/QtCore/QNoImplicitBoolCast ../../include/QtCore/Q_INT8 ../../include/QtCore/Q_UINT8 ../../include/QtCore/Q_INT16 ../../include/QtCore/Q_UINT16 ../../include/QtCore/Q_INT32 ../../include/QtCore/Q_UINT32 ../../include/QtCore/Q_INT64 ../../include/QtCore/Q_UINT64 ../../include/QtCore/Q_LLONG ../../include/QtCore/Q_ULLONG ../../include/QtCore/Q_LONG ../../include/QtCore/Q_ULONG ../../include/QtCore/QSysInfo ../../include/QtCore/QtMsgHandler ../../include/QtCore/QGlobalStatic ../../include/QtCore/QBool ../../include/QtCore/QTypeInfo ../../include/QtCore/QFlag ../../include/QtCore/QFlags ../../include/QtCore/QForeachContainer ../../include/QtCore/QForeachContainerBase ../../include/QtCore/Qt ../../include/QtCore/QInternal ../../include/QtCore/QCOORD ../../include/QtCore/QTranslator ../../include/QtCore/QVariant ../../include/QtCore/QVariantList ../../include/QtCore/QVariantMap ../../include/QtCore/QVariantComparisonHelper ../../include/QtCore/QMimeData ../../include/QtCore/QEventLoop ../../include/QtCore/QCoreApplication ../../include/QtCore/QtCleanUpFunction ../../include/QtCore/QModelIndex ../../include/QtCore/QPersistentModelIndex ../../include/QtCore/QModelIndexList ../../include/QtCore/QAbstractItemModel ../../include/QtCore/QAbstractTableModel ../../include/QtCore/QAbstractListModel ../../include/QtCore/QSignalMapper ../../include/QtCore/QObjectCleanupHandler ../../include/QtCore/QBasicTimer ../../include/QtCore/QSocketNotifier ../../include/QtCore/QObjectList ../../include/QtCore/QObjectData ../../include/QtCore/QObject ../../include/QtCore/QObjectUserData ../../include/QtCore/QTimer ../../include/QtCore/QMetaType ../../include/QtCore/QMetaTypeId ../../include/QtCore/QMetaTypeId2 ../../include/QtCore/QAbstractEventDispatcher ../../include/QtCore/QPointer ../../include/QtCore/QMetaMethod ../../include/QtCore/QMetaEnum ../../include/QtCore/QMetaProperty ../../include/QtCore/QMetaClassInfo ../../include/QtCore/QEvent ../../include/QtCore/QTimerEvent ../../include/QtCore/QChildEvent ../../include/QtCore/QCustomEvent ../../include/QtCore/QDynamicPropertyChangeEvent ../../include/QtCore/QGenericArgument ../../include/QtCore/QGenericReturnArgument ../../include/QtCore/QArgument ../../include/QtCore/QReturnArgument ../../include/QtCore/QMetaObject ../../include/QtCore/QPluginLoader ../../include/QtCore/QUuid ../../include/QtCore/QLibrary ../../include/QtCore/QtPlugin ../../include/QtCore/QtPluginInstanceFunction ../../include/QtCore/QFactoryInterface ../../include/QtCore/QSemaphore ../../include/QtCore/QThreadStorageData ../../include/QtCore/QThreadStorage ../../include/QtCore/QWaitCondition ../../include/QtCore/QThread ../../include/QtCore/QMutex ../../include/QtCore/QMutexLocker ../../include/QtCore/QReadWriteLock ../../include/QtCore/QReadLocker ../../include/QtCore/QWriteLocker ../../include/QtCore/QAtomic ../../include/QtCore/QAtomicPointer
+++ /dev/null
-diff -Nupr a/include/Qt/qatomic_avr32.h b/include/Qt/qatomic_avr32.h
---- a/include/Qt/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/include/Qt/qatomic_avr32.h 2006-07-27 07:55:09.000000000 +0200
-@@ -0,0 +1 @@
-+#include "../../src/corelib/arch/qatomic_avr32.h"
-diff -Nupr a/include/QtCore/qatomic_avr32.h b/include/QtCore/qatomic_avr32.h
---- a/include/QtCore/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/include/QtCore/qatomic_avr32.h 2006-07-27 07:55:28.000000000 +0200
-@@ -0,0 +1 @@
-+#include "../../src/corelib/arch/qatomic_avr32.h"
-diff -Nupr a/src/corelib/arch/arch.pri b/src/corelib/arch/arch.pri
---- a/src/corelib/arch/arch.pri 2006-06-30 09:49:44.000000000 +0200
-+++ b/src/corelib/arch/arch.pri 2006-07-26 11:03:43.000000000 +0200
-@@ -13,6 +13,7 @@ mac:HEADERS += arch/qatomic_macosx.h \
- arch/qatomic_generic.h \
- arch/qatomic_powerpc.h \
- arch/qatomic_arm.h \
-+ arch/qatomic_avr32.h \
- arch/qatomic_i386.h \
- arch/qatomic_mips.h \
- arch/qatomic_s390.h \
-diff -Nupr a/src/corelib/arch/avr32/arch.pri b/src/corelib/arch/avr32/arch.pri
---- a/src/corelib/arch/avr32/arch.pri 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/arch.pri 2006-07-26 11:02:16.000000000 +0200
-@@ -0,0 +1,5 @@
-+#
-+# AVR32 architecture
-+#
-+SOURCES += $$QT_ARCH_CPP/qatomic.cpp \
-+ $$QT_ARCH_CPP/malloc.c
-diff -Nupr a/src/corelib/arch/avr32/malloc.c b/src/corelib/arch/avr32/malloc.c
---- a/src/corelib/arch/avr32/malloc.c 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/malloc.c 2006-07-28 10:29:44.000000000 +0200
-@@ -0,0 +1,5819 @@
-+/****************************************************************************
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** This file contains third party code which is not governed by the Qt
-+** Commercial License Agreement. Please read the license headers below
-+** for more information.
-+**
-+** Further information about Qt licensing is available at:
-+** http://www.trolltech.com/products/qt/licensing.html or by
-+** contacting info@trolltech.com.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+/* ---- config.h */
-+#define KDE_MALLOC
-+#define KDE_MALLOC_FULL
-+#define KDE_MALLOC_AVR32
-+/* ---- */
-+
-+#ifdef KDE_MALLOC
-+
-+#ifdef KDE_MALLOC_DEBUG
-+#define DEBUG
-+#endif
-+
-+#define USE_MALLOC_LOCK
-+#define INLINE __inline__
-+/*#define INLINE*/
-+#define USE_MEMCPY 0
-+#define MMAP_CLEARS 1
-+
-+/*
-+ This is a version (aka dlmalloc) of malloc/free/realloc written by
-+ Doug Lea and released to the public domain. Use, modify, and
-+ redistribute this code without permission or acknowledgment in any
-+ way you wish. Send questions, comments, complaints, performance
-+ data, etc to dl@cs.oswego.edu
-+
-+* VERSION 2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
-+
-+ Note: There may be an updated version of this malloc obtainable at
-+ ftp://gee.cs.oswego.edu/pub/misc/malloc.c
-+ Check before installing!
-+
-+* Quickstart
-+
-+ This library is all in one file to simplify the most common usage:
-+ ftp it, compile it (-O), and link it into another program. All
-+ of the compile-time options default to reasonable values for use on
-+ most unix platforms. Compile -DWIN32 for reasonable defaults on windows.
-+ You might later want to step through various compile-time and dynamic
-+ tuning options.
-+
-+ For convenience, an include file for code using this malloc is at:
-+ ftp://gee.cs.oswego.edu/pub/misc/malloc-2.7.0.h
-+ You don't really need this .h file unless you call functions not
-+ defined in your system include files. The .h file contains only the
-+ excerpts from this file needed for using this malloc on ANSI C/C++
-+ systems, so long as you haven't changed compile-time options about
-+ naming and tuning parameters. If you do, then you can create your
-+ own malloc.h that does include all settings by cutting at the point
-+ indicated below.
-+
-+* Why use this malloc?
-+
-+ This is not the fastest, most space-conserving, most portable, or
-+ most tunable malloc ever written. However it is among the fastest
-+ while also being among the most space-conserving, portable and tunable.
-+ Consistent balance across these factors results in a good general-purpose
-+ allocator for malloc-intensive programs.
-+
-+ The main properties of the algorithms are:
-+ * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
-+ with ties normally decided via FIFO (i.e. least recently used).
-+ * For small (<= 64 bytes by default) requests, it is a caching
-+ allocator, that maintains pools of quickly recycled chunks.
-+ * In between, and for combinations of large and small requests, it does
-+ the best it can trying to meet both goals at once.
-+ * For very large requests (>= 128KB by default), it relies on system
-+ memory mapping facilities, if supported.
-+
-+ For a longer but slightly out of date high-level description, see
-+ http://gee.cs.oswego.edu/dl/html/malloc.html
-+
-+ You may already by default be using a C library containing a malloc
-+ that is based on some version of this malloc (for example in
-+ linux). You might still want to use the one in this file in order to
-+ customize settings or to avoid overheads associated with library
-+ versions.
-+
-+* Contents, described in more detail in "description of public routines" below.
-+
-+ Standard (ANSI/SVID/...) functions:
-+ malloc(size_t n);
-+ calloc(size_t n_elements, size_t element_size);
-+ free(Void_t* p);
-+ realloc(Void_t* p, size_t n);
-+ memalign(size_t alignment, size_t n);
-+ valloc(size_t n);
-+ mallinfo()
-+ mallopt(int parameter_number, int parameter_value)
-+
-+ Additional functions:
-+ independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);
-+ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
-+ pvalloc(size_t n);
-+ cfree(Void_t* p);
-+ malloc_trim(size_t pad);
-+ malloc_usable_size(Void_t* p);
-+ malloc_stats();
-+
-+* Vital statistics:
-+
-+ Supported pointer representation: 4 or 8 bytes
-+ Supported size_t representation: 4 or 8 bytes
-+ Note that size_t is allowed to be 4 bytes even if pointers are 8.
-+ You can adjust this by defining INTERNAL_SIZE_T
-+
-+ Alignment: 2 * sizeof(size_t) (default)
-+ (i.e., 8 byte alignment with 4byte size_t). This suffices for
-+ nearly all current machines and C compilers. However, you can
-+ define MALLOC_ALIGNMENT to be wider than this if necessary.
-+
-+ Minimum overhead per allocated chunk: 4 or 8 bytes
-+ Each malloced chunk has a hidden word of overhead holding size
-+ and status information.
-+
-+ Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
-+ 8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
-+
-+ When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
-+ ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
-+ needed; 4 (8) for a trailing size field and 8 (16) bytes for
-+ free list pointers. Thus, the minimum allocatable size is
-+ 16/24/32 bytes.
-+
-+ Even a request for zero bytes (i.e., malloc(0)) returns a
-+ pointer to something of the minimum allocatable size.
-+
-+ The maximum overhead wastage (i.e., number of extra bytes
-+ allocated than were requested in malloc) is less than or equal
-+ to the minimum size, except for requests >= mmap_threshold that
-+ are serviced via mmap(), where the worst case wastage is 2 *
-+ sizeof(size_t) bytes plus the remainder from a system page (the
-+ minimal mmap unit); typically 4096 or 8192 bytes.
-+
-+ Maximum allocated size: 4-byte size_t: 2^32 minus about two pages
-+ 8-byte size_t: 2^64 minus about two pages
-+
-+ It is assumed that (possibly signed) size_t values suffice to
-+ represent chunk sizes. `Possibly signed' is due to the fact
-+ that `size_t' may be defined on a system as either a signed or
-+ an unsigned type. The ISO C standard says that it must be
-+ unsigned, but a few systems are known not to adhere to this.
-+ Additionally, even when size_t is unsigned, sbrk (which is by
-+ default used to obtain memory from system) accepts signed
-+ arguments, and may not be able to handle size_t-wide arguments
-+ with negative sign bit. Generally, values that would
-+ appear as negative after accounting for overhead and alignment
-+ are supported only via mmap(), which does not have this
-+ limitation.
-+
-+ Requests for sizes outside the allowed range will perform an optional
-+ failure action and then return null. (Requests may also
-+ also fail because a system is out of memory.)
-+
-+ Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined
-+
-+ When USE_MALLOC_LOCK is defined, wrappers are created to
-+ surround every public call with either a pthread mutex or
-+ a win32 spinlock (depending on WIN32). This is not
-+ especially fast, and can be a major bottleneck.
-+ It is designed only to provide minimal protection
-+ in concurrent environments, and to provide a basis for
-+ extensions. If you are using malloc in a concurrent program,
-+ you would be far better off obtaining ptmalloc, which is
-+ derived from a version of this malloc, and is well-tuned for
-+ concurrent programs. (See http://www.malloc.de)
-+
-+ Compliance: I believe it is compliant with the 1997 Single Unix Specification
-+ (See http://www.opennc.org). Also SVID/XPG, ANSI C, and probably
-+ others as well.
-+
-+* Synopsis of compile-time options:
-+
-+ People have reported using previous versions of this malloc on all
-+ versions of Unix, sometimes by tweaking some of the defines
-+ below. It has been tested most extensively on Solaris and
-+ Linux. It is also reported to work on WIN32 platforms.
-+ People also report using it in stand-alone embedded systems.
-+
-+ The implementation is in straight, hand-tuned ANSI C. It is not
-+ at all modular. (Sorry!) It uses a lot of macros. To be at all
-+ usable, this code should be compiled using an optimizing compiler
-+ (for example gcc -O3) that can simplify expressions and control
-+ paths. (FAQ: some macros import variables as arguments rather than
-+ declare locals because people reported that some debuggers
-+ otherwise get confused.)
-+
-+ OPTION DEFAULT VALUE
-+
-+ Compilation Environment options:
-+
-+ __STD_C derived from C compiler defines
-+ WIN32 NOT defined
-+ HAVE_MEMCPY defined
-+ USE_MEMCPY 1 if HAVE_MEMCPY is defined
-+ HAVE_MMAP defined as 1
-+ MMAP_CLEARS 1
-+ HAVE_MREMAP 0 unless linux defined
-+ malloc_getpagesize derived from system #includes, or 4096 if not
-+ HAVE_USR_INCLUDE_MALLOC_H NOT defined
-+ LACKS_UNISTD_H NOT defined unless WIN32
-+ LACKS_SYS_PARAM_H NOT defined unless WIN32
-+ LACKS_SYS_MMAN_H NOT defined unless WIN32
-+
-+ Changing default word sizes:
-+
-+ INTERNAL_SIZE_T size_t
-+ MALLOC_ALIGNMENT 2 * sizeof(INTERNAL_SIZE_T)
-+
-+ Configuration and functionality options:
-+
-+ USE_DL_PREFIX NOT defined
-+ USE_PUBLIC_MALLOC_WRAPPERS NOT defined
-+ USE_MALLOC_LOCK NOT defined
-+ DEBUG NOT defined
-+ REALLOC_ZERO_BYTES_FREES NOT defined
-+ MALLOC_FAILURE_ACTION errno = ENOMEM, if __STD_C defined, else no-op
-+ TRIM_FASTBINS 0
-+
-+ Options for customizing MORECORE:
-+
-+ MORECORE sbrk
-+ MORECORE_CONTIGUOUS 1
-+ MORECORE_CANNOT_TRIM NOT defined
-+ MMAP_AS_MORECORE_SIZE (1024 * 1024)
-+
-+ Tuning options that are also dynamically changeable via mallopt:
-+
-+ DEFAULT_MXFAST 64
-+ DEFAULT_TRIM_THRESHOLD 128 * 1024
-+ DEFAULT_TOP_PAD 0
-+ DEFAULT_MMAP_THRESHOLD 128 * 1024
-+ DEFAULT_MMAP_MAX 65536
-+
-+ There are several other #defined constants and macros that you
-+ probably don't want to touch unless you are extending or adapting malloc.
-+*/
-+
-+/*
-+ WIN32 sets up defaults for MS environment and compilers.
-+ Otherwise defaults are for unix.
-+*/
-+
-+/* #define WIN32 */
-+
-+#ifdef WIN32
-+
-+#define WIN32_LEAN_AND_MEAN
-+#include <windows.h>
-+
-+/* Win32 doesn't supply or need the following headers */
-+#define LACKS_UNISTD_H
-+#define LACKS_SYS_PARAM_H
-+#define LACKS_SYS_MMAN_H
-+
-+/* Use the supplied emulation of sbrk */
-+#define MORECORE sbrk
-+#define MORECORE_CONTIGUOUS 1
-+#define MORECORE_FAILURE ((void*)(-1))
-+
-+/* Use the supplied emulation of mmap and munmap */
-+#define HAVE_MMAP 1
-+#define MUNMAP_FAILURE (-1)
-+#define MMAP_CLEARS 1
-+
-+/* These values don't really matter in windows mmap emulation */
-+#define MAP_PRIVATE 1
-+#define MAP_ANONYMOUS 2
-+#define PROT_READ 1
-+#define PROT_WRITE 2
-+
-+/* Emulation functions defined at the end of this file */
-+
-+/* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */
-+#ifdef USE_MALLOC_LOCK
-+static int slwait(int *sl);
-+static int slrelease(int *sl);
-+#endif
-+
-+static long getpagesize(void);
-+static long getregionsize(void);
-+static void *sbrk(long size);
-+static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg);
-+static long munmap(void *ptr, long size);
-+
-+static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed);
-+static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user);
-+
-+#endif
-+
-+/*
-+ __STD_C should be nonzero if using ANSI-standard C compiler, a C++
-+ compiler, or a C compiler sufficiently close to ANSI to get away
-+ with it.
-+*/
-+
-+#ifndef __STD_C
-+#if defined(__STDC__) || defined(_cplusplus)
-+#define __STD_C 1
-+#else
-+#define __STD_C 0
-+#endif
-+#endif /*__STD_C*/
-+
-+
-+/*
-+ Void_t* is the pointer type that malloc should say it returns
-+*/
-+
-+#ifndef Void_t
-+#if (__STD_C || defined(WIN32))
-+#define Void_t void
-+#else
-+#define Void_t char
-+#endif
-+#endif /*Void_t*/
-+
-+#if __STD_C
-+#include <stddef.h> /* for size_t */
-+#else
-+#include <sys/types.h>
-+#endif
-+
-+#ifdef __cplusplus
-+extern "C" {
-+#endif
-+
-+/* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */
-+
-+/* #define LACKS_UNISTD_H */
-+
-+#ifndef LACKS_UNISTD_H
-+#include <unistd.h>
-+#endif
-+
-+/* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */
-+
-+/* #define LACKS_SYS_PARAM_H */
-+
-+
-+#include <stdio.h> /* needed for malloc_stats */
-+#include <errno.h> /* needed for optional MALLOC_FAILURE_ACTION */
-+
-+
-+/*
-+ Debugging:
-+
-+ Because freed chunks may be overwritten with bookkeeping fields, this
-+ malloc will often die when freed memory is overwritten by user
-+ programs. This can be very effective (albeit in an annoying way)
-+ in helping track down dangling pointers.
-+
-+ If you compile with -DDEBUG, a number of assertion checks are
-+ enabled that will catch more memory errors. You probably won't be
-+ able to make much sense of the actual assertion errors, but they
-+ should help you locate incorrectly overwritten memory. The
-+ checking is fairly extensive, and will slow down execution
-+ noticeably. Calling malloc_stats or mallinfo with DEBUG set will
-+ attempt to check every non-mmapped allocated and free chunk in the
-+ course of computing the summmaries. (By nature, mmapped regions
-+ cannot be checked very much automatically.)
-+
-+ Setting DEBUG may also be helpful if you are trying to modify
-+ this code. The assertions in the check routines spell out in more
-+ detail the assumptions and invariants underlying the algorithms.
-+
-+ Setting DEBUG does NOT provide an automated mechanism for checking
-+ that all accesses to malloced memory stay within their
-+ bounds. However, there are several add-ons and adaptations of this
-+ or other mallocs available that do this.
-+*/
-+
-+#ifdef DEBUG
-+#include <assert.h>
-+#else
-+#define assert(x) ((void)0)
-+#endif
-+
-+
-+/*
-+ INTERNAL_SIZE_T is the word-size used for internal bookkeeping
-+ of chunk sizes.
-+
-+ The default version is the same as size_t.
-+
-+ While not strictly necessary, it is best to define this as an
-+ unsigned type, even if size_t is a signed type. This may avoid some
-+ artificial size limitations on some systems.
-+
-+ On a 64-bit machine, you may be able to reduce malloc overhead by
-+ defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the
-+ expense of not being able to handle more than 2^32 of malloced
-+ space. If this limitation is acceptable, you are encouraged to set
-+ this unless you are on a platform requiring 16byte alignments. In
-+ this case the alignment requirements turn out to negate any
-+ potential advantages of decreasing size_t word size.
-+
-+ Implementors: Beware of the possible combinations of:
-+ - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,
-+ and might be the same width as int or as long
-+ - size_t might have different width and signedness as INTERNAL_SIZE_T
-+ - int and long might be 32 or 64 bits, and might be the same width
-+ To deal with this, most comparisons and difference computations
-+ among INTERNAL_SIZE_Ts should cast them to unsigned long, being
-+ aware of the fact that casting an unsigned int to a wider long does
-+ not sign-extend. (This also makes checking for negative numbers
-+ awkward.) Some of these casts result in harmless compiler warnings
-+ on some systems.
-+*/
-+
-+#ifndef INTERNAL_SIZE_T
-+#define INTERNAL_SIZE_T size_t
-+#endif
-+
-+/* The corresponding word size */
-+#define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
-+
-+
-+/*
-+ MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
-+ It must be a power of two at least 2 * SIZE_SZ, even on machines
-+ for which smaller alignments would suffice. It may be defined as
-+ larger than this though. Note however that code and data structures
-+ are optimized for the case of 8-byte alignment.
-+*/
-+
-+
-+#ifndef MALLOC_ALIGNMENT
-+#define MALLOC_ALIGNMENT (2 * SIZE_SZ)
-+#endif
-+
-+/* The corresponding bit mask value */
-+#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
-+
-+
-+
-+/*
-+ REALLOC_ZERO_BYTES_FREES should be set if a call to
-+ realloc with zero bytes should be the same as a call to free.
-+ Some people think it should. Otherwise, since this malloc
-+ returns a unique pointer for malloc(0), so does realloc(p, 0).
-+*/
-+
-+/* #define REALLOC_ZERO_BYTES_FREES */
-+
-+/*
-+ TRIM_FASTBINS controls whether free() of a very small chunk can
-+ immediately lead to trimming. Setting to true (1) can reduce memory
-+ footprint, but will almost always slow down programs that use a lot
-+ of small chunks.
-+
-+ Define this only if you are willing to give up some speed to more
-+ aggressively reduce system-level memory footprint when releasing
-+ memory in programs that use many small chunks. You can get
-+ essentially the same effect by setting MXFAST to 0, but this can
-+ lead to even greater slowdowns in programs using many small chunks.
-+ TRIM_FASTBINS is an in-between compile-time option, that disables
-+ only those chunks bordering topmost memory from being placed in
-+ fastbins.
-+*/
-+
-+#ifndef TRIM_FASTBINS
-+#define TRIM_FASTBINS 0
-+#endif
-+
-+
-+/*
-+ USE_DL_PREFIX will prefix all public routines with the string 'dl'.
-+ This is necessary when you only want to use this malloc in one part
-+ of a program, using your regular system malloc elsewhere.
-+*/
-+
-+/* #define USE_DL_PREFIX */
-+
-+
-+/*
-+ USE_MALLOC_LOCK causes wrapper functions to surround each
-+ callable routine with pthread mutex lock/unlock.
-+
-+ USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined
-+*/
-+
-+
-+/* #define USE_MALLOC_LOCK */
-+
-+
-+/*
-+ If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is
-+ actually a wrapper function that first calls MALLOC_PREACTION, then
-+ calls the internal routine, and follows it with
-+ MALLOC_POSTACTION. This is needed for locking, but you can also use
-+ this, without USE_MALLOC_LOCK, for purposes of interception,
-+ instrumentation, etc. It is a sad fact that using wrappers often
-+ noticeably degrades performance of malloc-intensive programs.
-+*/
-+
-+#ifdef USE_MALLOC_LOCK
-+#define USE_PUBLIC_MALLOC_WRAPPERS
-+#else
-+/* #define USE_PUBLIC_MALLOC_WRAPPERS */
-+#endif
-+
-+
-+/*
-+ Two-phase name translation.
-+ All of the actual routines are given mangled names.
-+ When wrappers are used, they become the public callable versions.
-+ When DL_PREFIX is used, the callable names are prefixed.
-+*/
-+
-+#ifndef USE_PUBLIC_MALLOC_WRAPPERS
-+#define cALLOc public_cALLOc
-+#define fREe public_fREe
-+#define cFREe public_cFREe
-+#define mALLOc public_mALLOc
-+#define mEMALIGn public_mEMALIGn
-+#define rEALLOc public_rEALLOc
-+#define vALLOc public_vALLOc
-+#define pVALLOc public_pVALLOc
-+#define mALLINFo public_mALLINFo
-+#define mALLOPt public_mALLOPt
-+#define mTRIm public_mTRIm
-+#define mSTATs public_mSTATs
-+#define mUSABLe public_mUSABLe
-+#define iCALLOc public_iCALLOc
-+#define iCOMALLOc public_iCOMALLOc
-+#endif
-+
-+#ifdef USE_DL_PREFIX
-+#define public_cALLOc dlcalloc
-+#define public_fREe dlfree
-+#define public_cFREe dlcfree
-+#define public_mALLOc dlmalloc
-+#define public_mEMALIGn dlmemalign
-+#define public_rEALLOc dlrealloc
-+#define public_vALLOc dlvalloc
-+#define public_pVALLOc dlpvalloc
-+#define public_mALLINFo dlmallinfo
-+#define public_mALLOPt dlmallopt
-+#define public_mTRIm dlmalloc_trim
-+#define public_mSTATs dlmalloc_stats
-+#define public_mUSABLe dlmalloc_usable_size
-+#define public_iCALLOc dlindependent_calloc
-+#define public_iCOMALLOc dlindependent_comalloc
-+#else /* USE_DL_PREFIX */
-+#define public_cALLOc calloc
-+#define public_fREe free
-+#define public_cFREe cfree
-+#define public_mALLOc malloc
-+#define public_mEMALIGn memalign
-+#define public_rEALLOc realloc
-+#define public_vALLOc valloc
-+#define public_pVALLOc pvalloc
-+#define public_mALLINFo mallinfo
-+#define public_mALLOPt mallopt
-+#define public_mTRIm malloc_trim
-+#define public_mSTATs malloc_stats
-+#define public_mUSABLe malloc_usable_size
-+#define public_iCALLOc independent_calloc
-+#define public_iCOMALLOc independent_comalloc
-+#endif /* USE_DL_PREFIX */
-+
-+
-+/*
-+ HAVE_MEMCPY should be defined if you are not otherwise using
-+ ANSI STD C, but still have memcpy and memset in your C library
-+ and want to use them in calloc and realloc. Otherwise simple
-+ macro versions are defined below.
-+
-+ USE_MEMCPY should be defined as 1 if you actually want to
-+ have memset and memcpy called. People report that the macro
-+ versions are faster than libc versions on some systems.
-+
-+ Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks
-+ (of <= 36 bytes) are manually unrolled in realloc and calloc.
-+*/
-+
-+/* If it's available it's defined in config.h. */
-+/* #define HAVE_MEMCPY */
-+
-+#ifndef USE_MEMCPY
-+#ifdef HAVE_MEMCPY
-+#define USE_MEMCPY 1
-+#else
-+#define USE_MEMCPY 0
-+#endif
-+#endif
-+
-+
-+#if (__STD_C || defined(HAVE_MEMCPY))
-+
-+#ifdef WIN32
-+/* On Win32 memset and memcpy are already declared in windows.h */
-+#else
-+#if __STD_C
-+void* memset(void*, int, size_t);
-+void* memcpy(void*, const void*, size_t);
-+#else
-+Void_t* memset();
-+Void_t* memcpy();
-+#endif
-+#endif
-+#endif
-+
-+/*
-+ MALLOC_FAILURE_ACTION is the action to take before "return 0" when
-+ malloc fails to be able to return memory, either because memory is
-+ exhausted or because of illegal arguments.
-+
-+ By default, sets errno if running on STD_C platform, else does nothing.
-+*/
-+
-+#ifndef MALLOC_FAILURE_ACTION
-+#if __STD_C
-+#define MALLOC_FAILURE_ACTION \
-+ errno = ENOMEM;
-+
-+#else
-+#define MALLOC_FAILURE_ACTION
-+#endif
-+#endif
-+
-+/*
-+ MORECORE-related declarations. By default, rely on sbrk
-+*/
-+
-+
-+#ifdef LACKS_UNISTD_H
-+#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
-+#if __STD_C
-+extern Void_t* sbrk(ptrdiff_t);
-+#else
-+extern Void_t* sbrk();
-+#endif
-+#endif
-+#endif
-+
-+/*
-+ MORECORE is the name of the routine to call to obtain more memory
-+ from the system. See below for general guidance on writing
-+ alternative MORECORE functions, as well as a version for WIN32 and a
-+ sample version for pre-OSX macos.
-+*/
-+
-+#ifndef MORECORE
-+#define MORECORE sbrk
-+#endif
-+
-+/*
-+ MORECORE_FAILURE is the value returned upon failure of MORECORE
-+ as well as mmap. Since it cannot be an otherwise valid memory address,
-+ and must reflect values of standard sys calls, you probably ought not
-+ try to redefine it.
-+*/
-+
-+#ifndef MORECORE_FAILURE
-+#define MORECORE_FAILURE (-1)
-+#endif
-+
-+/*
-+ If MORECORE_CONTIGUOUS is true, take advantage of fact that
-+ consecutive calls to MORECORE with positive arguments always return
-+ contiguous increasing addresses. This is true of unix sbrk. Even
-+ if not defined, when regions happen to be contiguous, malloc will
-+ permit allocations spanning regions obtained from different
-+ calls. But defining this when applicable enables some stronger
-+ consistency checks and space efficiencies.
-+*/
-+
-+#ifndef MORECORE_CONTIGUOUS
-+#define MORECORE_CONTIGUOUS 1
-+#endif
-+
-+/*
-+ Define MORECORE_CANNOT_TRIM if your version of MORECORE
-+ cannot release space back to the system when given negative
-+ arguments. This is generally necessary only if you are using
-+ a hand-crafted MORECORE function that cannot handle negative arguments.
-+*/
-+
-+/* #define MORECORE_CANNOT_TRIM */
-+
-+
-+/*
-+ Define HAVE_MMAP as true to optionally make malloc() use mmap() to
-+ allocate very large blocks. These will be returned to the
-+ operating system immediately after a free(). Also, if mmap
-+ is available, it is used as a backup strategy in cases where
-+ MORECORE fails to provide space from system.
-+
-+ This malloc is best tuned to work with mmap for large requests.
-+ If you do not have mmap, operations involving very large chunks (1MB
-+ or so) may be slower than you'd like.
-+*/
-+
-+#ifndef HAVE_MMAP
-+#define HAVE_MMAP 1
-+#endif
-+
-+#if HAVE_MMAP
-+/*
-+ Standard unix mmap using /dev/zero clears memory so calloc doesn't
-+ need to.
-+*/
-+
-+#ifndef MMAP_CLEARS
-+#define MMAP_CLEARS 1
-+#endif
-+
-+#else /* no mmap */
-+#ifndef MMAP_CLEARS
-+#define MMAP_CLEARS 0
-+#endif
-+#endif
-+
-+
-+/*
-+ MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if
-+ sbrk fails, and mmap is used as a backup (which is done only if
-+ HAVE_MMAP). The value must be a multiple of page size. This
-+ backup strategy generally applies only when systems have "holes" in
-+ address space, so sbrk cannot perform contiguous expansion, but
-+ there is still space available on system. On systems for which
-+ this is known to be useful (i.e. most linux kernels), this occurs
-+ only when programs allocate huge amounts of memory. Between this,
-+ and the fact that mmap regions tend to be limited, the size should
-+ be large, to avoid too many mmap calls and thus avoid running out
-+ of kernel resources.
-+*/
-+
-+#ifndef MMAP_AS_MORECORE_SIZE
-+#define MMAP_AS_MORECORE_SIZE (1024 * 1024)
-+#endif
-+
-+/*
-+ Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
-+ large blocks. This is currently only possible on Linux with
-+ kernel versions newer than 1.3.77.
-+*/
-+
-+#ifndef HAVE_MREMAP
-+#if defined(linux) || defined(__linux__) || defined(__linux)
-+#define HAVE_MREMAP 1
-+#else
-+#define HAVE_MREMAP 0
-+#endif
-+
-+#endif /* HAVE_MMAP */
-+
-+
-+/*
-+ The system page size. To the extent possible, this malloc manages
-+ memory from the system in page-size units. Note that this value is
-+ cached during initialization into a field of malloc_state. So even
-+ if malloc_getpagesize is a function, it is only called once.
-+
-+ The following mechanics for getpagesize were adapted from bsd/gnu
-+ getpagesize.h. If none of the system-probes here apply, a value of
-+ 4096 is used, which should be OK: If they don't apply, then using
-+ the actual value probably doesn't impact performance.
-+*/
-+
-+
-+#ifndef malloc_getpagesize
-+
-+#ifndef LACKS_UNISTD_H
-+# include <unistd.h>
-+#endif
-+
-+# 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 */
-+# define malloc_getpagesize getpagesize()
-+# else
-+# ifndef LACKS_SYS_PARAM_H
-+# include <sys/param.h>
-+# endif
-+# ifdef EXEC_PAGESIZE
-+# define malloc_getpagesize EXEC_PAGESIZE
-+# else
-+# ifdef NBPG
-+# ifndef CLSIZE
-+# define malloc_getpagesize NBPG
-+# else
-+# define malloc_getpagesize (NBPG * CLSIZE)
-+# endif
-+# else
-+# ifdef NBPC
-+# define malloc_getpagesize NBPC
-+# else
-+# ifdef PAGESIZE
-+# define malloc_getpagesize PAGESIZE
-+# else /* just guess */
-+# define malloc_getpagesize (4096)
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+#endif
-+
-+/*
-+ This version of malloc supports the standard SVID/XPG mallinfo
-+ routine that returns a struct containing usage properties and
-+ statistics. It should work on any SVID/XPG compliant system that has
-+ a /usr/include/malloc.h defining struct mallinfo. (If you'd like to
-+ install such a thing yourself, cut out the preliminary declarations
-+ as described above and below and save them in a malloc.h file. But
-+ there's no compelling reason to bother to do this.)
-+
-+ The main declaration needed is the mallinfo struct that is returned
-+ (by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a
-+ bunch of field that are not even meaningful in this version of
-+ malloc. These fields are are instead filled by mallinfo() with
-+ other numbers that might be of interest.
-+
-+ HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
-+ /usr/include/malloc.h file that includes a declaration of struct
-+ mallinfo. If so, it is included; else an SVID2/XPG2 compliant
-+ version is declared below. These must be precisely the same for
-+ mallinfo() to work. The original SVID version of this struct,
-+ defined on most systems with mallinfo, declares all fields as
-+ ints. But some others define as unsigned long. If your system
-+ defines the fields using a type of different width than listed here,
-+ you must #include your system version and #define
-+ HAVE_USR_INCLUDE_MALLOC_H.
-+*/
-+
-+/* #define HAVE_USR_INCLUDE_MALLOC_H */
-+
-+/*#ifdef HAVE_USR_INCLUDE_MALLOC_H*/
-+#if 0
-+#include "/usr/include/malloc.h"
-+#else
-+
-+/* SVID2/XPG mallinfo structure */
-+
-+struct mallinfo {
-+ int arena; /* non-mmapped space allocated from system */
-+ int ordblks; /* number of free chunks */
-+ int smblks; /* number of fastbin blocks */
-+ int hblks; /* number of mmapped regions */
-+ int hblkhd; /* space in mmapped regions */
-+ int usmblks; /* maximum total allocated space */
-+ int fsmblks; /* space available in freed fastbin blocks */
-+ int uordblks; /* total allocated space */
-+ int fordblks; /* total free space */
-+ int keepcost; /* top-most, releasable (via malloc_trim) space */
-+};
-+
-+/*
-+ SVID/XPG defines four standard parameter numbers for mallopt,
-+ normally defined in malloc.h. Only one of these (M_MXFAST) is used
-+ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
-+ so setting them has no effect. But this malloc also supports other
-+ options in mallopt described below.
-+*/
-+#endif
-+
-+
-+/* ---------- description of public routines ------------ */
-+
-+/*
-+ malloc(size_t n)
-+ Returns a pointer to a newly allocated chunk of at least n bytes, or null
-+ if no space is available. Additionally, on failure, errno is
-+ set to ENOMEM on ANSI C systems.
-+
-+ If n is zero, malloc returns a minumum-sized chunk. (The minimum
-+ size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
-+ systems.) On most systems, size_t is an unsigned type, so calls
-+ with negative arguments 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.
-+*/
-+#if __STD_C
-+Void_t* public_mALLOc(size_t);
-+#else
-+Void_t* public_mALLOc();
-+#endif
-+
-+/*
-+ free(Void_t* 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. It can have arbitrary (i.e., bad!)
-+ effects if p has already been freed.
-+
-+ Unless disabled (using mallopt), freeing very large spaces will
-+ when possible, automatically trigger operations that give
-+ back unused memory to the system, thus reducing program footprint.
-+*/
-+#if __STD_C
-+void public_fREe(Void_t*);
-+#else
-+void public_fREe();
-+#endif
-+
-+/*
-+ calloc(size_t n_elements, size_t element_size);
-+ Returns a pointer to n_elements * element_size bytes, with all locations
-+ set to zero.
-+*/
-+#if __STD_C
-+Void_t* public_cALLOc(size_t, size_t);
-+#else
-+Void_t* public_cALLOc();
-+#endif
-+
-+/*
-+ realloc(Void_t* 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
-+ if no space is available.
-+
-+ The returned pointer may or may not be the same as p. The algorithm
-+ prefers extending p when possible, otherwise it employs the
-+ equivalent of a malloc-copy-free sequence.
-+
-+ If p is null, realloc is equivalent to malloc.
-+
-+ If space is not available, realloc returns null, errno is set (if on
-+ ANSI) and p is NOT freed.
-+
-+ if n is for fewer bytes than already held by p, the newly unused
-+ space is lopped off and freed if possible. Unless the #define
-+ REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of
-+ zero (re)allocates a minimum-sized chunk.
-+
-+ Large chunks that were internally obtained via mmap will always
-+ be reallocated using malloc-copy-free sequences unless
-+ the system supports MREMAP (currently only linux).
-+
-+ The old unix realloc convention of allowing the last-free'd chunk
-+ to be used as an argument to realloc is not supported.
-+*/
-+#if __STD_C
-+Void_t* public_rEALLOc(Void_t*, size_t);
-+#else
-+Void_t* public_rEALLOc();
-+#endif
-+
-+/*
-+ 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.
-+
-+ The alignment argument should be a power of two. If the argument is
-+ not a power of two, the nearest greater power is used.
-+ 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.
-+*/
-+#if __STD_C
-+Void_t* public_mEMALIGn(size_t, size_t);
-+#else
-+Void_t* public_mEMALIGn();
-+#endif
-+
-+/*
-+ 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.
-+*/
-+#if __STD_C
-+Void_t* public_vALLOc(size_t);
-+#else
-+Void_t* public_vALLOc();
-+#endif
-+
-+
-+
-+/*
-+ 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
-+ corresponding parameter to the argument value if it can (i.e., so
-+ long as the value is meaningful), and returns 1 if successful else
-+ 0. SVID/XPG/ANSI defines four standard param numbers for mallopt,
-+ normally defined in malloc.h. Only one of these (M_MXFAST) is used
-+ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
-+ so setting them has no effect. But this malloc also supports four
-+ other options in mallopt. See below for details. Briefly, supported
-+ parameters are as follows (listed defaults are for "typical"
-+ configurations).
-+
-+ Symbol param # default allowed param values
-+ M_MXFAST 1 64 0-80 (0 disables fastbins)
-+ M_TRIM_THRESHOLD -1 128*1024 any (-1U disables trimming)
-+ M_TOP_PAD -2 0 any
-+ M_MMAP_THRESHOLD -3 128*1024 any (or 0 if no MMAP support)
-+ M_MMAP_MAX -4 65536 any (0 disables use of mmap)
-+*/
-+#if __STD_C
-+int public_mALLOPt(int, int);
-+#else
-+int public_mALLOPt();
-+#endif
-+
-+
-+/*
-+ mallinfo()
-+ Returns (by copy) a struct containing various summary statistics:
-+
-+ arena: current total non-mmapped bytes allocated from system
-+ ordblks: the number of free chunks
-+ smblks: the number of fastbin blocks (i.e., small chunks that
-+ have been freed but not use resused or consolidated)
-+ hblks: current number of mmapped regions
-+ hblkhd: total bytes held in mmapped regions
-+ usmblks: the maximum total allocated space. This will be greater
-+ than current total if trimming has occurred.
-+ fsmblks: total bytes held in fastbin blocks
-+ uordblks: current total allocated space (normal or mmapped)
-+ fordblks: total free space
-+ keepcost: the maximum number of bytes that could ideally be released
-+ back to system via malloc_trim. ("ideally" means that
-+ it ignores page restrictions etc.)
-+
-+ Because these fields are ints, but internal bookkeeping may
-+ be kept as longs, the reported values may wrap around zero and
-+ thus be inaccurate.
-+*/
-+#if __STD_C
-+struct mallinfo public_mALLINFo(void);
-+#else
-+struct mallinfo public_mALLINFo();
-+#endif
-+
-+/*
-+ independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
-+
-+ independent_calloc is similar to calloc, but instead of returning a
-+ single cleared space, it returns an array of pointers to n_elements
-+ independent elements that can hold contents of size elem_size, each
-+ of which starts out cleared, and can be independently freed,
-+ realloc'ed etc. The elements are guaranteed to be adjacently
-+ allocated (this is not guaranteed to occur with multiple callocs or
-+ mallocs), which may also improve cache locality in some
-+ applications.
-+
-+ The "chunks" argument is optional (i.e., may be null, which is
-+ probably the most typical usage). If it is null, the returned array
-+ is itself dynamically allocated and should also be freed when it is
-+ no longer needed. Otherwise, the chunks array must be of at least
-+ n_elements in length. It is filled in with the pointers to the
-+ chunks.
-+
-+ In either case, independent_calloc returns this pointer array, or
-+ null if the allocation failed. If n_elements is zero and "chunks"
-+ is null, it returns a chunk representing an array with zero elements
-+ (which should be freed if not wanted).
-+
-+ Each element must be individually freed when it is no longer
-+ needed. If you'd like to instead be able to free all at once, you
-+ should instead use regular calloc and assign pointers into this
-+ space to represent elements. (In this case though, you cannot
-+ independently free elements.)
-+
-+ independent_calloc simplifies and speeds up implementations of many
-+ kinds of pools. It may also be useful when constructing large data
-+ structures that initially have a fixed number of fixed-sized nodes,
-+ but the number is not known at compile time, and some of the nodes
-+ may later need to be freed. For example:
-+
-+ struct Node { int item; struct Node* next; };
-+
-+ struct Node* build_list() {
-+ struct Node** pool;
-+ int n = read_number_of_nodes_needed();
-+ if (n <= 0) return 0;
-+ pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
-+ if (pool == 0) die();
-+ // organize into a linked list...
-+ struct Node* first = pool[0];
-+ for (i = 0; i < n-1; ++i)
-+ pool[i]->next = pool[i+1];
-+ free(pool); // Can now free the array (or not, if it is needed later)
-+ return first;
-+ }
-+*/
-+#if __STD_C
-+Void_t** public_iCALLOc(size_t, size_t, Void_t**);
-+#else
-+Void_t** public_iCALLOc();
-+#endif
-+
-+/*
-+ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
-+
-+ independent_comalloc allocates, all at once, a set of n_elements
-+ chunks with sizes indicated in the "sizes" array. It returns
-+ an array of pointers to these elements, each of which can be
-+ independently freed, realloc'ed etc. The elements are guaranteed to
-+ be adjacently allocated (this is not guaranteed to occur with
-+ multiple callocs or mallocs), which may also improve cache locality
-+ in some applications.
-+
-+ The "chunks" argument is optional (i.e., may be null). If it is null
-+ the returned array is itself dynamically allocated and should also
-+ be freed when it is no longer needed. Otherwise, the chunks array
-+ must be of at least n_elements in length. It is filled in with the
-+ pointers to the chunks.
-+
-+ In either case, independent_comalloc returns this pointer array, or
-+ null if the allocation failed. If n_elements is zero and chunks is
-+ null, it returns a chunk representing an array with zero elements
-+ (which should be freed if not wanted).
-+
-+ Each element must be individually freed when it is no longer
-+ needed. If you'd like to instead be able to free all at once, you
-+ should instead use a single regular malloc, and assign pointers at
-+ particular offsets in the aggregate space. (In this case though, you
-+ cannot independently free elements.)
-+
-+ independent_comallac differs from independent_calloc in that each
-+ element may have a different size, and also that it does not
-+ automatically clear elements.
-+
-+ independent_comalloc can be used to speed up allocation in cases
-+ where several structs or objects must always be allocated at the
-+ same time. For example:
-+
-+ struct Head { ... }
-+ struct Foot { ... }
-+
-+ void send_message(char* msg) {
-+ int msglen = strlen(msg);
-+ size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
-+ void* chunks[3];
-+ if (independent_comalloc(3, sizes, chunks) == 0)
-+ die();
-+ struct Head* head = (struct Head*)(chunks[0]);
-+ char* body = (char*)(chunks[1]);
-+ struct Foot* foot = (struct Foot*)(chunks[2]);
-+ // ...
-+ }
-+
-+ In general though, independent_comalloc is worth using only for
-+ larger values of n_elements. For small values, you probably won't
-+ detect enough difference from series of malloc calls to bother.
-+
-+ 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.
-+*/
-+#if __STD_C
-+Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
-+#else
-+Void_t** public_iCOMALLOc();
-+#endif
-+
-+
-+/*
-+ pvalloc(size_t n);
-+ Equivalent to valloc(minimum-page-that-holds(n)), that is,
-+ round up n to nearest pagesize.
-+ */
-+#if __STD_C
-+Void_t* public_pVALLOc(size_t);
-+#else
-+Void_t* public_pVALLOc();
-+#endif
-+
-+/*
-+ cfree(Void_t* p);
-+ Equivalent to free(p).
-+
-+ cfree is needed/defined on some systems that pair it with calloc,
-+ for odd historical reasons (such as: cfree is used in example
-+ code in the first edition of K&R).
-+*/
-+#if __STD_C
-+void public_cFREe(Void_t*);
-+#else
-+void public_cFREe();
-+#endif
-+
-+/*
-+ malloc_trim(size_t pad);
-+
-+ If possible, gives memory back to the system (via negative
-+ arguments to sbrk) if there is unused memory at the `high' end of
-+ the malloc pool. You can call this after freeing large blocks of
-+ memory to potentially reduce the system-level memory requirements
-+ of a program. However, it cannot guarantee to reduce memory. Under
-+ some allocation patterns, some large free blocks of memory will be
-+ locked between two used chunks, so they cannot be given back to
-+ the system.
-+
-+ The `pad' argument to malloc_trim represents the amount of free
-+ trailing space to leave untrimmed. If this argument is zero,
-+ only the minimum amount of memory to maintain internal data
-+ structures will be left (one page or less). Non-zero arguments
-+ can be supplied to maintain enough 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.
-+ On systems that do not support "negative sbrks", it will always
-+ rreturn 0.
-+*/
-+#if __STD_C
-+int public_mTRIm(size_t);
-+#else
-+int public_mTRIm();
-+#endif
-+
-+/*
-+ malloc_usable_size(Void_t* p);
-+
-+ Returns the number of bytes you can actually use in
-+ an allocated chunk, which may be more than you requested (although
-+ often not) due to alignment and minimum size constraints.
-+ You can use this many bytes without worrying about
-+ overwriting other allocated objects. This is not a particularly great
-+ programming practice. malloc_usable_size can be more useful in
-+ debugging and assertions, for example:
-+
-+ p = malloc(n);
-+ assert(malloc_usable_size(p) >= 256);
-+
-+*/
-+#if __STD_C
-+size_t public_mUSABLe(Void_t*);
-+#else
-+size_t public_mUSABLe();
-+#endif
-+
-+/*
-+ 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
-+ current if malloc_trim and/or munmap got called), and the current
-+ number of bytes allocated via malloc (or realloc, etc) but not yet
-+ freed. Note that this is the number of bytes allocated, not the
-+ number requested. It will be larger than the number requested
-+ because of alignment and bookkeeping overhead. Because it includes
-+ alignment wastage as being in use, this figure may be greater than
-+ zero even when no user-level chunks are allocated.
-+
-+ The reported current and maximum system memory can be inaccurate if
-+ a program makes other calls to system memory allocation functions
-+ (normally sbrk) outside of malloc.
-+
-+ malloc_stats prints only the most commonly interesting statistics.
-+ More information can be obtained by calling mallinfo.
-+
-+*/
-+#if __STD_C
-+void public_mSTATs();
-+#else
-+void public_mSTATs();
-+#endif
-+
-+/* mallopt tuning options */
-+
-+/*
-+ M_MXFAST is the maximum request size used for "fastbins", special bins
-+ that hold returned chunks without consolidating their spaces. This
-+ enables future requests for chunks of the same size to be handled
-+ very quickly, but can increase fragmentation, and thus increase the
-+ overall memory footprint of a program.
-+
-+ This malloc manages fastbins very conservatively yet still
-+ efficiently, so fragmentation is rarely a problem for values less
-+ than or equal to the default. The maximum supported value of MXFAST
-+ is 80. You wouldn't want it any higher than this anyway. Fastbins
-+ are designed especially for use with many small structs, objects or
-+ strings -- the default handles structs/objects/arrays with sizes up
-+ to 8 4byte fields, or small strings representing words, tokens,
-+ etc. Using fastbins for larger objects normally worsens
-+ fragmentation without improving speed.
-+
-+ M_MXFAST is set in REQUEST size units. It is internally used in
-+ chunksize units, which adds padding and alignment. You can reduce
-+ M_MXFAST to 0 to disable all use of fastbins. This causes the malloc
-+ algorithm to be a closer approximation of fifo-best-fit in all cases,
-+ not just for larger requests, but will generally cause it to be
-+ slower.
-+*/
-+
-+
-+/* M_MXFAST is a standard SVID/XPG tuning option, usually listed in malloc.h */
-+#ifndef M_MXFAST
-+#define M_MXFAST 1
-+#endif
-+
-+#ifndef DEFAULT_MXFAST
-+#define DEFAULT_MXFAST 64
-+#endif
-+
-+
-+/*
-+ M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
-+ to keep before releasing via malloc_trim in free().
-+
-+ Automatic trimming is mainly useful in long-lived programs.
-+ Because trimming via sbrk can be slow on some systems, and can
-+ sometimes be wasteful (in cases where programs immediately
-+ afterward allocate more large chunks) the value should be high
-+ enough so that your overall system performance would improve by
-+ releasing this much memory.
-+
-+ The trim threshold and the mmap control parameters (see below)
-+ can be traded off with one another. Trimming and mmapping are
-+ two different ways of releasing unused memory back to the
-+ system. Between these two, it is often possible to keep
-+ system-level demands of a long-lived program down to a bare
-+ minimum. For example, in one test suite of sessions measuring
-+ the XF86 X server on Linux, using a trim threshold of 128K and a
-+ mmap threshold of 192K led to near-minimal long term resource
-+ consumption.
-+
-+ If you are using this malloc in a long-lived program, it should
-+ pay to experiment with these values. As a rough guide, you
-+ might set to a value close to the average size of a process
-+ (program) running on your system. Releasing this much memory
-+ would allow such a process to run in memory. Generally, it's
-+ worth it to tune for trimming rather tham memory mapping when a
-+ program undergoes phases where several large chunks are
-+ allocated and released in ways that can reuse each other's
-+ storage, perhaps mixed with phases where there are no such
-+ chunks at all. And in well-behaved long-lived programs,
-+ controlling release of large blocks via trimming versus mapping
-+ is usually faster.
-+
-+ However, in most programs, these parameters serve mainly as
-+ protection against the system-level effects of carrying around
-+ massive amounts of unneeded memory. Since frequent calls to
-+ sbrk, mmap, and munmap otherwise degrade performance, the default
-+ parameters are set to relatively high values that serve only as
-+ safeguards.
-+
-+ The trim value It must be greater than page size to have any useful
-+ effect. To disable trimming completely, you can set to
-+ (unsigned long)(-1)
-+
-+ Trim settings interact with fastbin (MXFAST) settings: Unless
-+ TRIM_FASTBINS is defined, automatic trimming never takes place upon
-+ freeing a chunk with size less than or equal to MXFAST. Trimming is
-+ instead delayed until subsequent freeing of larger chunks. However,
-+ you can still force an attempted trim by calling malloc_trim.
-+
-+ Also, trimming is not generally possible in cases where
-+ the main arena is obtained via mmap.
-+
-+ Note that the trick some people use of mallocing a huge space and
-+ then freeing it at program startup, in an attempt to reserve system
-+ memory, doesn't have the intended effect under automatic trimming,
-+ since that memory will immediately be returned to the system.
-+*/
-+
-+#define M_TRIM_THRESHOLD -1
-+
-+#ifndef DEFAULT_TRIM_THRESHOLD
-+#define DEFAULT_TRIM_THRESHOLD (128 * 1024)
-+#endif
-+
-+/*
-+ M_TOP_PAD is the amount of extra `padding' space to allocate or
-+ retain whenever sbrk is called. It is used in two ways internally:
-+
-+ * When sbrk is called to extend the top of the arena to satisfy
-+ a new malloc request, this much padding is added to the sbrk
-+ request.
-+
-+ * When malloc_trim is called automatically from free(),
-+ it is used as the `pad' argument.
-+
-+ In both cases, the actual amount of padding is rounded
-+ so that the end of the arena is always a system page boundary.
-+
-+ The main reason for using padding is to avoid calling sbrk so
-+ often. Having even a small pad greatly reduces the likelihood
-+ that nearly every malloc request during program start-up (or
-+ after trimming) will invoke sbrk, which needlessly wastes
-+ time.
-+
-+ Automatic rounding-up to page-size units is normally sufficient
-+ to avoid measurable overhead, so the default is 0. However, in
-+ systems where sbrk is relatively slow, it can pay to increase
-+ this value, at the expense of carrying around more memory than
-+ the program needs.
-+*/
-+
-+#define M_TOP_PAD -2
-+
-+#ifndef DEFAULT_TOP_PAD
-+#define DEFAULT_TOP_PAD (0)
-+#endif
-+
-+/*
-+ M_MMAP_THRESHOLD is the request size threshold for using mmap()
-+ to service a request. Requests of at least this size that cannot
-+ be allocated using already-existing space will be serviced via mmap.
-+ (If enough normal freed space already exists it is used instead.)
-+
-+ Using mmap segregates relatively large chunks of memory so that
-+ they can be individually obtained and released from the host
-+ system. A request serviced through mmap is never reused by any
-+ other request (at least not directly; the system may just so
-+ happen to remap successive requests to the same locations).
-+
-+ Segregating space in this way has the benefits that:
-+
-+ 1. Mmapped space can ALWAYS be individually released back
-+ to the system, which helps keep the system level memory
-+ demands of a long-lived program low.
-+ 2. Mapped memory can never become `locked' between
-+ other chunks, as can happen with normally allocated chunks, which
-+ means that even trimming via malloc_trim would not release them.
-+ 3. On some systems with "holes" in address spaces, mmap can obtain
-+ memory that sbrk cannot.
-+
-+ However, it has the disadvantages that:
-+
-+ 1. The space cannot be reclaimed, consolidated, and then
-+ used to service later requests, as happens with normal chunks.
-+ 2. It can lead to more wastage because of mmap page alignment
-+ requirements
-+ 3. It causes malloc performance to be more dependent on host
-+ system memory management support routines which may vary in
-+ implementation quality and may impose arbitrary
-+ limitations. Generally, servicing a request via normal
-+ malloc steps is faster than going through a system's mmap.
-+
-+ The advantages of mmap nearly always outweigh disadvantages for
-+ "large" chunks, but the value of "large" varies across systems. The
-+ default is an empirically derived value that works well in most
-+ systems.
-+*/
-+
-+#define M_MMAP_THRESHOLD -3
-+
-+#ifndef DEFAULT_MMAP_THRESHOLD
-+#define DEFAULT_MMAP_THRESHOLD (128 * 1024)
-+#endif
-+
-+/*
-+ M_MMAP_MAX is the maximum number of requests to simultaneously
-+ service using mmap. This parameter exists because
-+. Some systems have a limited number of internal tables for
-+ use by mmap, and using more than a few of them may degrade
-+ performance.
-+
-+ The default is set to a value that serves only as a safeguard.
-+ Setting to 0 disables use of mmap for servicing large requests. If
-+ HAVE_MMAP is not set, the default value is 0, and attempts to set it
-+ to non-zero values in mallopt will fail.
-+*/
-+
-+#define M_MMAP_MAX -4
-+
-+#ifndef DEFAULT_MMAP_MAX
-+#if HAVE_MMAP
-+#define DEFAULT_MMAP_MAX (65536)
-+#else
-+#define DEFAULT_MMAP_MAX (0)
-+#endif
-+#endif
-+
-+#ifdef __cplusplus
-+}; /* end of extern "C" */
-+#endif
-+
-+/*
-+ ========================================================================
-+ To make a fully customizable malloc.h header file, cut everything
-+ above this line, put into file malloc.h, edit to suit, and #include it
-+ on the next line, as well as in programs that use this malloc.
-+ ========================================================================
-+*/
-+
-+/* #include "malloc.h" */
-+
-+/* --------------------- public wrappers ---------------------- */
-+
-+#ifdef USE_PUBLIC_MALLOC_WRAPPERS
-+
-+/* Declare all routines as internal */
-+#if __STD_C
-+static Void_t* mALLOc(size_t);
-+static void fREe(Void_t*);
-+static Void_t* rEALLOc(Void_t*, size_t);
-+static Void_t* mEMALIGn(size_t, size_t);
-+static Void_t* vALLOc(size_t);
-+static Void_t* pVALLOc(size_t);
-+static Void_t* cALLOc(size_t, size_t);
-+static Void_t** iCALLOc(size_t, size_t, Void_t**);
-+static Void_t** iCOMALLOc(size_t, size_t*, Void_t**);
-+static void cFREe(Void_t*);
-+static int mTRIm(size_t);
-+static size_t mUSABLe(Void_t*);
-+static void mSTATs();
-+static int mALLOPt(int, int);
-+static struct mallinfo mALLINFo(void);
-+#else
-+static Void_t* mALLOc();
-+static void fREe();
-+static Void_t* rEALLOc();
-+static Void_t* mEMALIGn();
-+static Void_t* vALLOc();
-+static Void_t* pVALLOc();
-+static Void_t* cALLOc();
-+static Void_t** iCALLOc();
-+static Void_t** iCOMALLOc();
-+static void cFREe();
-+static int mTRIm();
-+static size_t mUSABLe();
-+static void mSTATs();
-+static int mALLOPt();
-+static struct mallinfo mALLINFo();
-+#endif
-+
-+/*
-+ MALLOC_PREACTION and MALLOC_POSTACTION should be
-+ defined to return 0 on success, and nonzero on failure.
-+ The return value of MALLOC_POSTACTION is currently ignored
-+ in wrapper functions since there is no reasonable default
-+ action to take on failure.
-+*/
-+
-+
-+#ifdef USE_MALLOC_LOCK
-+
-+#ifdef WIN32
-+
-+static int mALLOC_MUTEx;
-+#define MALLOC_PREACTION slwait(&mALLOC_MUTEx)
-+#define MALLOC_POSTACTION slrelease(&mALLOC_MUTEx)
-+
-+#else
-+
-+#if 0
-+#include <pthread.h>
-+
-+static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER;
-+
-+#define MALLOC_PREACTION pthread_mutex_lock(&mALLOC_MUTEx)
-+#define MALLOC_POSTACTION pthread_mutex_unlock(&mALLOC_MUTEx)
-+
-+#else
-+
-+#ifdef KDE_MALLOC_X86
-+#include "x86.h"
-+#elif defined(KDE_MALLOC_AVR32)
-+
-+#include <sched.h>
-+#include <time.h>
-+
-+static __inline__ int q_atomic_swp(volatile unsigned int *ptr,
-+ unsigned int newval)
-+{
-+ register int ret;
-+ asm volatile("xchg %0,%1,%2"
-+ : "=&r"(ret)
-+ : "r"(ptr), "r"(newval)
-+ : "memory", "cc");
-+ return ret;
-+}
-+
-+typedef struct {
-+ volatile unsigned int lock;
-+ int pad0_;
-+} mutex_t;
-+
-+#define MUTEX_INITIALIZER { 0, 0 }
-+
-+static __inline__ int lock(mutex_t *m) {
-+ int cnt = 0;
-+ struct timespec tm;
-+
-+ for(;;) {
-+ if (q_atomic_swp(&m->lock, 1) == 0)
-+ return 0;
-+#ifdef _POSIX_PRIORITY_SCHEDULING
-+ if(cnt < 50) {
-+ sched_yield();
-+ cnt++;
-+ } else
-+#endif
-+ {
-+ tm.tv_sec = 0;
-+ tm.tv_nsec = 2000001;
-+ nanosleep(&tm, NULL);
-+ cnt = 0;
-+ }
-+ }
-+}
-+
-+static __inline__ int unlock(mutex_t *m) {
-+ m->lock = 0;
-+ return 0;
-+}
-+
-+#else
-+#error Unknown spinlock implementation
-+#endif
-+
-+static mutex_t spinlock = MUTEX_INITIALIZER;
-+
-+#define MALLOC_PREACTION lock( &spinlock )
-+#define MALLOC_POSTACTION unlock( &spinlock )
-+
-+#endif
-+
-+#endif /* USE_MALLOC_LOCK */
-+
-+#else
-+
-+/* Substitute anything you like for these */
-+
-+#define MALLOC_PREACTION (0)
-+#define MALLOC_POSTACTION (0)
-+
-+#endif
-+
-+#if 0
-+Void_t* public_mALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+void public_fREe(Void_t* m) {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ fREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = rEALLOc(m, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mEMALIGn(alignment, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_vALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = vALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_pVALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = pVALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_cALLOc(size_t n, size_t elem_size) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = cALLOc(n, elem_size);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+
-+Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {
-+ Void_t** m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = iCALLOc(n, elem_size, chunks);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {
-+ Void_t** m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = iCOMALLOc(n, sizes, chunks);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+void public_cFREe(Void_t* m) {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ cFREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+int public_mTRIm(size_t s) {
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mTRIm(s);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+
-+size_t public_mUSABLe(Void_t* m) {
-+ size_t result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mUSABLe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+
-+void public_mSTATs() {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ mSTATs();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+struct mallinfo public_mALLINFo() {
-+ struct mallinfo m;
-+ if (MALLOC_PREACTION != 0) {
-+ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-+ return nm;
-+ }
-+ m = mALLINFo();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+int public_mALLOPt(int p, int v) {
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mALLOPt(p, v);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+#endif
-+
-+#endif
-+
-+
-+
-+/* ------------- Optional versions of memcopy ---------------- */
-+
-+
-+#if USE_MEMCPY
-+
-+/*
-+ Note: memcpy is ONLY invoked with non-overlapping regions,
-+ so the (usually slower) memmove is not needed.
-+*/
-+
-+#define MALLOC_COPY(dest, src, nbytes) memcpy(dest, src, nbytes)
-+#define MALLOC_ZERO(dest, nbytes) memset(dest, 0, nbytes)
-+
-+#else /* !USE_MEMCPY */
-+
-+/* Use Duff's device for good zeroing/copying performance. */
-+
-+#define MALLOC_ZERO(charp, nbytes) \
-+do { \
-+ INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \
-+ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
-+ long mcn; \
-+ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
-+ switch (mctmp) { \
-+ case 0: for(;;) { *mzp++ = 0; \
-+ case 7: *mzp++ = 0; \
-+ case 6: *mzp++ = 0; \
-+ case 5: *mzp++ = 0; \
-+ case 4: *mzp++ = 0; \
-+ case 3: *mzp++ = 0; \
-+ case 2: *mzp++ = 0; \
-+ case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \
-+ } \
-+} while(0)
-+
-+#define MALLOC_COPY(dest,src,nbytes) \
-+do { \
-+ INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \
-+ INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \
-+ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
-+ long mcn; \
-+ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
-+ switch (mctmp) { \
-+ case 0: for(;;) { *mcdst++ = *mcsrc++; \
-+ case 7: *mcdst++ = *mcsrc++; \
-+ case 6: *mcdst++ = *mcsrc++; \
-+ case 5: *mcdst++ = *mcsrc++; \
-+ case 4: *mcdst++ = *mcsrc++; \
-+ case 3: *mcdst++ = *mcsrc++; \
-+ case 2: *mcdst++ = *mcsrc++; \
-+ case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \
-+ } \
-+} while(0)
-+
-+#endif
-+
-+/* ------------------ MMAP support ------------------ */
-+
-+
-+#if HAVE_MMAP
-+
-+#include <fcntl.h>
-+#ifndef LACKS_SYS_MMAN_H
-+#include <sys/mman.h>
-+#endif
-+
-+#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
-+#define MAP_ANONYMOUS MAP_ANON
-+#endif
-+
-+/*
-+ Nearly all versions of mmap support MAP_ANONYMOUS,
-+ so the following is unlikely to be needed, but is
-+ supplied just in case.
-+*/
-+
-+#ifndef MAP_ANONYMOUS
-+
-+static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
-+
-+#define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? \
-+ (dev_zero_fd = open("/dev/zero", O_RDWR), \
-+ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : \
-+ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0))
-+
-+#else
-+
-+#define MMAP(addr, size, prot, flags) \
-+ (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0))
-+
-+#endif
-+
-+
-+#endif /* HAVE_MMAP */
-+
-+
-+/*
-+ ----------------------- Chunk representations -----------------------
-+*/
-+
-+
-+/*
-+ This struct declaration is misleading (but accurate and necessary).
-+ It declares a "view" into memory allowing access to necessary
-+ fields at known offsets from a given base. See explanation below.
-+*/
-+
-+struct malloc_chunk {
-+
-+ INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
-+ INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
-+
-+ struct malloc_chunk* fd; /* double links -- used only if free. */
-+ struct malloc_chunk* bk;
-+};
-+
-+
-+typedef struct malloc_chunk* mchunkptr;
-+
-+/*
-+ malloc_chunk details:
-+
-+ (The following includes lightly edited explanations by Colin Plumb.)
-+
-+ Chunks of memory are maintained using a `boundary tag' method as
-+ described in e.g., Knuth or Standish. (See the paper by Paul
-+ Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
-+ survey of such techniques.) Sizes of free chunks are stored both
-+ in the front of each chunk and at the end. This makes
-+ consolidating fragmented chunks into bigger chunks very fast. The
-+ size fields also hold bits representing whether chunks are free or
-+ in use.
-+
-+ An allocated chunk looks like this:
-+
-+
-+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of previous chunk, if allocated | |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of chunk, in bytes |P|
-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | User data starts here... .
-+ . .
-+ . (malloc_usable_space() bytes) .
-+ . |
-+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of chunk |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+
-+
-+ Where "chunk" is the front of the chunk for the purpose of most of
-+ the malloc code, but "mem" is the pointer that is returned to the
-+ user. "Nextchunk" is the beginning of the next contiguous chunk.
-+
-+ Chunks always begin on even word boundaries, so the mem portion
-+ (which is returned to the user) is also on an even word boundary, and
-+ thus at least double-word aligned.
-+
-+ Free chunks are stored in circular doubly-linked lists, and look like this:
-+
-+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of previous chunk |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ `head:' | Size of chunk, in bytes |P|
-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Forward pointer to next chunk in list |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Back pointer to previous chunk in list |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Unused space (may be 0 bytes long) .
-+ . .
-+ . |
-+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ `foot:' | Size of chunk, in bytes |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+
-+ The P (PREV_INUSE) bit, stored in the unused low-order bit of the
-+ chunk size (which is always a multiple of two words), is an in-use
-+ bit for the *previous* chunk. If that bit is *clear*, then the
-+ word before the current chunk size contains the previous chunk
-+ size, and can be used to find the front of the previous chunk.
-+ The very first chunk allocated always has this bit set,
-+ preventing access to non-existent (or non-owned) memory. If
-+ prev_inuse is set for any given chunk, then you CANNOT determine
-+ the size of the previous chunk, and might even get a memory
-+ addressing fault when trying to do so.
-+
-+ Note that the `foot' of the current chunk is actually represented
-+ as the prev_size of the NEXT chunk. This makes it easier to
-+ deal with alignments etc but can be very confusing when trying
-+ to extend or adapt this code.
-+
-+ The two exceptions to all this are
-+
-+ 1. The special chunk `top' doesn't bother using the
-+ trailing size field since there is no next contiguous chunk
-+ that would have to index off it. After initialization, `top'
-+ is forced to always exist. If it would become less than
-+ MINSIZE bytes long, it is replenished.
-+
-+ 2. Chunks allocated via mmap, which have the second-lowest-order
-+ bit (IS_MMAPPED) set in their size fields. Because they are
-+ allocated one-by-one, each must contain its own trailing size field.
-+
-+*/
-+
-+/*
-+ ---------- Size and alignment checks and conversions ----------
-+*/
-+
-+/* conversion from malloc headers to user pointers, and back */
-+
-+#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ))
-+#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
-+
-+/* The smallest possible chunk */
-+#define MIN_CHUNK_SIZE (sizeof(struct malloc_chunk))
-+
-+/* The smallest size we can malloc is an aligned minimal chunk */
-+
-+#define MINSIZE \
-+ (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
-+
-+/* Check if m has acceptable alignment */
-+
-+#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
-+
-+
-+/*
-+ Check if a request is so large that it would wrap around zero when
-+ padded and aligned. To simplify some other code, the bound is made
-+ low enough so that adding MINSIZE will also not wrap around zero.
-+*/
-+
-+#define REQUEST_OUT_OF_RANGE(req) \
-+ ((unsigned long)(req) >= \
-+ (unsigned long)(INTERNAL_SIZE_T)(-2 * MINSIZE))
-+
-+/* pad request bytes into a usable size -- internal version */
-+
-+#define request2size(req) \
-+ (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \
-+ MINSIZE : \
-+ ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
-+
-+/* Same, except also perform argument check */
-+
-+#define checked_request2size(req, sz) \
-+ if (REQUEST_OUT_OF_RANGE(req)) { \
-+ MALLOC_FAILURE_ACTION; \
-+ return 0; \
-+ } \
-+ (sz) = request2size(req);
-+
-+/*
-+ --------------- Physical chunk operations ---------------
-+*/
-+
-+
-+/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
-+#define PREV_INUSE 0x1
-+
-+/* extract inuse bit of previous chunk */
-+#define prev_inuse(p) ((p)->size & PREV_INUSE)
-+
-+
-+/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
-+#define IS_MMAPPED 0x2
-+
-+/* check for mmap()'ed chunk */
-+#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
-+
-+/*
-+ Bits to mask off when extracting size
-+
-+ Note: IS_MMAPPED is intentionally not masked off from size field in
-+ macros for which mmapped chunks should never be seen. This should
-+ cause helpful core dumps to occur if it is tried by accident by
-+ people extending or adapting this malloc.
-+*/
-+#define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
-+
-+/* Get size, ignoring use bits */
-+#define chunksize(p) ((p)->size & ~(SIZE_BITS))
-+
-+
-+/* Ptr to next physical malloc_chunk. */
-+#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
-+
-+/* Ptr to previous physical malloc_chunk */
-+#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
-+
-+/* Treat space at ptr + offset as a chunk */
-+#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
-+
-+/* extract p's inuse bit */
-+#define inuse(p)\
-+((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
-+
-+/* set/clear chunk as being inuse without otherwise disturbing */
-+#define set_inuse(p)\
-+((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
-+
-+#define clear_inuse(p)\
-+((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
-+
-+
-+/* check/set/clear inuse bits in known places */
-+#define inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
-+
-+#define set_inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
-+
-+#define clear_inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
-+
-+
-+/* Set size at head, without disturbing its use bit */
-+#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s)))
-+
-+/* Set size/use field */
-+#define set_head(p, s) ((p)->size = (s))
-+
-+/* Set size at footer (only when chunk is not in use) */
-+#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
-+
-+
-+/*
-+ -------------------- Internal data structures --------------------
-+
-+ All internal state is held in an instance of malloc_state defined
-+ below. There are no other static variables, except in two optional
-+ cases:
-+ * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
-+ * If HAVE_MMAP is true, but mmap doesn't support
-+ MAP_ANONYMOUS, a dummy file descriptor for mmap.
-+
-+ Beware of lots of tricks that minimize the total bookkeeping space
-+ requirements. The result is a little over 1K bytes (for 4byte
-+ pointers and size_t.)
-+*/
-+
-+/*
-+ Bins
-+
-+ An array of bin headers for free chunks. Each bin is doubly
-+ linked. The bins are approximately proportionally (log) spaced.
-+ There are a lot of these bins (128). This may look excessive, but
-+ works very well in practice. Most bins hold sizes that are
-+ unusual as malloc request sizes, but are more usual for fragments
-+ and consolidated sets of chunks, which is what these bins hold, so
-+ they can be found quickly. All procedures maintain the invariant
-+ that no consolidated chunk physically borders another one, so each
-+ chunk in a list is known to be preceded and followed by either
-+ inuse chunks or the ends of memory.
-+
-+ Chunks in bins are kept in size order, with ties going to the
-+ approximately least recently used chunk. Ordering isn't needed
-+ for the small bins, which all contain the same-sized chunks, but
-+ facilitates best-fit allocation for larger chunks. These lists
-+ are just sequential. Keeping them in order almost never requires
-+ enough traversal to warrant using fancier ordered data
-+ structures.
-+
-+ Chunks of the same size are linked with the most
-+ recently freed at the front, and allocations are taken from the
-+ back. This results in LRU (FIFO) allocation order, which tends
-+ to give each chunk an equal opportunity to be consolidated with
-+ adjacent freed chunks, resulting in larger free chunks and less
-+ fragmentation.
-+
-+ To simplify use in double-linked lists, each bin header acts
-+ as a malloc_chunk. This avoids special-casing for headers.
-+ But to conserve space and improve locality, we allocate
-+ only the fd/bk pointers of bins, and then use repositioning tricks
-+ to treat these as the fields of a malloc_chunk*.
-+*/
-+
-+typedef struct malloc_chunk* mbinptr;
-+
-+/* addressing -- note that bin_at(0) does not exist */
-+#define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1)))
-+
-+/* analog of ++bin */
-+#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
-+
-+/* Reminders about list directionality within bins */
-+#define first(b) ((b)->fd)
-+#define last(b) ((b)->bk)
-+
-+/* Take a chunk off a bin list */
-+#define unlink(P, BK, FD) { \
-+ FD = P->fd; \
-+ BK = P->bk; \
-+ FD->bk = BK; \
-+ BK->fd = FD; \
-+}
-+
-+/*
-+ Indexing
-+
-+ Bins for sizes < 512 bytes contain chunks of all the same size, spaced
-+ 8 bytes apart. Larger bins are approximately logarithmically spaced:
-+
-+ 64 bins of size 8
-+ 32 bins of size 64
-+ 16 bins of size 512
-+ 8 bins of size 4096
-+ 4 bins of size 32768
-+ 2 bins of size 262144
-+ 1 bin of size what's left
-+
-+ There is actually a little bit of slop in the numbers in bin_index
-+ for the sake of speed. This makes no difference elsewhere.
-+
-+ The bins top out around 1MB because we expect to service large
-+ requests via mmap.
-+*/
-+
-+#define NBINS 128
-+#define NSMALLBINS 64
-+#define SMALLBIN_WIDTH 8
-+#define MIN_LARGE_SIZE 512
-+
-+#define in_smallbin_range(sz) \
-+ ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
-+
-+#define smallbin_index(sz) (((unsigned)(sz)) >> 3)
-+
-+#define largebin_index(sz) \
-+(((((unsigned long)(sz)) >> 6) <= 32)? 56 + (((unsigned long)(sz)) >> 6): \
-+ ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
-+ ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
-+ ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
-+ ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
-+ 126)
-+
-+#define bin_index(sz) \
-+ ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
-+
-+
-+/*
-+ Unsorted chunks
-+
-+ All remainders from chunk splits, as well as all returned chunks,
-+ are first placed in the "unsorted" bin. They are then placed
-+ in regular bins after malloc gives them ONE chance to be used before
-+ binning. So, basically, the unsorted_chunks list acts as a queue,
-+ with chunks being placed on it in free (and malloc_consolidate),
-+ and taken off (to be either used or placed in bins) in malloc.
-+*/
-+
-+/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
-+#define unsorted_chunks(M) (bin_at(M, 1))
-+
-+/*
-+ Top
-+
-+ The top-most available chunk (i.e., the one bordering the end of
-+ available memory) is treated specially. It is never included in
-+ any bin, is used only if no other chunk is available, and is
-+ released back to the system if it is very large (see
-+ M_TRIM_THRESHOLD). Because top initially
-+ points to its own bin with initial zero size, thus forcing
-+ extension on the first malloc request, we avoid having any special
-+ code in malloc to check whether it even exists yet. But we still
-+ need to do so when getting memory from system, so we make
-+ initial_top treat the bin as a legal but unusable chunk during the
-+ interval between initialization and the first call to
-+ sYSMALLOc. (This is somewhat delicate, since it relies on
-+ the 2 preceding words to be zero during this interval as well.)
-+*/
-+
-+/* Conveniently, the unsorted bin can be used as dummy top on first call */
-+#define initial_top(M) (unsorted_chunks(M))
-+
-+/*
-+ Binmap
-+
-+ To help compensate for the large number of bins, a one-level index
-+ structure is used for bin-by-bin searching. `binmap' is a
-+ bitvector recording whether bins are definitely empty so they can
-+ be skipped over during during traversals. The bits are NOT always
-+ cleared as soon as bins are empty, but instead only
-+ when they are noticed to be empty during traversal in malloc.
-+*/
-+
-+/* Conservatively use 32 bits per map word, even if on 64bit system */
-+#define BINMAPSHIFT 5
-+#define BITSPERMAP (1U << BINMAPSHIFT)
-+#define BINMAPSIZE (NBINS / BITSPERMAP)
-+
-+#define idx2block(i) ((i) >> BINMAPSHIFT)
-+#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
-+
-+#define mark_bin(m,i) ((m)->binmap[idx2block(i)] |= idx2bit(i))
-+#define unmark_bin(m,i) ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
-+#define get_binmap(m,i) ((m)->binmap[idx2block(i)] & idx2bit(i))
-+
-+/*
-+ Fastbins
-+
-+ An array of lists holding recently freed small chunks. Fastbins
-+ are not doubly linked. It is faster to single-link them, and
-+ since chunks are never removed from the middles of these lists,
-+ double linking is not necessary. Also, unlike regular bins, they
-+ are not even processed in FIFO order (they use faster LIFO) since
-+ ordering doesn't much matter in the transient contexts in which
-+ fastbins are normally used.
-+
-+ Chunks in fastbins keep their inuse bit set, so they cannot
-+ be consolidated with other free chunks. malloc_consolidate
-+ releases all chunks in fastbins and consolidates them with
-+ other free chunks.
-+*/
-+
-+typedef struct malloc_chunk* mfastbinptr;
-+
-+/* offset 2 to use otherwise unindexable first 2 bins */
-+#define fastbin_index(sz) ((((unsigned int)(sz)) >> 3) - 2)
-+
-+/* The maximum fastbin request size we support */
-+#define MAX_FAST_SIZE 80
-+
-+#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE))+1)
-+
-+/*
-+ FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
-+ that triggers automatic consolidation of possibly-surrounding
-+ fastbin chunks. This is a heuristic, so the exact value should not
-+ matter too much. It is defined at half the default trim threshold as a
-+ compromise heuristic to only attempt consolidation if it is likely
-+ to lead to trimming. However, it is not dynamically tunable, since
-+ consolidation reduces fragmentation surrounding loarge chunks even
-+ if trimming is not used.
-+*/
-+
-+#define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL)
-+
-+/*
-+ Since the lowest 2 bits in max_fast don't matter in size comparisons,
-+ they are used as flags.
-+*/
-+
-+/*
-+ FASTCHUNKS_BIT held in max_fast indicates that there are probably
-+ some fastbin chunks. It is set true on entering a chunk into any
-+ fastbin, and cleared only in malloc_consolidate.
-+
-+ The truth value is inverted so that have_fastchunks will be true
-+ upon startup (since statics are zero-filled), simplifying
-+ initialization checks.
-+*/
-+
-+#define FASTCHUNKS_BIT (1U)
-+
-+#define have_fastchunks(M) (((M)->max_fast & FASTCHUNKS_BIT) == 0)
-+#define clear_fastchunks(M) ((M)->max_fast |= FASTCHUNKS_BIT)
-+#define set_fastchunks(M) ((M)->max_fast &= ~FASTCHUNKS_BIT)
-+
-+/*
-+ NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
-+ regions. Otherwise, contiguity is exploited in merging together,
-+ when possible, results from consecutive MORECORE calls.
-+
-+ The initial value comes from MORECORE_CONTIGUOUS, but is
-+ changed dynamically if mmap is ever used as an sbrk substitute.
-+*/
-+
-+#define NONCONTIGUOUS_BIT (2U)
-+
-+#define contiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) == 0)
-+#define noncontiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) != 0)
-+#define set_noncontiguous(M) ((M)->max_fast |= NONCONTIGUOUS_BIT)
-+#define set_contiguous(M) ((M)->max_fast &= ~NONCONTIGUOUS_BIT)
-+
-+/*
-+ Set value of max_fast.
-+ Use impossibly small value if 0.
-+ Precondition: there are no existing fastbin chunks.
-+ Setting the value clears fastchunk bit but preserves noncontiguous bit.
-+*/
-+
-+#define set_max_fast(M, s) \
-+ (M)->max_fast = (((s) == 0)? SMALLBIN_WIDTH: request2size(s)) | \
-+ FASTCHUNKS_BIT | \
-+ ((M)->max_fast & NONCONTIGUOUS_BIT)
-+
-+
-+/*
-+ ----------- Internal state representation and initialization -----------
-+*/
-+
-+struct malloc_state {
-+
-+ /* The maximum chunk size to be eligible for fastbin */
-+ INTERNAL_SIZE_T max_fast; /* low 2 bits used as flags */
-+
-+ /* Fastbins */
-+ mfastbinptr fastbins[NFASTBINS];
-+
-+ /* Base of the topmost chunk -- not otherwise kept in a bin */
-+ mchunkptr top;
-+
-+ /* The remainder from the most recent split of a small request */
-+ mchunkptr last_remainder;
-+
-+ /* Normal bins packed as described above */
-+ mchunkptr bins[NBINS * 2];
-+
-+ /* Bitmap of bins */
-+ unsigned int binmap[BINMAPSIZE];
-+
-+ /* Tunable parameters */
-+ unsigned long trim_threshold;
-+ INTERNAL_SIZE_T top_pad;
-+ INTERNAL_SIZE_T mmap_threshold;
-+
-+ /* Memory map support */
-+ int n_mmaps;
-+ int n_mmaps_max;
-+ int max_n_mmaps;
-+
-+ /* Cache malloc_getpagesize */
-+ unsigned int pagesize;
-+
-+ /* Statistics */
-+ INTERNAL_SIZE_T mmapped_mem;
-+ INTERNAL_SIZE_T sbrked_mem;
-+ INTERNAL_SIZE_T max_sbrked_mem;
-+ INTERNAL_SIZE_T max_mmapped_mem;
-+ INTERNAL_SIZE_T max_total_mem;
-+};
-+
-+typedef struct malloc_state *mstate;
-+
-+/*
-+ There is exactly one instance of this struct in this malloc.
-+ If you are adapting this malloc in a way that does NOT use a static
-+ malloc_state, you MUST explicitly zero-fill it before using. This
-+ malloc relies on the property that malloc_state is initialized to
-+ all zeroes (as is true of C statics).
-+*/
-+
-+static struct malloc_state av_; /* never directly referenced */
-+
-+/*
-+ All uses of av_ are via get_malloc_state().
-+ At most one "call" to get_malloc_state is made per invocation of
-+ the public versions of malloc and free, but other routines
-+ that in turn invoke malloc and/or free may call more then once.
-+ Also, it is called in check* routines if DEBUG is set.
-+*/
-+
-+#define get_malloc_state() (&(av_))
-+
-+/*
-+ Initialize a malloc_state struct.
-+
-+ This is called only from within malloc_consolidate, which needs
-+ be called in the same contexts anyway. It is never called directly
-+ outside of malloc_consolidate because some optimizing compilers try
-+ to inline it at all call points, which turns out not to be an
-+ optimization at all. (Inlining it in malloc_consolidate is fine though.)
-+*/
-+
-+#if __STD_C
-+static void malloc_init_state(mstate av)
-+#else
-+static void malloc_init_state(av) mstate av;
-+#endif
-+{
-+ int i;
-+ mbinptr bin;
-+
-+ /* Establish circular links for normal bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ bin = bin_at(av,i);
-+ bin->fd = bin->bk = bin;
-+ }
-+
-+ av->top_pad = DEFAULT_TOP_PAD;
-+ av->n_mmaps_max = DEFAULT_MMAP_MAX;
-+ av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
-+ av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
-+
-+#if !MORECORE_CONTIGUOUS
-+ set_noncontiguous(av);
-+#endif
-+
-+ set_max_fast(av, DEFAULT_MXFAST);
-+
-+ av->top = initial_top(av);
-+ av->pagesize = malloc_getpagesize;
-+}
-+
-+/*
-+ Other internal utilities operating on mstates
-+*/
-+
-+#if __STD_C
-+static Void_t* sYSMALLOc(INTERNAL_SIZE_T, mstate);
-+static int sYSTRIm(size_t, mstate);
-+static void malloc_consolidate(mstate);
-+static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
-+#else
-+static Void_t* sYSMALLOc();
-+static int sYSTRIm();
-+static void malloc_consolidate();
-+static Void_t** iALLOc();
-+#endif
-+
-+/*
-+ Debugging support
-+
-+ These routines make a number of assertions about the states
-+ of data structures that should be true at all times. If any
-+ are not true, it's very likely that a user program has somehow
-+ trashed memory. (It's also possible that there is a coding error
-+ in malloc. In which case, please report it!)
-+*/
-+
-+#ifndef DEBUG
-+
-+#define check_chunk(P)
-+#define check_free_chunk(P)
-+#define check_inuse_chunk(P)
-+#define check_remalloced_chunk(P,N)
-+#define check_malloced_chunk(P,N)
-+#define check_malloc_state()
-+
-+#else
-+#define check_chunk(P) do_check_chunk(P)
-+#define check_free_chunk(P) do_check_free_chunk(P)
-+#define check_inuse_chunk(P) do_check_inuse_chunk(P)
-+#define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N)
-+#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
-+#define check_malloc_state() do_check_malloc_state()
-+
-+/*
-+ Properties of all chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_chunk(mchunkptr p)
-+#else
-+static void do_check_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ unsigned long sz = chunksize(p);
-+ /* min and max possible addresses assuming contiguous allocation */
-+ char* max_address = (char*)(av->top) + chunksize(av->top);
-+ char* min_address = max_address - av->sbrked_mem;
-+
-+ if (!chunk_is_mmapped(p)) {
-+
-+ /* Has legal address ... */
-+ if (p != av->top) {
-+ if (contiguous(av)) {
-+ assert(((char*)p) >= min_address);
-+ assert(((char*)p + sz) <= ((char*)(av->top)));
-+ }
-+ }
-+ else {
-+ /* top size is always at least MINSIZE */
-+ assert((unsigned long)(sz) >= MINSIZE);
-+ /* top predecessor always marked inuse */
-+ assert(prev_inuse(p));
-+ }
-+
-+ }
-+ else {
-+#if HAVE_MMAP
-+ /* address is outside main heap */
-+ if (contiguous(av) && av->top != initial_top(av)) {
-+ assert(((char*)p) < min_address || ((char*)p) > max_address);
-+ }
-+ /* chunk is page-aligned */
-+ assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
-+ /* mem is aligned */
-+ assert(aligned_OK(chunk2mem(p)));
-+#else
-+ /* force an appropriate assert violation if debug set */
-+ assert(!chunk_is_mmapped(p));
-+#endif
-+ }
-+}
-+
-+/*
-+ Properties of free chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_free_chunk(mchunkptr p)
-+#else
-+static void do_check_free_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
-+ mchunkptr next = chunk_at_offset(p, sz);
-+
-+ do_check_chunk(p);
-+
-+ /* Chunk must claim to be free ... */
-+ assert(!inuse(p));
-+ assert (!chunk_is_mmapped(p));
-+
-+ /* Unless a special marker, must have OK fields */
-+ if ((unsigned long)(sz) >= MINSIZE)
-+ {
-+ assert((sz & MALLOC_ALIGN_MASK) == 0);
-+ assert(aligned_OK(chunk2mem(p)));
-+ /* ... matching footer field */
-+ assert(next->prev_size == sz);
-+ /* ... and is fully consolidated */
-+ assert(prev_inuse(p));
-+ assert (next == av->top || inuse(next));
-+
-+ /* ... and has minimally sane links */
-+ assert(p->fd->bk == p);
-+ assert(p->bk->fd == p);
-+ }
-+ else /* markers are always of size SIZE_SZ */
-+ assert(sz == SIZE_SZ);
-+}
-+
-+/*
-+ Properties of inuse chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_inuse_chunk(mchunkptr p)
-+#else
-+static void do_check_inuse_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ mchunkptr next;
-+ do_check_chunk(p);
-+
-+ if (chunk_is_mmapped(p))
-+ return; /* mmapped chunks have no next/prev */
-+
-+ /* Check whether it claims to be in use ... */
-+ assert(inuse(p));
-+
-+ next = next_chunk(p);
-+
-+ /* ... and is surrounded by OK chunks.
-+ Since more things can be checked with free chunks than inuse ones,
-+ if an inuse chunk borders them and debug is on, it's worth doing them.
-+ */
-+ if (!prev_inuse(p)) {
-+ /* Note that we cannot even look at prev unless it is not inuse */
-+ mchunkptr prv = prev_chunk(p);
-+ assert(next_chunk(prv) == p);
-+ do_check_free_chunk(prv);
-+ }
-+
-+ if (next == av->top) {
-+ assert(prev_inuse(next));
-+ assert(chunksize(next) >= MINSIZE);
-+ }
-+ else if (!inuse(next))
-+ do_check_free_chunk(next);
-+}
-+
-+/*
-+ Properties of chunks recycled from fastbins
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
-+#else
-+static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
-+#endif
-+{
-+ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
-+
-+ do_check_inuse_chunk(p);
-+
-+ /* Legal size ... */
-+ assert((sz & MALLOC_ALIGN_MASK) == 0);
-+ assert((unsigned long)(sz) >= MINSIZE);
-+ /* ... and alignment */
-+ assert(aligned_OK(chunk2mem(p)));
-+ /* chunk is less than MINSIZE more than request */
-+ assert((long)(sz) - (long)(s) >= 0);
-+ assert((long)(sz) - (long)(s + MINSIZE) < 0);
-+}
-+
-+/*
-+ Properties of nonrecycled chunks at the point they are malloced
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
-+#else
-+static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
-+#endif
-+{
-+ /* same as recycled case ... */
-+ do_check_remalloced_chunk(p, s);
-+
-+ /*
-+ ... plus, must obey implementation invariant that prev_inuse is
-+ always true of any allocated chunk; i.e., that each allocated
-+ chunk borders either a previously allocated and still in-use
-+ chunk, or the base of its memory arena. This is ensured
-+ by making all allocations from the the `lowest' part of any found
-+ chunk. This does not necessarily hold however for chunks
-+ recycled via fastbins.
-+ */
-+
-+ assert(prev_inuse(p));
-+}
-+
-+
-+/*
-+ Properties of malloc_state.
-+
-+ This may be useful for debugging malloc, as well as detecting user
-+ programmer errors that somehow write into malloc_state.
-+
-+ If you are extending or experimenting with this malloc, you can
-+ probably figure out how to hack this routine to print out or
-+ display chunk addresses, sizes, bins, and other instrumentation.
-+*/
-+
-+static void do_check_malloc_state()
-+{
-+ mstate av = get_malloc_state();
-+ int i;
-+ mchunkptr p;
-+ mchunkptr q;
-+ mbinptr b;
-+ unsigned int binbit;
-+ int empty;
-+ unsigned int idx;
-+ INTERNAL_SIZE_T size;
-+ unsigned long total = 0;
-+ int max_fast_bin;
-+
-+ /* internal size_t must be no wider than pointer type */
-+ assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*));
-+
-+ /* alignment is a power of 2 */
-+ assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0);
-+
-+ /* cannot run remaining checks until fully initialized */
-+ if (av->top == 0 || av->top == initial_top(av))
-+ return;
-+
-+ /* pagesize is a power of 2 */
-+ assert((av->pagesize & (av->pagesize-1)) == 0);
-+
-+ /* properties of fastbins */
-+
-+ /* max_fast is in allowed range */
-+ assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE));
-+
-+ max_fast_bin = fastbin_index(av->max_fast);
-+
-+ for (i = 0; i < NFASTBINS; ++i) {
-+ p = av->fastbins[i];
-+
-+ /* all bins past max_fast are empty */
-+ if (i > max_fast_bin)
-+ assert(p == 0);
-+
-+ while (p != 0) {
-+ /* each chunk claims to be inuse */
-+ do_check_inuse_chunk(p);
-+ total += chunksize(p);
-+ /* chunk belongs in this bin */
-+ assert(fastbin_index(chunksize(p)) == i);
-+ p = p->fd;
-+ }
-+ }
-+
-+ if (total != 0)
-+ assert(have_fastchunks(av));
-+ else if (!have_fastchunks(av))
-+ assert(total == 0);
-+
-+ /* check normal bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ b = bin_at(av,i);
-+
-+ /* binmap is accurate (except for bin 1 == unsorted_chunks) */
-+ if (i >= 2) {
-+ binbit = get_binmap(av,i);
-+ empty = last(b) == b;
-+ if (!binbit)
-+ assert(empty);
-+ else if (!empty)
-+ assert(binbit);
-+ }
-+
-+ for (p = last(b); p != b; p = p->bk) {
-+ /* each chunk claims to be free */
-+ do_check_free_chunk(p);
-+ size = chunksize(p);
-+ total += size;
-+ if (i >= 2) {
-+ /* chunk belongs in bin */
-+ idx = bin_index(size);
-+ assert(idx == i);
-+ /* lists are sorted */
-+ assert(p->bk == b ||
-+ (unsigned long)chunksize(p->bk) >= (unsigned long)chunksize(p));
-+ }
-+ /* chunk is followed by a legal chain of inuse chunks */
-+ for (q = next_chunk(p);
-+ (q != av->top && inuse(q) &&
-+ (unsigned long)(chunksize(q)) >= MINSIZE);
-+ q = next_chunk(q))
-+ do_check_inuse_chunk(q);
-+ }
-+ }
-+
-+ /* top chunk is OK */
-+ check_chunk(av->top);
-+
-+ /* sanity checks for statistics */
-+
-+ assert(total <= (unsigned long)(av->max_total_mem));
-+ assert(av->n_mmaps >= 0);
-+ assert(av->n_mmaps <= av->n_mmaps_max);
-+ assert(av->n_mmaps <= av->max_n_mmaps);
-+
-+ assert((unsigned long)(av->sbrked_mem) <=
-+ (unsigned long)(av->max_sbrked_mem));
-+
-+ assert((unsigned long)(av->mmapped_mem) <=
-+ (unsigned long)(av->max_mmapped_mem));
-+
-+ assert((unsigned long)(av->max_total_mem) >=
-+ (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
-+}
-+#endif
-+
-+
-+/* ----------- Routines dealing with system allocation -------------- */
-+
-+/*
-+ sYSTRIm is an inverse of sorts to sYSMALLOc. It gives memory back
-+ to the system (via negative arguments to sbrk) if there is unused
-+ memory at the `high' end of the malloc pool. It is called
-+ automatically by free() when top space exceeds the trim
-+ threshold. It is also called by the public malloc_trim routine. It
-+ returns 1 if it actually released any memory, else 0.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static int sYSTRIm(size_t pad, mstate av)
-+#else
-+static int sYSTRIm(pad, av) size_t pad; mstate av;
-+#endif
-+{
-+ long top_size; /* Amount of top-most memory */
-+ long extra; /* Amount to release */
-+ long released; /* Amount actually released */
-+ char* current_brk; /* address returned by pre-check sbrk call */
-+ char* new_brk; /* address returned by post-check sbrk call */
-+ size_t pagesz;
-+
-+ pagesz = av->pagesize;
-+ top_size = chunksize(av->top);
-+
-+ /* Release in pagesize units, keeping at least one page */
-+ extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
-+
-+ if (extra > 0) {
-+
-+ /*
-+ Only proceed if end of memory is where we last set it.
-+ This avoids problems if there were foreign sbrk calls.
-+ */
-+ current_brk = (char*)(MORECORE(0));
-+ if (current_brk == (char*)(av->top) + top_size) {
-+
-+ /*
-+ Attempt to release memory. We ignore MORECORE return value,
-+ and instead call again to find out where new end of memory is.
-+ This avoids problems if first call releases less than we asked,
-+ of if failure somehow altered brk value. (We could still
-+ encounter problems if it altered brk in some very bad way,
-+ but the only thing we can do is adjust anyway, which will cause
-+ some downstream failure.)
-+ */
-+
-+ MORECORE(-extra);
-+ new_brk = (char*)(MORECORE(0));
-+
-+ if (new_brk != (char*)MORECORE_FAILURE) {
-+ released = (long)(current_brk - new_brk);
-+
-+ if (released != 0) {
-+ /* Success. Adjust top. */
-+ av->sbrked_mem -= released;
-+ set_head(av->top, (top_size - released) | PREV_INUSE);
-+ check_malloc_state();
-+ return 1;
-+ }
-+ }
-+ }
-+ }
-+ return 0;
-+}
-+
-+/*
-+ ------------------------- malloc_consolidate -------------------------
-+
-+ malloc_consolidate is a specialized version of free() that tears
-+ down chunks held in fastbins. Free itself cannot be used for this
-+ purpose since, among other things, it might place chunks back onto
-+ fastbins. So, instead, we need to use a minor variant of the same
-+ code.
-+
-+ Also, because this routine needs to be called the first time through
-+ malloc anyway, it turns out to be the perfect place to trigger
-+ initialization code.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void malloc_consolidate(mstate av)
-+#else
-+static void malloc_consolidate(av) mstate av;
-+#endif
-+{
-+ mfastbinptr* fb; /* current fastbin being consolidated */
-+ mfastbinptr* maxfb; /* last fastbin (for loop control) */
-+ mchunkptr p; /* current chunk being consolidated */
-+ mchunkptr nextp; /* next chunk to consolidate */
-+ mchunkptr unsorted_bin; /* bin header */
-+ mchunkptr first_unsorted; /* chunk to link to */
-+
-+ /* These have same use as in free() */
-+ mchunkptr nextchunk;
-+ INTERNAL_SIZE_T size;
-+ INTERNAL_SIZE_T nextsize;
-+ INTERNAL_SIZE_T prevsize;
-+ int nextinuse;
-+ mchunkptr bck;
-+ mchunkptr fwd;
-+
-+ /*
-+ If max_fast is 0, we know that av hasn't
-+ yet been initialized, in which case do so below
-+ */
-+
-+ if (av->max_fast != 0) {
-+ clear_fastchunks(av);
-+
-+ unsorted_bin = unsorted_chunks(av);
-+
-+ /*
-+ Remove each chunk from fast bin and consolidate it, placing it
-+ then in unsorted bin. Among other reasons for doing this,
-+ placing in unsorted bin avoids needing to calculate actual bins
-+ until malloc is sure that chunks aren't immediately going to be
-+ reused anyway.
-+ */
-+
-+ maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
-+ fb = &(av->fastbins[0]);
-+ do {
-+ if ( (p = *fb) != 0) {
-+ *fb = 0;
-+
-+ do {
-+ check_inuse_chunk(p);
-+ nextp = p->fd;
-+
-+ /* Slightly streamlined version of consolidation code in free() */
-+ size = p->size & ~PREV_INUSE;
-+ nextchunk = chunk_at_offset(p, size);
-+ nextsize = chunksize(nextchunk);
-+
-+ if (!prev_inuse(p)) {
-+ prevsize = p->prev_size;
-+ size += prevsize;
-+ p = chunk_at_offset(p, -((long) prevsize));
-+ unlink(p, bck, fwd);
-+ }
-+
-+ if (nextchunk != av->top) {
-+ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
-+ set_head(nextchunk, nextsize);
-+
-+ if (!nextinuse) {
-+ size += nextsize;
-+ unlink(nextchunk, bck, fwd);
-+ }
-+
-+ first_unsorted = unsorted_bin->fd;
-+ unsorted_bin->fd = p;
-+ first_unsorted->bk = p;
-+
-+ set_head(p, size | PREV_INUSE);
-+ p->bk = unsorted_bin;
-+ p->fd = first_unsorted;
-+ set_foot(p, size);
-+ }
-+
-+ else {
-+ size += nextsize;
-+ set_head(p, size | PREV_INUSE);
-+ av->top = p;
-+ }
-+
-+ } while ( (p = nextp) != 0);
-+
-+ }
-+ } while (fb++ != maxfb);
-+ }
-+ else {
-+ malloc_init_state(av);
-+ check_malloc_state();
-+ }
-+}
-+
-+/*
-+ ------------------------------ free ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+void fREe(Void_t* mem)
-+#else
-+void fREe(mem) Void_t* mem;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ mchunkptr p; /* chunk corresponding to mem */
-+ INTERNAL_SIZE_T size; /* its size */
-+ mfastbinptr* fb; /* associated fastbin */
-+ mchunkptr nextchunk; /* next contiguous chunk */
-+ INTERNAL_SIZE_T nextsize; /* its size */
-+ int nextinuse; /* true if nextchunk is used */
-+ INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
-+ mchunkptr bck; /* misc temp for linking */
-+ mchunkptr fwd; /* misc temp for linking */
-+
-+
-+ /* free(0) has no effect */
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+ size = chunksize(p);
-+
-+ check_inuse_chunk(p);
-+
-+ /*
-+ If eligible, place chunk on a fastbin so it can be found
-+ and used quickly in malloc.
-+ */
-+
-+ if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
-+
-+#if TRIM_FASTBINS
-+ /*
-+ If TRIM_FASTBINS set, don't place chunks
-+ bordering top into fastbins
-+ */
-+ && (chunk_at_offset(p, size) != av->top)
-+#endif
-+ ) {
-+
-+ set_fastchunks(av);
-+ fb = &(av->fastbins[fastbin_index(size)]);
-+ p->fd = *fb;
-+ *fb = p;
-+ }
-+
-+ /*
-+ Consolidate other non-mmapped chunks as they arrive.
-+ */
-+
-+ else if (!chunk_is_mmapped(p)) {
-+ nextchunk = chunk_at_offset(p, size);
-+ nextsize = chunksize(nextchunk);
-+
-+ /* consolidate backward */
-+ if (!prev_inuse(p)) {
-+ prevsize = p->prev_size;
-+ size += prevsize;
-+ p = chunk_at_offset(p, -((long) prevsize));
-+ unlink(p, bck, fwd);
-+ }
-+
-+ if (nextchunk != av->top) {
-+ /* get and clear inuse bit */
-+ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
-+ set_head(nextchunk, nextsize);
-+
-+ /* consolidate forward */
-+ if (!nextinuse) {
-+ unlink(nextchunk, bck, fwd);
-+ size += nextsize;
-+ }
-+
-+ /*
-+ Place the chunk in unsorted chunk list. Chunks are
-+ not placed into regular bins until after they have
-+ been given one chance to be used in malloc.
-+ */
-+
-+ bck = unsorted_chunks(av);
-+ fwd = bck->fd;
-+ p->bk = bck;
-+ p->fd = fwd;
-+ bck->fd = p;
-+ fwd->bk = p;
-+
-+ set_head(p, size | PREV_INUSE);
-+ set_foot(p, size);
-+
-+ check_free_chunk(p);
-+ }
-+
-+ /*
-+ If the chunk borders the current high end of memory,
-+ consolidate into top
-+ */
-+
-+ else {
-+ size += nextsize;
-+ set_head(p, size | PREV_INUSE);
-+ av->top = p;
-+ check_chunk(p);
-+ }
-+
-+ /*
-+ If freeing a large space, consolidate possibly-surrounding
-+ chunks. Then, if the total unused topmost memory exceeds trim
-+ threshold, ask malloc_trim to reduce top.
-+
-+ Unless max_fast is 0, we don't know if there are fastbins
-+ bordering top, so we cannot tell for sure whether threshold
-+ has been reached unless fastbins are consolidated. But we
-+ don't want to consolidate on each free. As a compromise,
-+ consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
-+ is reached.
-+ */
-+
-+ if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
-+ if (have_fastchunks(av))
-+ malloc_consolidate(av);
-+
-+#ifndef MORECORE_CANNOT_TRIM
-+ if ((unsigned long)(chunksize(av->top)) >=
-+ (unsigned long)(av->trim_threshold))
-+ sYSTRIm(av->top_pad, av);
-+#endif
-+ }
-+
-+ }
-+ /*
-+ If the chunk was allocated via mmap, release via munmap()
-+ Note that if HAVE_MMAP is false but chunk_is_mmapped is
-+ true, then user must have overwritten memory. There's nothing
-+ we can do to catch this error unless DEBUG is set, in which case
-+ check_inuse_chunk (above) will have triggered error.
-+ */
-+
-+ else {
-+#if HAVE_MMAP
-+ int ret;
-+ INTERNAL_SIZE_T offset = p->prev_size;
-+ av->n_mmaps--;
-+ av->mmapped_mem -= (size + offset);
-+ ret = munmap((char*)p - offset, size + offset);
-+ /* munmap returns non-zero on failure */
-+ assert(ret == 0);
-+#endif
-+ }
-+ }
-+}
-+
-+/*
-+ sysmalloc handles malloc cases requiring more memory from the system.
-+ On entry, it is assumed that av->top does not have enough
-+ space to service request for nb bytes, thus requiring that av->top
-+ be extended or replaced.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
-+#else
-+static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
-+#endif
-+{
-+ mchunkptr old_top; /* incoming value of av->top */
-+ INTERNAL_SIZE_T old_size; /* its size */
-+ char* old_end; /* its end address */
-+
-+ long size; /* arg to first MORECORE or mmap call */
-+ char* brk; /* return value from MORECORE */
-+
-+ long correction; /* arg to 2nd MORECORE call */
-+ char* snd_brk; /* 2nd return val */
-+
-+ INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
-+ INTERNAL_SIZE_T end_misalign; /* partial page left at end of new space */
-+ char* aligned_brk; /* aligned offset into brk */
-+
-+ mchunkptr p; /* the allocated/returned chunk */
-+ mchunkptr remainder; /* remainder from allocation */
-+ unsigned long remainder_size; /* its size */
-+
-+ unsigned long sum; /* for updating stats */
-+
-+ size_t pagemask = av->pagesize - 1;
-+
-+
-+#if HAVE_MMAP
-+
-+ /*
-+ If have mmap, and the request size meets the mmap threshold, and
-+ the system supports mmap, and there are few enough currently
-+ allocated mmapped regions, try to directly map this request
-+ rather than expanding top.
-+ */
-+
-+ if ((unsigned long)(nb) >= (unsigned long)(av->mmap_threshold) &&
-+ (av->n_mmaps < av->n_mmaps_max)) {
-+
-+ char* mm; /* return value from mmap call*/
-+
-+ /*
-+ Round up size to nearest page. For mmapped chunks, the overhead
-+ is one SIZE_SZ unit larger than for normal chunks, because there
-+ is no following chunk whose prev_size field could be used.
-+ */
-+ size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
-+
-+ /* Don't try if size wraps around 0 */
-+ if ((unsigned long)(size) > (unsigned long)(nb)) {
-+
-+ mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
-+
-+ if (mm != (char*)(MORECORE_FAILURE)) {
-+
-+ /*
-+ The offset to the start of the mmapped region is stored
-+ in the prev_size field of the chunk. This allows us to adjust
-+ returned start address to meet alignment requirements here
-+ and in memalign(), and still be able to compute proper
-+ address argument for later munmap in free() and realloc().
-+ */
-+
-+ front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK;
-+ if (front_misalign > 0) {
-+ correction = MALLOC_ALIGNMENT - front_misalign;
-+ p = (mchunkptr)(mm + correction);
-+ p->prev_size = correction;
-+ set_head(p, (size - correction) |IS_MMAPPED);
-+ }
-+ else {
-+ p = (mchunkptr)mm;
-+ p->prev_size = 0;
-+ set_head(p, size|IS_MMAPPED);
-+ }
-+
-+ /* update statistics */
-+
-+ if (++av->n_mmaps > av->max_n_mmaps)
-+ av->max_n_mmaps = av->n_mmaps;
-+
-+ sum = av->mmapped_mem += size;
-+ if (sum > (unsigned long)(av->max_mmapped_mem))
-+ av->max_mmapped_mem = sum;
-+ sum += av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ check_chunk(p);
-+
-+ return chunk2mem(p);
-+ }
-+ }
-+ }
-+#endif
-+
-+ /* Record incoming configuration of top */
-+
-+ old_top = av->top;
-+ old_size = chunksize(old_top);
-+ old_end = (char*)(chunk_at_offset(old_top, old_size));
-+
-+ brk = snd_brk = (char*)(MORECORE_FAILURE);
-+
-+ /*
-+ If not the first time through, we require old_size to be
-+ at least MINSIZE and to have prev_inuse set.
-+ */
-+
-+ assert((old_top == initial_top(av) && old_size == 0) ||
-+ ((unsigned long) (old_size) >= MINSIZE &&
-+ prev_inuse(old_top)));
-+
-+ /* Precondition: not enough current space to satisfy nb request */
-+ assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
-+
-+ /* Precondition: all fastbins are consolidated */
-+ assert(!have_fastchunks(av));
-+
-+
-+ /* Request enough space for nb + pad + overhead */
-+
-+ size = nb + av->top_pad + MINSIZE;
-+
-+ /*
-+ If contiguous, we can subtract out existing space that we hope to
-+ combine with new space. We add it back later only if
-+ we don't actually get contiguous space.
-+ */
-+
-+ if (contiguous(av))
-+ size -= old_size;
-+
-+ /*
-+ Round to a multiple of page size.
-+ If MORECORE is not contiguous, this ensures that we only call it
-+ with whole-page arguments. And if MORECORE is contiguous and
-+ this is not first time through, this preserves page-alignment of
-+ previous calls. Otherwise, we correct to page-align below.
-+ */
-+
-+ size = (size + pagemask) & ~pagemask;
-+
-+ /*
-+ Don't try to call MORECORE if argument is so big as to appear
-+ negative. Note that since mmap takes size_t arg, it may succeed
-+ below even if we cannot call MORECORE.
-+ */
-+
-+ if (size > 0)
-+ brk = (char*)(MORECORE(size));
-+
-+ /*
-+ If have mmap, try using it as a backup when MORECORE fails or
-+ cannot be used. This is worth doing on systems that have "holes" in
-+ address space, so sbrk cannot extend to give contiguous space, but
-+ space is available elsewhere. Note that we ignore mmap max count
-+ and threshold limits, since the space will not be used as a
-+ segregated mmap region.
-+ */
-+
-+#if HAVE_MMAP
-+ if (brk == (char*)(MORECORE_FAILURE)) {
-+
-+ /* Cannot merge with old top, so add its size back in */
-+ if (contiguous(av))
-+ size = (size + old_size + pagemask) & ~pagemask;
-+
-+ /* If we are relying on mmap as backup, then use larger units */
-+ if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
-+ size = MMAP_AS_MORECORE_SIZE;
-+
-+ /* Don't try if size wraps around 0 */
-+ if ((unsigned long)(size) > (unsigned long)(nb)) {
-+
-+ brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
-+
-+ if (brk != (char*)(MORECORE_FAILURE)) {
-+
-+ /* We do not need, and cannot use, another sbrk call to find end */
-+ snd_brk = brk + size;
-+
-+ /*
-+ Record that we no longer have a contiguous sbrk region.
-+ After the first time mmap is used as backup, we do not
-+ ever rely on contiguous space since this could incorrectly
-+ bridge regions.
-+ */
-+ set_noncontiguous(av);
-+ }
-+ }
-+ }
-+#endif
-+
-+ if (brk != (char*)(MORECORE_FAILURE)) {
-+ av->sbrked_mem += size;
-+
-+ /*
-+ If MORECORE extends previous space, we can likewise extend top size.
-+ */
-+
-+ if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
-+ set_head(old_top, (size + old_size) | PREV_INUSE);
-+ }
-+
-+ /*
-+ Otherwise, make adjustments:
-+
-+ * If the first time through or noncontiguous, we need to call sbrk
-+ just to find out where the end of memory lies.
-+
-+ * We need to ensure that all returned chunks from malloc will meet
-+ MALLOC_ALIGNMENT
-+
-+ * If there was an intervening foreign sbrk, we need to adjust sbrk
-+ request size to account for fact that we will not be able to
-+ combine new space with existing space in old_top.
-+
-+ * Almost all systems internally allocate whole pages at a time, in
-+ which case we might as well use the whole last page of request.
-+ So we allocate enough more memory to hit a page boundary now,
-+ which in turn causes future contiguous calls to page-align.
-+ */
-+
-+ else {
-+ front_misalign = 0;
-+ end_misalign = 0;
-+ correction = 0;
-+ aligned_brk = brk;
-+
-+ /* handle contiguous cases */
-+ if (contiguous(av)) {
-+
-+ /* Guarantee alignment of first new chunk made from this space */
-+
-+ front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
-+ if (front_misalign > 0) {
-+
-+ /*
-+ Skip over some bytes to arrive at an aligned position.
-+ We don't need to specially mark these wasted front bytes.
-+ They will never be accessed anyway because
-+ prev_inuse of av->top (and any chunk created from its start)
-+ is always true after initialization.
-+ */
-+
-+ correction = MALLOC_ALIGNMENT - front_misalign;
-+ aligned_brk += correction;
-+ }
-+
-+ /*
-+ If this isn't adjacent to existing space, then we will not
-+ be able to merge with old_top space, so must add to 2nd request.
-+ */
-+
-+ correction += old_size;
-+
-+ /* Extend the end address to hit a page boundary */
-+ end_misalign = (INTERNAL_SIZE_T)(brk + size + correction);
-+ correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
-+
-+ assert(correction >= 0);
-+ snd_brk = (char*)(MORECORE(correction));
-+
-+ /*
-+ If can't allocate correction, try to at least find out current
-+ brk. It might be enough to proceed without failing.
-+
-+ Note that if second sbrk did NOT fail, we assume that space
-+ is contiguous with first sbrk. This is a safe assumption unless
-+ program is multithreaded but doesn't use locks and a foreign sbrk
-+ occurred between our first and second calls.
-+ */
-+
-+ if (snd_brk == (char*)(MORECORE_FAILURE)) {
-+ correction = 0;
-+ snd_brk = (char*)(MORECORE(0));
-+ }
-+ }
-+
-+ /* handle non-contiguous cases */
-+ else {
-+ /* MORECORE/mmap must correctly align */
-+ assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
-+
-+ /* Find out current end of memory */
-+ if (snd_brk == (char*)(MORECORE_FAILURE)) {
-+ snd_brk = (char*)(MORECORE(0));
-+ }
-+ }
-+
-+ /* Adjust top based on results of second sbrk */
-+ if (snd_brk != (char*)(MORECORE_FAILURE)) {
-+ av->top = (mchunkptr)aligned_brk;
-+ set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
-+ av->sbrked_mem += correction;
-+
-+ /*
-+ If not the first time through, we either have a
-+ gap due to foreign sbrk or a non-contiguous region. Insert a
-+ double fencepost at old_top to prevent consolidation with space
-+ we don't own. These fenceposts are artificial chunks that are
-+ marked as inuse and are in any case too small to use. We need
-+ two to make sizes and alignments work out.
-+ */
-+
-+ if (old_size != 0) {
-+ /*
-+ Shrink old_top to insert fenceposts, keeping size a
-+ multiple of MALLOC_ALIGNMENT. We know there is at least
-+ enough space in old_top to do this.
-+ */
-+ old_size = (old_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
-+ set_head(old_top, old_size | PREV_INUSE);
-+
-+ /*
-+ Note that the following assignments completely overwrite
-+ old_top when old_size was previously MINSIZE. This is
-+ intentional. We need the fencepost, even if old_top otherwise gets
-+ lost.
-+ */
-+ chunk_at_offset(old_top, old_size )->size =
-+ SIZE_SZ|PREV_INUSE;
-+
-+ chunk_at_offset(old_top, old_size + SIZE_SZ)->size =
-+ SIZE_SZ|PREV_INUSE;
-+
-+ /* If possible, release the rest. */
-+ if (old_size >= MINSIZE) {
-+ fREe(chunk2mem(old_top));
-+ }
-+
-+ }
-+ }
-+ }
-+
-+ /* Update statistics */
-+ sum = av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_sbrked_mem))
-+ av->max_sbrked_mem = sum;
-+
-+ sum += av->mmapped_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ check_malloc_state();
-+
-+ /* finally, do the allocation */
-+ p = av->top;
-+ size = chunksize(p);
-+
-+ /* check that one of the above allocation paths succeeded */
-+ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(p, nb);
-+ av->top = remainder;
-+ set_head(p, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ check_malloced_chunk(p, nb);
-+ return chunk2mem(p);
-+ }
-+ }
-+
-+ /* catch all failure paths */
-+ MALLOC_FAILURE_ACTION;
-+ return 0;
-+}
-+
-+
-+/*
-+ ------------------------------ malloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* mALLOc(size_t bytes)
-+#else
-+ Void_t* mALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T nb; /* normalized request size */
-+ unsigned int idx; /* associated bin index */
-+ mbinptr bin; /* associated bin */
-+ mfastbinptr* fb; /* associated fastbin */
-+
-+ mchunkptr victim; /* inspected/selected chunk */
-+ INTERNAL_SIZE_T size; /* its size */
-+ int victim_index; /* its bin index */
-+
-+ mchunkptr remainder; /* remainder from a split */
-+ unsigned long remainder_size; /* its size */
-+
-+ unsigned int block; /* bit map traverser */
-+ unsigned int bit; /* bit map traverser */
-+ unsigned int map; /* current word of binmap */
-+
-+ mchunkptr fwd; /* misc temp for linking */
-+ mchunkptr bck; /* misc temp for linking */
-+
-+ /*
-+ Convert request size to internal form by adding SIZE_SZ bytes
-+ overhead plus possibly more to obtain necessary alignment and/or
-+ to obtain a size of at least MINSIZE, the smallest allocatable
-+ size. Also, checked_request2size traps (returning 0) request sizes
-+ that are so large that they wrap around zero when padded and
-+ aligned.
-+ */
-+
-+ checked_request2size(bytes, nb);
-+
-+ /*
-+ If the size qualifies as a fastbin, first check corresponding bin.
-+ This code is safe to execute even if av is not yet initialized, so we
-+ can try it without checking, which saves some time on this fast path.
-+ */
-+
-+ if ((unsigned long)(nb) <= (unsigned long)(av->max_fast)) {
-+ fb = &(av->fastbins[(fastbin_index(nb))]);
-+ if ( (victim = *fb) != 0) {
-+ *fb = victim->fd;
-+ check_remalloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+
-+ /*
-+ If a small request, check regular bin. Since these "smallbins"
-+ hold one size each, no searching within bins is necessary.
-+ (For a large request, we need to wait until unsorted chunks are
-+ processed to find best fit. But for small ones, fits are exact
-+ anyway, so we can check now, which is faster.)
-+ */
-+
-+ if (in_smallbin_range(nb)) {
-+ idx = smallbin_index(nb);
-+ bin = bin_at(av,idx);
-+
-+ if ( (victim = last(bin)) != bin) {
-+ if (victim == 0) /* initialization check */
-+ malloc_consolidate(av);
-+ else {
-+ bck = victim->bk;
-+ set_inuse_bit_at_offset(victim, nb);
-+ bin->bk = bck;
-+ bck->fd = bin;
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ /*
-+ If this is a large request, consolidate fastbins before continuing.
-+ While it might look excessive to kill all fastbins before
-+ even seeing if there is space available, this avoids
-+ fragmentation problems normally associated with fastbins.
-+ Also, in practice, programs tend to have runs of either small or
-+ large requests, but less often mixtures, so consolidation is not
-+ invoked all that often in most programs. And the programs that
-+ it is called frequently in otherwise tend to fragment.
-+ */
-+
-+ else {
-+ idx = largebin_index(nb);
-+ if (have_fastchunks(av))
-+ malloc_consolidate(av);
-+ }
-+
-+ /*
-+ Process recently freed or remaindered chunks, taking one only if
-+ it is exact fit, or, if this a small request, the chunk is remainder from
-+ the most recent non-exact fit. Place other traversed chunks in
-+ bins. Note that this step is the only place in any routine where
-+ chunks are placed in bins.
-+
-+ The outer loop here is needed because we might not realize until
-+ near the end of malloc that we should have consolidated, so must
-+ do so and retry. This happens at most once, and only when we would
-+ otherwise need to expand memory to service a "small" request.
-+ */
-+
-+ for(;;) {
-+
-+ while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
-+ bck = victim->bk;
-+ size = chunksize(victim);
-+
-+ /*
-+ If a small request, try to use last remainder if it is the
-+ only chunk in unsorted bin. This helps promote locality for
-+ runs of consecutive small requests. This is the only
-+ exception to best-fit, and applies only when there is
-+ no exact fit for a small chunk.
-+ */
-+
-+ if (in_smallbin_range(nb) &&
-+ bck == unsorted_chunks(av) &&
-+ victim == av->last_remainder &&
-+ (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
-+
-+ /* split and reattach remainder */
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(victim, nb);
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ av->last_remainder = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* remove from unsorted list */
-+ unsorted_chunks(av)->bk = bck;
-+ bck->fd = unsorted_chunks(av);
-+
-+ /* Take now instead of binning if exact fit */
-+
-+ if (size == nb) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* place chunk in bin */
-+
-+ if (in_smallbin_range(size)) {
-+ victim_index = smallbin_index(size);
-+ bck = bin_at(av, victim_index);
-+ fwd = bck->fd;
-+ }
-+ else {
-+ victim_index = largebin_index(size);
-+ bck = bin_at(av, victim_index);
-+ fwd = bck->fd;
-+
-+ /* maintain large bins in sorted order */
-+ if (fwd != bck) {
-+ size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
-+ /* if smaller than smallest, bypass loop below */
-+ if ((unsigned long)(size) <= (unsigned long)(bck->bk->size)) {
-+ fwd = bck;
-+ bck = bck->bk;
-+ }
-+ else {
-+ while ((unsigned long)(size) < (unsigned long)(fwd->size))
-+ fwd = fwd->fd;
-+ bck = fwd->bk;
-+ }
-+ }
-+ }
-+
-+ mark_bin(av, victim_index);
-+ victim->bk = bck;
-+ victim->fd = fwd;
-+ fwd->bk = victim;
-+ bck->fd = victim;
-+ }
-+
-+ /*
-+ If a large request, scan through the chunks of current bin in
-+ sorted order to find smallest that fits. This is the only step
-+ where an unbounded number of chunks might be scanned without doing
-+ anything useful with them. However the lists tend to be short.
-+ */
-+
-+ if (!in_smallbin_range(nb)) {
-+ bin = bin_at(av, idx);
-+
-+ /* skip scan if empty or largest chunk is too small */
-+ if ((victim = last(bin)) != bin &&
-+ (unsigned long)(first(bin)->size) >= (unsigned long)(nb)) {
-+
-+ while (((unsigned long)(size = chunksize(victim)) <
-+ (unsigned long)(nb)))
-+ victim = victim->bk;
-+
-+ remainder_size = size - nb;
-+ unlink(victim, bck, fwd);
-+
-+ /* Exhaust */
-+ if (remainder_size < MINSIZE) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ /* Split */
-+ else {
-+ remainder = chunk_at_offset(victim, nb);
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ /*
-+ Search for a chunk by scanning bins, starting with next largest
-+ bin. This search is strictly by best-fit; i.e., the smallest
-+ (with ties going to approximately the least recently used) chunk
-+ that fits is selected.
-+
-+ The bitmap avoids needing to check that most blocks are nonempty.
-+ The particular case of skipping all bins during warm-up phases
-+ when no chunks have been returned yet is faster than it might look.
-+ */
-+
-+ ++idx;
-+ bin = bin_at(av,idx);
-+ block = idx2block(idx);
-+ map = av->binmap[block];
-+ bit = idx2bit(idx);
-+
-+ for (;;) {
-+
-+ /* Skip rest of block if there are no more set bits in this block. */
-+ if (bit > map || bit == 0) {
-+ do {
-+ if (++block >= BINMAPSIZE) /* out of bins */
-+ goto use_top;
-+ } while ( (map = av->binmap[block]) == 0);
-+
-+ bin = bin_at(av, (block << BINMAPSHIFT));
-+ bit = 1;
-+ }
-+
-+ /* Advance to bin with set bit. There must be one. */
-+ while ((bit & map) == 0) {
-+ bin = next_bin(bin);
-+ bit <<= 1;
-+ assert(bit != 0);
-+ }
-+
-+ /* Inspect the bin. It is likely to be non-empty */
-+ victim = last(bin);
-+
-+ /* If a false alarm (empty bin), clear the bit. */
-+ if (victim == bin) {
-+ av->binmap[block] = map &= ~bit; /* Write through */
-+ bin = next_bin(bin);
-+ bit <<= 1;
-+ }
-+
-+ else {
-+ size = chunksize(victim);
-+
-+ /* We know the first chunk in this bin is big enough to use. */
-+ assert((unsigned long)(size) >= (unsigned long)(nb));
-+
-+ remainder_size = size - nb;
-+
-+ /* unlink */
-+ bck = victim->bk;
-+ bin->bk = bck;
-+ bck->fd = bin;
-+
-+ /* Exhaust */
-+ if (remainder_size < MINSIZE) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* Split */
-+ else {
-+ remainder = chunk_at_offset(victim, nb);
-+
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+ /* advertise as last remainder */
-+ if (in_smallbin_range(nb))
-+ av->last_remainder = remainder;
-+
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ use_top:
-+ /*
-+ If large enough, split off the chunk bordering the end of memory
-+ (held in av->top). Note that this is in accord with the best-fit
-+ search rule. In effect, av->top is treated as larger (and thus
-+ less well fitting) than any other available chunk since it can
-+ be extended to be as large as necessary (up to system
-+ limitations).
-+
-+ We require that av->top always exists (i.e., has size >=
-+ MINSIZE) after initialization, so if it would otherwise be
-+ exhuasted by current request, it is replenished. (The main
-+ reason for ensuring it exists is that we may need MINSIZE space
-+ to put in fenceposts in sysmalloc.)
-+ */
-+
-+ victim = av->top;
-+ size = chunksize(victim);
-+
-+ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(victim, nb);
-+ av->top = remainder;
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /*
-+ If there is space available in fastbins, consolidate and retry,
-+ to possibly avoid expanding memory. This can occur only if nb is
-+ in smallbin range so we didn't consolidate upon entry.
-+ */
-+
-+ else if (have_fastchunks(av)) {
-+ assert(in_smallbin_range(nb));
-+ malloc_consolidate(av);
-+ idx = smallbin_index(nb); /* restore original bin index */
-+ }
-+
-+ /*
-+ Otherwise, relay to handle system-dependent cases
-+ */
-+ else
-+ return sYSMALLOc(nb, av);
-+ }
-+}
-+
-+/*
-+ ------------------------------ realloc ------------------------------
-+*/
-+
-+
-+INLINE
-+#if __STD_C
-+Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
-+#else
-+Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T nb; /* padded request size */
-+
-+ mchunkptr oldp; /* chunk corresponding to oldmem */
-+ INTERNAL_SIZE_T oldsize; /* its size */
-+
-+ mchunkptr newp; /* chunk to return */
-+ INTERNAL_SIZE_T newsize; /* its size */
-+ Void_t* newmem; /* corresponding user mem */
-+
-+ mchunkptr next; /* next contiguous chunk after oldp */
-+
-+ mchunkptr remainder; /* extra space at end of newp */
-+ unsigned long remainder_size; /* its size */
-+
-+ mchunkptr bck; /* misc temp for linking */
-+ mchunkptr fwd; /* misc temp for linking */
-+
-+ unsigned long copysize; /* bytes to copy */
-+ unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
-+ INTERNAL_SIZE_T* s; /* copy source */
-+ INTERNAL_SIZE_T* d; /* copy destination */
-+
-+
-+#ifdef REALLOC_ZERO_BYTES_FREES
-+ if (bytes == 0) {
-+ fREe(oldmem);
-+ return 0;
-+ }
-+#endif
-+
-+ /* realloc of null is supposed to be same as malloc */
-+ if (oldmem == 0) return mALLOc(bytes);
-+
-+ checked_request2size(bytes, nb);
-+
-+ oldp = mem2chunk(oldmem);
-+ oldsize = chunksize(oldp);
-+
-+ check_inuse_chunk(oldp);
-+
-+ if (!chunk_is_mmapped(oldp)) {
-+
-+ if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
-+ /* already big enough; split below */
-+ newp = oldp;
-+ newsize = oldsize;
-+ }
-+
-+ else {
-+ next = chunk_at_offset(oldp, oldsize);
-+
-+ /* Try to expand forward into top */
-+ if (next == av->top &&
-+ (unsigned long)(newsize = oldsize + chunksize(next)) >=
-+ (unsigned long)(nb + MINSIZE)) {
-+ set_head_size(oldp, nb);
-+ av->top = chunk_at_offset(oldp, nb);
-+ set_head(av->top, (newsize - nb) | PREV_INUSE);
-+ return chunk2mem(oldp);
-+ }
-+
-+ /* Try to expand forward into next chunk; split off remainder below */
-+ else if (next != av->top &&
-+ !inuse(next) &&
-+ (unsigned long)(newsize = oldsize + chunksize(next)) >=
-+ (unsigned long)(nb)) {
-+ newp = oldp;
-+ unlink(next, bck, fwd);
-+ }
-+
-+ /* allocate, copy, free */
-+ else {
-+ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
-+ if (newmem == 0)
-+ return 0; /* propagate failure */
-+
-+ newp = mem2chunk(newmem);
-+ newsize = chunksize(newp);
-+
-+ /*
-+ Avoid copy if newp is next chunk after oldp.
-+ */
-+ if (newp == next) {
-+ newsize += oldsize;
-+ newp = oldp;
-+ }
-+ else {
-+ /*
-+ Unroll copy of <= 36 bytes (72 if 8byte sizes)
-+ We know that contents have an odd number of
-+ INTERNAL_SIZE_T-sized words; minimally 3.
-+ */
-+
-+ copysize = oldsize - SIZE_SZ;
-+ s = (INTERNAL_SIZE_T*)(oldmem);
-+ d = (INTERNAL_SIZE_T*)(newmem);
-+ ncopies = copysize / sizeof(INTERNAL_SIZE_T);
-+ assert(ncopies >= 3);
-+
-+ if (ncopies > 9)
-+ MALLOC_COPY(d, s, copysize);
-+
-+ else {
-+ *(d+0) = *(s+0);
-+ *(d+1) = *(s+1);
-+ *(d+2) = *(s+2);
-+ if (ncopies > 4) {
-+ *(d+3) = *(s+3);
-+ *(d+4) = *(s+4);
-+ if (ncopies > 6) {
-+ *(d+5) = *(s+5);
-+ *(d+6) = *(s+6);
-+ if (ncopies > 8) {
-+ *(d+7) = *(s+7);
-+ *(d+8) = *(s+8);
-+ }
-+ }
-+ }
-+ }
-+
-+ fREe(oldmem);
-+ check_inuse_chunk(newp);
-+ return chunk2mem(newp);
-+ }
-+ }
-+ }
-+
-+ /* If possible, free extra space in old or extended chunk */
-+
-+ assert((unsigned long)(newsize) >= (unsigned long)(nb));
-+
-+ remainder_size = newsize - nb;
-+
-+ if (remainder_size < MINSIZE) { /* not enough extra to split off */
-+ set_head_size(newp, newsize);
-+ set_inuse_bit_at_offset(newp, newsize);
-+ }
-+ else { /* split remainder */
-+ remainder = chunk_at_offset(newp, nb);
-+ set_head_size(newp, nb);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ /* Mark remainder as inuse so free() won't complain */
-+ set_inuse_bit_at_offset(remainder, remainder_size);
-+ fREe(chunk2mem(remainder));
-+ }
-+
-+ check_inuse_chunk(newp);
-+ return chunk2mem(newp);
-+ }
-+
-+ /*
-+ Handle mmap cases
-+ */
-+
-+ else {
-+#if HAVE_MMAP
-+
-+#if HAVE_MREMAP
-+ INTERNAL_SIZE_T offset = oldp->prev_size;
-+ size_t pagemask = av->pagesize - 1;
-+ char *cp;
-+ unsigned long sum;
-+
-+ /* Note the extra SIZE_SZ overhead */
-+ newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask;
-+
-+ /* don't need to remap if still within same page */
-+ if (oldsize == newsize - offset)
-+ return oldmem;
-+
-+ cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
-+
-+ if (cp != (char*)MORECORE_FAILURE) {
-+
-+ newp = (mchunkptr)(cp + offset);
-+ set_head(newp, (newsize - offset)|IS_MMAPPED);
-+
-+ assert(aligned_OK(chunk2mem(newp)));
-+ assert((newp->prev_size == offset));
-+
-+ /* update statistics */
-+ sum = av->mmapped_mem += newsize - oldsize;
-+ if (sum > (unsigned long)(av->max_mmapped_mem))
-+ av->max_mmapped_mem = sum;
-+ sum += av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ return chunk2mem(newp);
-+ }
-+#endif
-+
-+ /* Note the extra SIZE_SZ overhead. */
-+ if ((unsigned long)(oldsize) >= (unsigned long)(nb + SIZE_SZ))
-+ newmem = oldmem; /* do nothing */
-+ else {
-+ /* Must alloc, copy, free. */
-+ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
-+ if (newmem != 0) {
-+ MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
-+ fREe(oldmem);
-+ }
-+ }
-+ return newmem;
-+
-+#else
-+ /* If !HAVE_MMAP, but chunk_is_mmapped, user must have overwritten mem */
-+ check_malloc_state();
-+ MALLOC_FAILURE_ACTION;
-+ return 0;
-+#endif
-+ }
-+}
-+
-+/*
-+ ------------------------------ memalign ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* mEMALIGn(size_t alignment, size_t bytes)
-+#else
-+Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
-+#endif
-+{
-+ INTERNAL_SIZE_T nb; /* padded request size */
-+ char* m; /* memory returned by malloc call */
-+ mchunkptr p; /* corresponding chunk */
-+ char* brk; /* alignment point within p */
-+ mchunkptr newp; /* chunk to return */
-+ INTERNAL_SIZE_T newsize; /* its size */
-+ INTERNAL_SIZE_T leadsize; /* leading space before alignment point */
-+ mchunkptr remainder; /* spare room at end to split off */
-+ unsigned long remainder_size; /* its size */
-+ INTERNAL_SIZE_T size;
-+
-+ /* If need less alignment than we give anyway, just relay to malloc */
-+
-+ if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
-+
-+ /* Otherwise, ensure that it is at least a minimum chunk size */
-+
-+ if (alignment < MINSIZE) alignment = MINSIZE;
-+
-+ /* Make sure alignment is power of 2 (in case MINSIZE is not). */
-+ if ((alignment & (alignment - 1)) != 0) {
-+ size_t a = MALLOC_ALIGNMENT * 2;
-+ while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
-+ alignment = a;
-+ }
-+
-+ checked_request2size(bytes, nb);
-+
-+ /*
-+ Strategy: find a spot within that chunk that meets the alignment
-+ request, and then possibly free the leading and trailing space.
-+ */
-+
-+
-+ /* Call malloc with worst case padding to hit alignment. */
-+
-+ m = (char*)(mALLOc(nb + alignment + MINSIZE));
-+
-+ if (m == 0) return 0; /* propagate failure */
-+
-+ p = mem2chunk(m);
-+
-+ if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
-+
-+ /*
-+ Find an aligned spot inside chunk. Since we need to give back
-+ leading space in a chunk of at least MINSIZE, if the first
-+ calculation places us at a spot with less than MINSIZE leader,
-+ we can move to the next aligned spot -- we've allocated enough
-+ total room so that this is always possible.
-+ */
-+
-+ brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) &
-+ -((signed long) alignment));
-+ if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
-+ brk += alignment;
-+
-+ newp = (mchunkptr)brk;
-+ leadsize = brk - (char*)(p);
-+ newsize = chunksize(p) - leadsize;
-+
-+ /* For mmapped chunks, just adjust offset */
-+ if (chunk_is_mmapped(p)) {
-+ newp->prev_size = p->prev_size + leadsize;
-+ set_head(newp, newsize|IS_MMAPPED);
-+ return chunk2mem(newp);
-+ }
-+
-+ /* Otherwise, give back leader, use the rest */
-+ set_head(newp, newsize | PREV_INUSE);
-+ set_inuse_bit_at_offset(newp, newsize);
-+ set_head_size(p, leadsize);
-+ fREe(chunk2mem(p));
-+ p = newp;
-+
-+ assert (newsize >= nb &&
-+ (((unsigned long)(chunk2mem(p))) % alignment) == 0);
-+ }
-+
-+ /* Also give back spare room at the end */
-+ if (!chunk_is_mmapped(p)) {
-+ size = chunksize(p);
-+ if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(p, nb);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_head_size(p, nb);
-+ fREe(chunk2mem(remainder));
-+ }
-+ }
-+
-+ check_inuse_chunk(p);
-+ return chunk2mem(p);
-+}
-+
-+/*
-+ ------------------------------ calloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* cALLOc(size_t n_elements, size_t elem_size)
-+#else
-+Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size;
-+#endif
-+{
-+ mchunkptr p;
-+ unsigned long clearsize;
-+ unsigned long nclears;
-+ INTERNAL_SIZE_T* d;
-+
-+ Void_t* mem = mALLOc(n_elements * elem_size);
-+
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+
-+ if (!chunk_is_mmapped(p))
-+ {
-+ /*
-+ Unroll clear of <= 36 bytes (72 if 8byte sizes)
-+ We know that contents have an odd number of
-+ INTERNAL_SIZE_T-sized words; minimally 3.
-+ */
-+
-+ d = (INTERNAL_SIZE_T*)mem;
-+ clearsize = chunksize(p) - SIZE_SZ;
-+ nclears = clearsize / sizeof(INTERNAL_SIZE_T);
-+ assert(nclears >= 3);
-+
-+ if (nclears > 9)
-+ MALLOC_ZERO(d, clearsize);
-+
-+ else {
-+ *(d+0) = 0;
-+ *(d+1) = 0;
-+ *(d+2) = 0;
-+ if (nclears > 4) {
-+ *(d+3) = 0;
-+ *(d+4) = 0;
-+ if (nclears > 6) {
-+ *(d+5) = 0;
-+ *(d+6) = 0;
-+ if (nclears > 8) {
-+ *(d+7) = 0;
-+ *(d+8) = 0;
-+ }
-+ }
-+ }
-+ }
-+ }
-+#if ! MMAP_CLEARS
-+ else
-+ {
-+ d = (INTERNAL_SIZE_T*)mem;
-+ clearsize = chunksize(p) - 2 * SIZE_SZ;
-+ MALLOC_ZERO(d, clearsize);
-+ }
-+#endif
-+ }
-+ return mem;
-+}
-+
-+/*
-+ ------------------------------ cfree ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+void cFREe(Void_t *mem)
-+#else
-+void cFREe(mem) Void_t *mem;
-+#endif
-+{
-+ fREe(mem);
-+}
-+
-+/*
-+ ------------------------------ ialloc ------------------------------
-+ ialloc 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
-+*/
-+
-+
-+INLINE
-+#if __STD_C
-+static Void_t** iALLOc(size_t n_elements,
-+ size_t* sizes,
-+ int opts,
-+ Void_t* chunks[])
-+#else
-+static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ INTERNAL_SIZE_T element_size; /* chunksize of each element, if all same */
-+ INTERNAL_SIZE_T contents_size; /* total size of elements */
-+ INTERNAL_SIZE_T array_size; /* request size of pointer array */
-+ Void_t* mem; /* malloced aggregate space */
-+ mchunkptr p; /* corresponding chunk */
-+ INTERNAL_SIZE_T remainder_size; /* remaining bytes while splitting */
-+ Void_t** marray; /* either "chunks" or malloced ptr array */
-+ mchunkptr array_chunk; /* chunk for malloced ptr array */
-+ int mmx; /* to disable mmap */
-+ INTERNAL_SIZE_T size;
-+ size_t i;
-+
-+ /* Ensure initialization/consolidation */
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+
-+ /* 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_t**) mALLOc(0);
-+ marray = 0;
-+ array_size = request2size(n_elements * (sizeof(Void_t*)));
-+ }
-+
-+ /* 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]);
-+ }
-+
-+ /* subtract out alignment bytes from total to minimize overallocation */
-+ size = contents_size + array_size - MALLOC_ALIGN_MASK;
-+
-+ /*
-+ Allocate the aggregate chunk.
-+ But first disable mmap so malloc won't use it, since
-+ we would not be able to later free/realloc space internal
-+ to a segregated mmap region.
-+ */
-+ mmx = av->n_mmaps_max; /* disable mmap */
-+ av->n_mmaps_max = 0;
-+ mem = mALLOc(size);
-+ av->n_mmaps_max = mmx; /* reset mmap */
-+ if (mem == 0)
-+ return 0;
-+
-+ p = mem2chunk(mem);
-+ assert(!chunk_is_mmapped(p));
-+ remainder_size = chunksize(p);
-+
-+ if (opts & 0x2) { /* optionally clear the elements */
-+ MALLOC_ZERO(mem, remainder_size - SIZE_SZ - array_size);
-+ }
-+
-+ /* If not provided, allocate the pointer array as final part of chunk */
-+ if (marray == 0) {
-+ array_chunk = chunk_at_offset(p, contents_size);
-+ marray = (Void_t**) (chunk2mem(array_chunk));
-+ set_head(array_chunk, (remainder_size - contents_size) | PREV_INUSE);
-+ 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_head(p, size | PREV_INUSE);
-+ p = chunk_at_offset(p, size);
-+ }
-+ else { /* the final element absorbs any overallocation slop */
-+ set_head(p, remainder_size | PREV_INUSE);
-+ break;
-+ }
-+ }
-+
-+#ifdef 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(mem2chunk(marray));
-+ }
-+
-+ for (i = 0; i != n_elements; ++i)
-+ check_inuse_chunk(mem2chunk(marray[i]));
-+#endif
-+
-+ return marray;
-+}
-+
-+
-+/*
-+ ------------------------- independent_calloc -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])
-+#else
-+Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];
-+#endif
-+{
-+ size_t sz = elem_size; /* serves as 1-element array */
-+ /* opts arg of 3 means all elements are same size, and should be cleared */
-+ return iALLOc(n_elements, &sz, 3, chunks);
-+}
-+
-+/*
-+ ------------------------- independent_comalloc -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])
-+#else
-+Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];
-+#endif
-+{
-+ return iALLOc(n_elements, sizes, 0, chunks);
-+}
-+
-+
-+/*
-+ ------------------------------ valloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* vALLOc(size_t bytes)
-+#else
-+Void_t* vALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ /* Ensure initialization/consolidation */
-+ mstate av = get_malloc_state();
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+ return mEMALIGn(av->pagesize, bytes);
-+}
-+
-+/*
-+ ------------------------------ pvalloc ------------------------------
-+*/
-+
-+
-+#if __STD_C
-+Void_t* pVALLOc(size_t bytes)
-+#else
-+Void_t* pVALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ size_t pagesz;
-+
-+ /* Ensure initialization/consolidation */
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+ pagesz = av->pagesize;
-+ return mEMALIGn(pagesz, (bytes + pagesz - 1) & ~(pagesz - 1));
-+}
-+
-+
-+/*
-+ ------------------------------ malloc_trim ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+int mTRIm(size_t pad)
-+#else
-+int mTRIm(pad) size_t pad;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ /* Ensure initialization/consolidation */
-+ malloc_consolidate(av);
-+
-+#ifndef MORECORE_CANNOT_TRIM
-+ return sYSTRIm(pad, av);
-+#else
-+ return 0;
-+#endif
-+}
-+
-+
-+/*
-+ ------------------------- malloc_usable_size -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+size_t mUSABLe(Void_t* mem)
-+#else
-+size_t mUSABLe(mem) Void_t* mem;
-+#endif
-+{
-+ mchunkptr p;
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+ if (chunk_is_mmapped(p))
-+ return chunksize(p) - 2*SIZE_SZ;
-+ else if (inuse(p))
-+ return chunksize(p) - SIZE_SZ;
-+ }
-+ return 0;
-+}
-+
-+/*
-+ ------------------------------ mallinfo ------------------------------
-+*/
-+
-+struct mallinfo mALLINFo()
-+{
-+ mstate av = get_malloc_state();
-+ struct mallinfo mi;
-+ unsigned int i;
-+ mbinptr b;
-+ mchunkptr p;
-+ INTERNAL_SIZE_T avail;
-+ INTERNAL_SIZE_T fastavail;
-+ int nblocks;
-+ int nfastblocks;
-+
-+ /* Ensure initialization */
-+ if (av->top == 0) malloc_consolidate(av);
-+
-+ check_malloc_state();
-+
-+ /* Account for top */
-+ avail = chunksize(av->top);
-+ nblocks = 1; /* top always exists */
-+
-+ /* traverse fastbins */
-+ nfastblocks = 0;
-+ fastavail = 0;
-+
-+ for (i = 0; i < NFASTBINS; ++i) {
-+ for (p = av->fastbins[i]; p != 0; p = p->fd) {
-+ ++nfastblocks;
-+ fastavail += chunksize(p);
-+ }
-+ }
-+
-+ avail += fastavail;
-+
-+ /* traverse regular bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ b = bin_at(av, i);
-+ for (p = last(b); p != b; p = p->bk) {
-+ ++nblocks;
-+ avail += chunksize(p);
-+ }
-+ }
-+
-+ mi.smblks = nfastblocks;
-+ mi.ordblks = nblocks;
-+ mi.fordblks = avail;
-+ mi.uordblks = av->sbrked_mem - avail;
-+ mi.arena = av->sbrked_mem;
-+ mi.hblks = av->n_mmaps;
-+ mi.hblkhd = av->mmapped_mem;
-+ mi.fsmblks = fastavail;
-+ mi.keepcost = chunksize(av->top);
-+ mi.usmblks = av->max_total_mem;
-+ return mi;
-+}
-+
-+/*
-+ ------------------------------ malloc_stats ------------------------------
-+*/
-+
-+void mSTATs()
-+{
-+ struct mallinfo mi = mALLINFo();
-+
-+#ifdef WIN32
-+ {
-+ unsigned long free, reserved, committed;
-+ vminfo (&free, &reserved, &committed);
-+ fprintf(stderr, "free bytes = %10lu\n",
-+ free);
-+ fprintf(stderr, "reserved bytes = %10lu\n",
-+ reserved);
-+ fprintf(stderr, "committed bytes = %10lu\n",
-+ committed);
-+ }
-+#endif
-+
-+
-+ fprintf(stderr, "max system bytes = %10lu\n",
-+ (unsigned long)(mi.usmblks));
-+ fprintf(stderr, "system bytes = %10lu\n",
-+ (unsigned long)(mi.arena + mi.hblkhd));
-+ fprintf(stderr, "in use bytes = %10lu\n",
-+ (unsigned long)(mi.uordblks + mi.hblkhd));
-+
-+
-+#ifdef WIN32
-+ {
-+ unsigned long kernel, user;
-+ if (cpuinfo (TRUE, &kernel, &user)) {
-+ fprintf(stderr, "kernel ms = %10lu\n",
-+ kernel);
-+ fprintf(stderr, "user ms = %10lu\n",
-+ user);
-+ }
-+ }
-+#endif
-+}
-+
-+
-+/*
-+ ------------------------------ mallopt ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+int mALLOPt(int param_number, int value)
-+#else
-+int mALLOPt(param_number, value) int param_number; int value;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ /* Ensure initialization/consolidation */
-+ malloc_consolidate(av);
-+
-+ switch(param_number) {
-+ case M_MXFAST:
-+ if (value >= 0 && value <= MAX_FAST_SIZE) {
-+ set_max_fast(av, value);
-+ return 1;
-+ }
-+ else
-+ return 0;
-+
-+ case M_TRIM_THRESHOLD:
-+ av->trim_threshold = value;
-+ return 1;
-+
-+ case M_TOP_PAD:
-+ av->top_pad = value;
-+ return 1;
-+
-+ case M_MMAP_THRESHOLD:
-+ av->mmap_threshold = value;
-+ return 1;
-+
-+ case M_MMAP_MAX:
-+#if !HAVE_MMAP
-+ if (value != 0)
-+ return 0;
-+#endif
-+ av->n_mmaps_max = value;
-+ return 1;
-+
-+ default:
-+ return 0;
-+ }
-+}
-+
-+
-+/*
-+ -------------------- Alternative MORECORE functions --------------------
-+*/
-+
-+
-+/*
-+ General Requirements for MORECORE.
-+
-+ The MORECORE function must have the following properties:
-+
-+ If MORECORE_CONTIGUOUS is false:
-+
-+ * MORECORE must allocate in multiples of pagesize. It will
-+ only be called with arguments that are multiples of pagesize.
-+
-+ * MORECORE(0) must return an address that is at least
-+ MALLOC_ALIGNMENT aligned. (Page-aligning always suffices.)
-+
-+ else (i.e. If MORECORE_CONTIGUOUS is true):
-+
-+ * Consecutive calls to MORECORE with positive arguments
-+ return increasing addresses, indicating that space has been
-+ contiguously extended.
-+
-+ * MORECORE need not allocate in multiples of pagesize.
-+ Calls to MORECORE need not have args of multiples of pagesize.
-+
-+ * MORECORE need not page-align.
-+
-+ In either case:
-+
-+ * MORECORE may allocate more memory than requested. (Or even less,
-+ but this will generally result in a malloc failure.)
-+
-+ * MORECORE must not allocate memory when given argument zero, but
-+ instead return one past the end address of memory from previous
-+ nonzero call. This malloc does NOT call MORECORE(0)
-+ until at least one call with positive arguments is made, so
-+ the initial value returned is not important.
-+
-+ * Even though consecutive calls to MORECORE need not return contiguous
-+ addresses, it must be OK for malloc'ed chunks to span multiple
-+ regions in those cases where they do happen to be contiguous.
-+
-+ * MORECORE need not handle negative arguments -- it may instead
-+ just return MORECORE_FAILURE when given negative arguments.
-+ Negative arguments are always multiples of pagesize. MORECORE
-+ must not misinterpret negative args as large positive unsigned
-+ args. You can suppress all such calls from even occurring by defining
-+ MORECORE_CANNOT_TRIM,
-+
-+ There is some variation across systems about the type of the
-+ argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
-+ actually be size_t, because sbrk supports negative args, so it is
-+ normally the signed type of the same width as size_t (sometimes
-+ declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much
-+ matter though. Internally, we use "long" as arguments, which should
-+ work across all reasonable possibilities.
-+
-+ Additionally, if MORECORE ever returns failure for a positive
-+ 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 map noncontiguous space.
-+
-+ If you'd like mmap to ALWAYS be used, you can define MORECORE to be
-+ a function that always returns MORECORE_FAILURE.
-+
-+ If you are using this malloc with something other than sbrk (or its
-+ emulation) to supply memory regions, you probably want to set
-+ MORECORE_CONTIGUOUS as false. As an example, here is a custom
-+ allocator kindly contributed for pre-OSX macOS. It uses virtually
-+ but not necessarily physically contiguous non-paged memory (locked
-+ in, present and won't get swapped out). You can use it by
-+ uncommenting this section, adding some #includes, and setting up the
-+ appropriate defines above:
-+
-+ #define MORECORE osMoreCore
-+ #define MORECORE_CONTIGUOUS 0
-+
-+ There is also a shutdown routine that should somehow be called for
-+ cleanup upon program exit.
-+
-+ #define MAX_POOL_ENTRIES 100
-+ #define MINIMUM_MORECORE_SIZE (64 * 1024)
-+ static int next_os_pool;
-+ void *our_os_pools[MAX_POOL_ENTRIES];
-+
-+ void *osMoreCore(int size)
-+ {
-+ void *ptr = 0;
-+ static void *sbrk_top = 0;
-+
-+ if (size > 0)
-+ {
-+ if (size < MINIMUM_MORECORE_SIZE)
-+ size = MINIMUM_MORECORE_SIZE;
-+ if (CurrentExecutionLevel() == kTaskLevel)
-+ ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
-+ if (ptr == 0)
-+ {
-+ return (void *) MORECORE_FAILURE;
-+ }
-+ // save ptrs so they can be freed during cleanup
-+ our_os_pools[next_os_pool] = ptr;
-+ next_os_pool++;
-+ ptr = (void *) ((((unsigned long) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
-+ sbrk_top = (char *) ptr + size;
-+ return ptr;
-+ }
-+ else if (size < 0)
-+ {
-+ // we don't currently support shrink behavior
-+ return (void *) MORECORE_FAILURE;
-+ }
-+ else
-+ {
-+ return sbrk_top;
-+ }
-+ }
-+
-+ // cleanup any allocated memory pools
-+ // called as last thing before shutting down driver
-+
-+ void osCleanupMem(void)
-+ {
-+ void **ptr;
-+
-+ for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
-+ if (*ptr)
-+ {
-+ PoolDeallocate(*ptr);
-+ *ptr = 0;
-+ }
-+ }
-+
-+*/
-+
-+
-+/*
-+ --------------------------------------------------------------
-+
-+ Emulation of sbrk for win32.
-+ Donated by J. Walter <Walter@GeNeSys-e.de>.
-+ For additional information about this code, and malloc on Win32, see
-+ http://www.genesys-e.de/jwalter/
-+*/
-+
-+
-+#ifdef WIN32
-+
-+#ifdef _DEBUG
-+/* #define TRACE */
-+#endif
-+
-+/* Support for USE_MALLOC_LOCK */
-+#ifdef USE_MALLOC_LOCK
-+
-+/* Wait for spin lock */
-+static int slwait (int *sl) {
-+ while (InterlockedCompareExchange ((void **) sl, (void *) 1, (void *) 0) != 0)
-+ Sleep (0);
-+ return 0;
-+}
-+
-+/* Release spin lock */
-+static int slrelease (int *sl) {
-+ InterlockedExchange (sl, 0);
-+ return 0;
-+}
-+
-+#ifdef NEEDED
-+/* Spin lock for emulation code */
-+static int g_sl;
-+#endif
-+
-+#endif /* USE_MALLOC_LOCK */
-+
-+/* getpagesize for windows */
-+static long getpagesize (void) {
-+ static long g_pagesize = 0;
-+ if (! g_pagesize) {
-+ SYSTEM_INFO system_info;
-+ GetSystemInfo (&system_info);
-+ g_pagesize = system_info.dwPageSize;
-+ }
-+ return g_pagesize;
-+}
-+static long getregionsize (void) {
-+ static long g_regionsize = 0;
-+ if (! g_regionsize) {
-+ SYSTEM_INFO system_info;
-+ GetSystemInfo (&system_info);
-+ g_regionsize = system_info.dwAllocationGranularity;
-+ }
-+ return g_regionsize;
-+}
-+
-+/* A region list entry */
-+typedef struct _region_list_entry {
-+ void *top_allocated;
-+ void *top_committed;
-+ void *top_reserved;
-+ long reserve_size;
-+ struct _region_list_entry *previous;
-+} region_list_entry;
-+
-+/* Allocate and link a region entry in the region list */
-+static int region_list_append (region_list_entry **last, void *base_reserved, long reserve_size) {
-+ region_list_entry *next = HeapAlloc (GetProcessHeap (), 0, sizeof (region_list_entry));
-+ if (! next)
-+ return FALSE;
-+ next->top_allocated = (char *) base_reserved;
-+ next->top_committed = (char *) base_reserved;
-+ next->top_reserved = (char *) base_reserved + reserve_size;
-+ next->reserve_size = reserve_size;
-+ next->previous = *last;
-+ *last = next;
-+ return TRUE;
-+}
-+/* Free and unlink the last region entry from the region list */
-+static int region_list_remove (region_list_entry **last) {
-+ region_list_entry *previous = (*last)->previous;
-+ if (! HeapFree (GetProcessHeap (), sizeof (region_list_entry), *last))
-+ return FALSE;
-+ *last = previous;
-+ return TRUE;
-+}
-+
-+#define CEIL(size,to) (((size)+(to)-1)&~((to)-1))
-+#define FLOOR(size,to) ((size)&~((to)-1))
-+
-+#define SBRK_SCALE 0
-+/* #define SBRK_SCALE 1 */
-+/* #define SBRK_SCALE 2 */
-+/* #define SBRK_SCALE 4 */
-+
-+/* sbrk for windows */
-+static void *sbrk (long size) {
-+ static long g_pagesize, g_my_pagesize;
-+ static long g_regionsize, g_my_regionsize;
-+ static region_list_entry *g_last;
-+ void *result = (void *) MORECORE_FAILURE;
-+#ifdef TRACE
-+ printf ("sbrk %d\n", size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize) {
-+ g_pagesize = getpagesize ();
-+ g_my_pagesize = g_pagesize << SBRK_SCALE;
-+ }
-+ if (! g_regionsize) {
-+ g_regionsize = getregionsize ();
-+ g_my_regionsize = g_regionsize << SBRK_SCALE;
-+ }
-+ if (! g_last) {
-+ if (! region_list_append (&g_last, 0, 0))
-+ goto sbrk_exit;
-+ }
-+ /* Assert invariants */
-+ assert (g_last);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
-+ g_last->top_allocated <= g_last->top_committed);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
-+ g_last->top_committed <= g_last->top_reserved &&
-+ (unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
-+ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
-+ /* Allocation requested? */
-+ if (size >= 0) {
-+ /* Allocation size is the requested size */
-+ long allocate_size = size;
-+ /* Compute the size to commit */
-+ long to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Do we reach the commit limit? */
-+ if (to_commit > 0) {
-+ /* Round size to commit */
-+ long commit_size = CEIL (to_commit, g_my_pagesize);
-+ /* Compute the size to reserve */
-+ long to_reserve = (char *) g_last->top_committed + commit_size - (char *) g_last->top_reserved;
-+ /* Do we reach the reserve limit? */
-+ if (to_reserve > 0) {
-+ /* Compute the remaining size to commit in the current region */
-+ long remaining_commit_size = (char *) g_last->top_reserved - (char *) g_last->top_committed;
-+ if (remaining_commit_size > 0) {
-+ /* Assert preconditions */
-+ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert (0 < remaining_commit_size && remaining_commit_size % g_pagesize == 0); {
-+ /* Commit this */
-+ void *base_committed = VirtualAlloc (g_last->top_committed, remaining_commit_size,
-+ MEM_COMMIT, PAGE_READWRITE);
-+ /* Check returned pointer for consistency */
-+ if (base_committed != g_last->top_committed)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", base_committed, remaining_commit_size);
-+#endif
-+ /* Adjust the regions commit top */
-+ g_last->top_committed = (char *) base_committed + remaining_commit_size;
-+ }
-+ } {
-+ /* Now we are going to search and reserve. */
-+ int contiguous = -1;
-+ int found = FALSE;
-+ MEMORY_BASIC_INFORMATION memory_info;
-+ void *base_reserved;
-+ long reserve_size;
-+ do {
-+ /* Assume contiguous memory */
-+ contiguous = TRUE;
-+ /* Round size to reserve */
-+ reserve_size = CEIL (to_reserve, g_my_regionsize);
-+ /* Start with the current region's top */
-+ memory_info.BaseAddress = g_last->top_reserved;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
-+ /* Assert postconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Query %p %d %s\n", memory_info.BaseAddress, memory_info.RegionSize,
-+ memory_info.State == MEM_FREE ? "FREE":
-+ (memory_info.State == MEM_RESERVE ? "RESERVED":
-+ (memory_info.State == MEM_COMMIT ? "COMMITTED": "?")));
-+#endif
-+ /* Region is free, well aligned and big enough: we are done */
-+ if (memory_info.State == MEM_FREE &&
-+ (unsigned) memory_info.BaseAddress % g_regionsize == 0 &&
-+ memory_info.RegionSize >= (unsigned) reserve_size) {
-+ found = TRUE;
-+ break;
-+ }
-+ /* From now on we can't get contiguous memory! */
-+ contiguous = FALSE;
-+ /* Recompute size to reserve */
-+ reserve_size = CEIL (allocate_size, g_my_regionsize);
-+ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ }
-+ /* Search failed? */
-+ if (! found)
-+ goto sbrk_exit;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_regionsize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ /* Try to reserve this */
-+ base_reserved = VirtualAlloc (memory_info.BaseAddress, reserve_size,
-+ MEM_RESERVE, PAGE_NOACCESS);
-+ if (! base_reserved) {
-+ int rc = GetLastError ();
-+ if (rc != ERROR_INVALID_ADDRESS)
-+ goto sbrk_exit;
-+ }
-+ /* A null pointer signals (hopefully) a race condition with another thread. */
-+ /* In this case, we try again. */
-+ } while (! base_reserved);
-+ /* Check returned pointer for consistency */
-+ if (memory_info.BaseAddress && base_reserved != memory_info.BaseAddress)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_reserved % g_regionsize == 0);
-+#ifdef TRACE
-+ printf ("Reserve %p %d\n", base_reserved, reserve_size);
-+#endif
-+ /* Did we get contiguous memory? */
-+ if (contiguous) {
-+ long start_size = (char *) g_last->top_committed - (char *) g_last->top_allocated;
-+ /* Adjust allocation size */
-+ allocate_size -= start_size;
-+ /* Adjust the regions allocation top */
-+ g_last->top_allocated = g_last->top_committed;
-+ /* Recompute the size to commit */
-+ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Round size to commit */
-+ commit_size = CEIL (to_commit, g_my_pagesize);
-+ }
-+ /* Append the new region to the list */
-+ if (! region_list_append (&g_last, base_reserved, reserve_size))
-+ goto sbrk_exit;
-+ /* Didn't we get contiguous memory? */
-+ if (! contiguous) {
-+ /* Recompute the size to commit */
-+ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Round size to commit */
-+ commit_size = CEIL (to_commit, g_my_pagesize);
-+ }
-+ }
-+ }
-+ /* Assert preconditions */
-+ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert (0 < commit_size && commit_size % g_pagesize == 0); {
-+ /* Commit this */
-+ void *base_committed = VirtualAlloc (g_last->top_committed, commit_size,
-+ MEM_COMMIT, PAGE_READWRITE);
-+ /* Check returned pointer for consistency */
-+ if (base_committed != g_last->top_committed)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", base_committed, commit_size);
-+#endif
-+ /* Adjust the regions commit top */
-+ g_last->top_committed = (char *) base_committed + commit_size;
-+ }
-+ }
-+ /* Adjust the regions allocation top */
-+ g_last->top_allocated = (char *) g_last->top_allocated + allocate_size;
-+ result = (char *) g_last->top_allocated - size;
-+ /* Deallocation requested? */
-+ } else if (size < 0) {
-+ long deallocate_size = - size;
-+ /* As long as we have a region to release */
-+ while ((char *) g_last->top_allocated - deallocate_size < (char *) g_last->top_reserved - g_last->reserve_size) {
-+ /* Get the size to release */
-+ long release_size = g_last->reserve_size;
-+ /* Get the base address */
-+ void *base_reserved = (char *) g_last->top_reserved - release_size;
-+ /* Assert preconditions */
-+ assert ((unsigned) base_reserved % g_regionsize == 0);
-+ assert (0 < release_size && release_size % g_regionsize == 0); {
-+ /* Release this */
-+ int rc = VirtualFree (base_reserved, 0,
-+ MEM_RELEASE);
-+ /* Check returned code for consistency */
-+ if (! rc)
-+ goto sbrk_exit;
-+#ifdef TRACE
-+ printf ("Release %p %d\n", base_reserved, release_size);
-+#endif
-+ }
-+ /* Adjust deallocation size */
-+ deallocate_size -= (char *) g_last->top_allocated - (char *) base_reserved;
-+ /* Remove the old region from the list */
-+ if (! region_list_remove (&g_last))
-+ goto sbrk_exit;
-+ } {
-+ /* Compute the size to decommit */
-+ long to_decommit = (char *) g_last->top_committed - ((char *) g_last->top_allocated - deallocate_size);
-+ if (to_decommit >= g_my_pagesize) {
-+ /* Compute the size to decommit */
-+ long decommit_size = FLOOR (to_decommit, g_my_pagesize);
-+ /* Compute the base address */
-+ void *base_committed = (char *) g_last->top_committed - decommit_size;
-+ /* Assert preconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+ assert (0 < decommit_size && decommit_size % g_pagesize == 0); {
-+ /* Decommit this */
-+ int rc = VirtualFree ((char *) base_committed, decommit_size,
-+ MEM_DECOMMIT);
-+ /* Check returned code for consistency */
-+ if (! rc)
-+ goto sbrk_exit;
-+#ifdef TRACE
-+ printf ("Decommit %p %d\n", base_committed, decommit_size);
-+#endif
-+ }
-+ /* Adjust deallocation size and regions commit and allocate top */
-+ deallocate_size -= (char *) g_last->top_allocated - (char *) base_committed;
-+ g_last->top_committed = base_committed;
-+ g_last->top_allocated = base_committed;
-+ }
-+ }
-+ /* Adjust regions allocate top */
-+ g_last->top_allocated = (char *) g_last->top_allocated - deallocate_size;
-+ /* Check for underflow */
-+ if ((char *) g_last->top_reserved - g_last->reserve_size > (char *) g_last->top_allocated ||
-+ g_last->top_allocated > g_last->top_committed) {
-+ /* Adjust regions allocate top */
-+ g_last->top_allocated = (char *) g_last->top_reserved - g_last->reserve_size;
-+ goto sbrk_exit;
-+ }
-+ result = g_last->top_allocated;
-+ }
-+ /* Assert invariants */
-+ assert (g_last);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
-+ g_last->top_allocated <= g_last->top_committed);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
-+ g_last->top_committed <= g_last->top_reserved &&
-+ (unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
-+ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
-+
-+sbrk_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return result;
-+}
-+
-+/* mmap for windows */
-+static void *mmap (void *ptr, long size, long prot, long type, long handle, long arg) {
-+ static long g_pagesize;
-+ static long g_regionsize;
-+#ifdef TRACE
-+ printf ("mmap %d\n", size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize)
-+ g_pagesize = getpagesize ();
-+ if (! g_regionsize)
-+ g_regionsize = getregionsize ();
-+ /* Assert preconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+ assert (size % g_pagesize == 0);
-+ /* Allocate this */
-+ ptr = VirtualAlloc (ptr, size,
-+ MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE);
-+ if (! ptr) {
-+ ptr = (void *) MORECORE_FAILURE;
-+ goto mmap_exit;
-+ }
-+ /* Assert postconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", ptr, size);
-+#endif
-+mmap_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return ptr;
-+}
-+
-+/* munmap for windows */
-+static long munmap (void *ptr, long size) {
-+ static long g_pagesize;
-+ static long g_regionsize;
-+ int rc = MUNMAP_FAILURE;
-+#ifdef TRACE
-+ printf ("munmap %p %d\n", ptr, size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize)
-+ g_pagesize = getpagesize ();
-+ if (! g_regionsize)
-+ g_regionsize = getregionsize ();
-+ /* Assert preconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+ assert (size % g_pagesize == 0);
-+ /* Free this */
-+ if (! VirtualFree (ptr, 0,
-+ MEM_RELEASE))
-+ goto munmap_exit;
-+ rc = 0;
-+#ifdef TRACE
-+ printf ("Release %p %d\n", ptr, size);
-+#endif
-+munmap_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return rc;
-+}
-+
-+static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed) {
-+ MEMORY_BASIC_INFORMATION memory_info;
-+ memory_info.BaseAddress = 0;
-+ *free = *reserved = *committed = 0;
-+ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
-+ switch (memory_info.State) {
-+ case MEM_FREE:
-+ *free += memory_info.RegionSize;
-+ break;
-+ case MEM_RESERVE:
-+ *reserved += memory_info.RegionSize;
-+ break;
-+ case MEM_COMMIT:
-+ *committed += memory_info.RegionSize;
-+ break;
-+ }
-+ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
-+ }
-+}
-+
-+static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user) {
-+ if (whole) {
-+ __int64 creation64, exit64, kernel64, user64;
-+ int rc = GetProcessTimes (GetCurrentProcess (),
-+ (FILETIME *) &creation64,
-+ (FILETIME *) &exit64,
-+ (FILETIME *) &kernel64,
-+ (FILETIME *) &user64);
-+ if (! rc) {
-+ *kernel = 0;
-+ *user = 0;
-+ return FALSE;
-+ }
-+ *kernel = (unsigned long) (kernel64 / 10000);
-+ *user = (unsigned long) (user64 / 10000);
-+ return TRUE;
-+ } else {
-+ __int64 creation64, exit64, kernel64, user64;
-+ int rc = GetThreadTimes (GetCurrentThread (),
-+ (FILETIME *) &creation64,
-+ (FILETIME *) &exit64,
-+ (FILETIME *) &kernel64,
-+ (FILETIME *) &user64);
-+ if (! rc) {
-+ *kernel = 0;
-+ *user = 0;
-+ return FALSE;
-+ }
-+ *kernel = (unsigned long) (kernel64 / 10000);
-+ *user = (unsigned long) (user64 / 10000);
-+ return TRUE;
-+ }
-+}
-+
-+#endif /* WIN32 */
-+
-+/* ------------------------------------------------------------
-+History:
-+
-+ V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
-+ * Introduce independent_comalloc and independent_calloc.
-+ Thanks to Michael Pachos for motivation and help.
-+ * Make optional .h file available
-+ * Allow > 2GB requests on 32bit systems.
-+ * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>.
-+ Thanks also to Andreas Mueller <a.mueller at paradatec.de>,
-+ and Anonymous.
-+ * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for
-+ helping test this.)
-+ * memalign: check alignment arg
-+ * realloc: don't try to shift chunks backwards, since this
-+ leads to more fragmentation in some programs and doesn't
-+ seem to help in any others.
-+ * Collect all cases in malloc requiring system memory into sYSMALLOc
-+ * Use mmap as backup to sbrk
-+ * Place all internal state in malloc_state
-+ * Introduce fastbins (although similar to 2.5.1)
-+ * Many minor tunings and cosmetic improvements
-+ * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK
-+ * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS
-+ Thanks to Tony E. Bennett <tbennett@nvidia.com> and others.
-+ * Include errno.h to support default failure action.
-+
-+ V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee)
-+ * return null for negative arguments
-+ * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com>
-+ * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h'
-+ (e.g. WIN32 platforms)
-+ * Cleanup header file inclusion for WIN32 platforms
-+ * Cleanup code to avoid Microsoft Visual C++ compiler complaints
-+ * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing
-+ memory allocation routines
-+ * Set 'malloc_getpagesize' for WIN32 platforms (needs more work)
-+ * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to
-+ usage of 'assert' in non-WIN32 code
-+ * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to
-+ avoid infinite loop
-+ * Always call 'fREe()' rather than 'free()'
-+
-+ V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee)
-+ * Fixed ordering problem with boundary-stamping
-+
-+ V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
-+ * Added pvalloc, as recommended by H.J. Liu
-+ * Added 64bit pointer support mainly from Wolfram Gloger
-+ * Added anonymously donated WIN32 sbrk emulation
-+ * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
-+ * malloc_extend_top: fix mask error that caused wastage after
-+ foreign sbrks
-+ * Add linux mremap support code from HJ Liu
-+
-+ V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
-+ * Integrated most documentation with the code.
-+ * Add support for mmap, with help from
-+ Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
-+ * Use last_remainder in more cases.
-+ * Pack bins using idea from colin@nyx10.cs.du.edu
-+ * Use ordered bins instead of best-fit threshold
-+ * Eliminate block-local decls to simplify tracing and debugging.
-+ * Support another case of realloc via move into top
-+ * Fix error occurring when initial sbrk_base not word-aligned.
-+ * Rely on page size for units instead of SBRK_UNIT to
-+ avoid surprises about sbrk alignment conventions.
-+ * Add mallinfo, mallopt. Thanks to Raymond Nijssen
-+ (raymond@es.ele.tue.nl) for the suggestion.
-+ * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
-+ * More precautions for cases where other routines call sbrk,
-+ courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
-+ * Added macros etc., allowing use in linux libc from
-+ H.J. Lu (hjl@gnu.ai.mit.edu)
-+ * Inverted this history list
-+
-+ V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
-+ * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
-+ * Removed all preallocation code since under current scheme
-+ the work required to undo bad preallocations exceeds
-+ the work saved in good cases for most test programs.
-+ * No longer use return list or unconsolidated bins since
-+ no scheme using them consistently outperforms those that don't
-+ given above changes.
-+ * Use best fit for very large chunks to prevent some worst-cases.
-+ * Added some support for debugging
-+
-+ V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
-+ * Removed footers when chunks are in use. Thanks to
-+ Paul Wilson (wilson@cs.texas.edu) for the suggestion.
-+
-+ V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
-+ * Added malloc_trim, with help from Wolfram Gloger
-+ (wmglo@Dent.MED.Uni-Muenchen.DE).
-+
-+ V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
-+
-+ V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
-+ * realloc: try to expand in both directions
-+ * malloc: swap order of clean-bin strategy;
-+ * realloc: only conditionally expand backwards
-+ * Try not to scavenge used bins
-+ * Use bin counts as a guide to preallocation
-+ * Occasionally bin return list chunks in first scan
-+ * Add a few optimizations from colin@nyx10.cs.du.edu
-+
-+ V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
-+ * faster bin computation & slightly different binning
-+ * merged all consolidations to one part of malloc proper
-+ (eliminating old malloc_find_space & malloc_clean_bin)
-+ * Scan 2 returns chunks (not just 1)
-+ * Propagate failure in realloc if malloc returns 0
-+ * Add stuff to allow compilation on non-ANSI compilers
-+ from kpv@research.att.com
-+
-+ V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
-+ * removed potential for odd address access in prev_chunk
-+ * removed dependency on getpagesize.h
-+ * misc cosmetics and a bit more internal documentation
-+ * anticosmetics: mangled names in macros to evade debugger strangeness
-+ * tested on sparc, hp-700, dec-mips, rs6000
-+ with gcc & native cc (hp, dec only) allowing
-+ Detlefs & Zorn comparison study (in SIGPLAN Notices.)
-+
-+ Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
-+ * Based loosely on libg++-1.2X malloc. (It retains some of the overall
-+ structure of old version, but most details differ.)
-+
-+*/
-+
-+#ifdef USE_PUBLIC_MALLOC_WRAPPERS
-+
-+#ifndef KDE_MALLOC_FULL
-+
-+#ifdef KDE_MALLOC_GLIBC
-+#include "glibc.h"
-+#else
-+/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/
-+#error Unknown libc
-+#endif
-+
-+/* 0 - uninitialized
-+ 1 - this malloc
-+ 2 - standard libc malloc*/
-+extern char* getenv(const char*);
-+static int malloc_type = 0;
-+static void init_malloc_type(void)
-+ {
-+ const char* const env = getenv( "KDE_MALLOC" );
-+ if( env == NULL )
-+ malloc_type = 1;
-+ else if( env[ 0 ] == '0' || env[ 0 ] == 'n' || env[ 0 ] == 'N' )
-+ malloc_type = 2;
-+ else
-+ malloc_type = 1;
-+ }
-+
-+#endif
-+
-+Void_t* public_mALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_malloc( bytes );
-+ init_malloc_type();
-+ return public_mALLOc( bytes );
-+#endif
-+}
-+
-+void public_fREe(Void_t* m) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ fREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+#ifndef KDE_MALLOC_FULL
-+ return;
-+ }
-+ if( malloc_type == 2 )
-+ {
-+ libc_free( m );
-+ return;
-+ }
-+ init_malloc_type();
-+ public_fREe( m );
-+#endif
-+}
-+
-+Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = rEALLOc(m, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_realloc( m, bytes );
-+ init_malloc_type();
-+ return public_rEALLOc( m, bytes );
-+#endif
-+}
-+
-+Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mEMALIGn(alignment, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_memalign( alignment, bytes );
-+ init_malloc_type();
-+ return public_mEMALIGn( alignment, bytes );
-+#endif
-+}
-+
-+Void_t* public_vALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = vALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_valloc( bytes );
-+ init_malloc_type();
-+ return public_vALLOc( bytes );
-+#endif
-+}
-+
-+Void_t* public_pVALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = pVALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_pvalloc( bytes );
-+ init_malloc_type();
-+ return public_pVALLOc( bytes );
-+#endif
-+}
-+
-+Void_t* public_cALLOc(size_t n, size_t elem_size) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = cALLOc(n, elem_size);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_calloc( n, elem_size );
-+ init_malloc_type();
-+ return public_cALLOc( n, elem_size );
-+#endif
-+}
-+
-+void public_cFREe(Void_t* m) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ cFREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+#ifndef KDE_MALLOC_FULL
-+ return;
-+ }
-+ if( malloc_type == 2 )
-+ {
-+ libc_cfree( m );
-+ return;
-+ }
-+ init_malloc_type();
-+ public_cFREe( m );
-+#endif
-+}
-+
-+struct mallinfo public_mALLINFo() {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ struct mallinfo m;
-+ if (MALLOC_PREACTION != 0) {
-+ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-+ return nm;
-+ }
-+ m = mALLINFo();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_mallinfo();
-+ init_malloc_type();
-+ return public_mALLINFo();
-+#endif
-+}
-+
-+int public_mALLOPt(int p, int v) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mALLOPt(p, v);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_mallopt( p, v );
-+ init_malloc_type();
-+ return public_mALLOPt( p, v );
-+#endif
-+}
-+#endif
-+
-+int
-+posix_memalign (void **memptr, size_t alignment, size_t size)
-+{
-+ void *mem;
-+
-+ /* Test whether the SIZE argument is valid. It must be a power of
-+ two multiple of sizeof (void *). */
-+ if (size % sizeof (void *) != 0 || (size & (size - 1)) != 0)
-+ return EINVAL;
-+
-+ mem = memalign (alignment, size);
-+
-+ if (mem != NULL) {
-+ *memptr = mem;
-+ return 0;
-+ }
-+
-+ return ENOMEM;
-+}
-+
-+#else
-+/* Some linkers (Solaris 2.6) don't like empty archives, but for
-+ easier Makefile's we want to link against libklmalloc.la every time,
-+ so simply make it non-empty. */
-+void kde_malloc_dummy_function ()
-+{
-+ return;
-+}
-+#endif
-diff -Nupr a/src/corelib/arch/avr32/qatomic.cpp b/src/corelib/arch/avr32/qatomic.cpp
---- a/src/corelib/arch/avr32/qatomic.cpp 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/qatomic.cpp 2006-07-26 11:02:43.000000000 +0200
-@@ -0,0 +1,24 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#include "QtCore/qatomic_avr32.h"
-+
-+Q_CORE_EXPORT long q_atomic_lock = 0;
-diff -Nupr a/src/corelib/arch/qatomic_arch.h b/src/corelib/arch/qatomic_arch.h
---- a/src/corelib/arch/qatomic_arch.h 2006-06-30 09:49:44.000000000 +0200
-+++ b/src/corelib/arch/qatomic_arch.h 2006-07-27 12:42:58.000000000 +0200
-@@ -47,6 +47,8 @@ QT_BEGIN_HEADER
- # include "QtCore/qatomic_alpha.h"
- #elif defined(QT_ARCH_ARM)
- # include "QtCore/qatomic_arm.h"
-+#elif defined(QT_ARCH_AVR32)
-+# include "QtCore/qatomic_avr32.h"
- #elif defined(QT_ARCH_BOUNDSCHECKER)
- # include "QtCore/qatomic_boundschecker.h"
- #elif defined(QT_ARCH_GENERIC)
-diff -Nupr a/src/corelib/arch/qatomic_avr32.h b/src/corelib/arch/qatomic_avr32.h
---- a/src/corelib/arch/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/qatomic_avr32.h 2006-07-28 10:30:08.000000000 +0200
-@@ -0,0 +1,132 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#ifndef AVR32_QATOMIC_H
-+#define AVR32_QATOMIC_H
-+
-+#include <QtCore/qglobal.h>
-+
-+QT_BEGIN_HEADER
-+
-+extern Q_CORE_EXPORT long q_atomic_lock;
-+
-+inline long q_atomic_swp(volatile long *ptr, long newval)
-+{
-+ register int ret;
-+ asm volatile("xchg %0,%1,%2"
-+ : "=&r"(ret)
-+ : "r"(ptr), "r"(newval)
-+ : "memory", "cc");
-+ return ret;
-+}
-+
-+inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
-+{
-+ int ret = 0;
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0);
-+ if (*ptr == expected) {
-+ *ptr = newval;
-+ ret = 1;
-+ }
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return ret;
-+}
-+
-+inline int q_atomic_test_and_set_acquire_int(volatile int *ptr, int expected, int newval)
-+{
-+ return q_atomic_test_and_set_int(ptr, expected, newval);
-+}
-+
-+inline int q_atomic_test_and_set_release_int(volatile int *ptr, int expected, int newval)
-+{
-+ return q_atomic_test_and_set_int(ptr, expected, newval);
-+}
-+
-+inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
-+{
-+ int ret = 0;
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ if (*reinterpret_cast<void * volatile *>(ptr) == expected) {
-+ *reinterpret_cast<void * volatile *>(ptr) = newval;
-+ ret = 1;
-+ }
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return ret;
-+}
-+
-+inline int q_atomic_increment(volatile int *ptr)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = originalValue + 1;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue != -1;
-+}
-+
-+inline int q_atomic_decrement(volatile int *ptr)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = originalValue - 1;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue != 1;
-+}
-+
-+inline int q_atomic_set_int(volatile int *ptr, int newval)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = newval;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue;
-+}
-+
-+inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ void *originalValue = *reinterpret_cast<void * volatile *>(ptr);
-+ *reinterpret_cast<void * volatile *>(ptr) = newval;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue;
-+}
-+
-+inline int q_atomic_fetch_and_add_int(volatile int *ptr, int value)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr += value;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue;
-+}
-+
-+inline int q_atomic_fetch_and_add_acquire_int(volatile int *ptr, int value)
-+{
-+ return q_atomic_fetch_and_add_int(ptr, value);
-+}
-+
-+inline int q_atomic_fetch_and_add_release_int(volatile int *ptr, int value)
-+{
-+ return q_atomic_fetch_and_add_int(ptr, value);
-+}
-+
-+QT_END_HEADER
-+
-+#endif // AVR32_QATOMIC_H
-diff -Nupr a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
---- a/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-06-30 09:49:45.000000000 +0200
-+++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-07-27 13:24:27.000000000 +0200
-@@ -87,6 +87,10 @@
- # define __NR_inotify_init 316
- # define __NR_inotify_add_watch 317
- # define __NR_inotify_rm_watch 318
-+#elif defined (__avr32__)
-+# define __NR_inotify_init 240
-+# define __NR_inotify_add_watch 241
-+# define __NR_inotify_rm_watch 242
- #elif defined (__SH4__)
- # define __NR_inotify_init 290
- # define __NR_inotify_add_watch 291
-diff -uprN a/mkspecs/qws/linux-avr32-g++/qmake.conf b/mkspecs/qws/linux-avr32-g++/qmake.conf
---- a/mkspecs/qws/linux-avr32-g++/qmake.conf 1970-01-01 01:00:00.000000000 +0100
-+++ b/mkspecs/qws/linux-avr32-g++/qmake.conf 2006-08-01 08:47:12.000000000 +0200
-@@ -0,0 +1,85 @@
-+#
-+# qmake configuration for linux-g++ using the avr32-linux-g++ crosscompiler
-+#
-+
-+MAKEFILE_GENERATOR = UNIX
-+TEMPLATE = app
-+CONFIG += qt warn_on release link_prl
-+QT += core gui network
-+QMAKE_INCREMENTAL_STYLE = sublib
-+
-+QMAKE_CC = avr32-linux-gcc
-+QMAKE_LEX = flex
-+QMAKE_LEXFLAGS =
-+QMAKE_YACC = yacc
-+QMAKE_YACCFLAGS = -d
-+QMAKE_CFLAGS = -pipe
-+QMAKE_CFLAGS_WARN_ON = -Wall -W
-+QMAKE_CFLAGS_WARN_OFF =
-+QMAKE_CFLAGS_RELEASE = -O2
-+QMAKE_CFLAGS_DEBUG = -g -O2
-+QMAKE_CFLAGS_SHLIB = -fPIC
-+QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
-+QMAKE_CFLAGS_THREAD = -D_REENTRANT
-+QMAKE_CFLAGS_HIDESYMS = -fvisibility=hidden
-+
-+QMAKE_CXX = avr32-linux-g++
-+QMAKE_CXXFLAGS = $$QMAKE_CFLAGS -fno-exceptions
-+QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
-+QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
-+QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
-+QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
-+QMAKE_CXXFLAGS_SHLIB = $$QMAKE_CFLAGS_SHLIB
-+QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
-+QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD
-+QMAKE_CXXFLAGS_HIDESYMS = $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden
-+
-+QMAKE_INCDIR =
-+QMAKE_LIBDIR =
-+QMAKE_INCDIR_X11 =
-+QMAKE_LIBDIR_X11 =
-+QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
-+QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
-+QMAKE_INCDIR_OPENGL =
-+QMAKE_LIBDIR_OPENGL =
-+QMAKE_INCDIR_QTOPIA = $(QPEDIR)/include
-+QMAKE_LIBDIR_QTOPIA = $(QPEDIR)/lib
-+
-+QMAKE_LINK = avr32-linux-g++
-+QMAKE_LINK_SHLIB = avr32-linux-g++
-+QMAKE_LFLAGS =
-+QMAKE_LFLAGS_RELEASE =
-+QMAKE_LFLAGS_DEBUG =
-+QMAKE_LFLAGS_SHLIB = -shared
-+QMAKE_LFLAGS_PLUGIN = $$QMAKE_LFLAGS_SHLIB
-+QMAKE_LFLAGS_SONAME = -Wl,-soname,
-+QMAKE_LFLAGS_THREAD =
-+QMAKE_RPATH = -Wl,-rpath,
-+
-+QMAKE_LIBS =
-+QMAKE_LIBS_DYNLOAD = -ldl
-+QMAKE_LIBS_X11 =
-+QMAKE_LIBS_X11SM =
-+QMAKE_LIBS_QT = -lqte
-+QMAKE_LIBS_QT_THREAD = -lqte-mt
-+QMAKE_LIBS_QT_OPENGL = -lqgl
-+QMAKE_LIBS_QTOPIA = -lqpe -lqtopia
-+QMAKE_LIBS_THREAD = -lpthread
-+
-+QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
-+QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
-+
-+QMAKE_AR = avr32-linux-ar cqs
-+QMAKE_RANLIB = avr32-linux-ranlib
-+
-+QMAKE_TAR = tar -cf
-+QMAKE_GZIP = gzip -9f
-+
-+QMAKE_COPY = cp -f
-+QMAKE_MOVE = mv -f
-+QMAKE_DEL_FILE = rm -f
-+QMAKE_DEL_DIR = rmdir
-+QMAKE_STRIP = avr32-linux-strip
-+QMAKE_CHK_DIR_EXISTS = test -d
-+QMAKE_MKDIR = mkdir -p
-+load(qt_config)
-diff -uprN a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h
---- a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 2006-07-26 09:16:52.000000000 +0200
-@@ -0,0 +1,22 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the qmake spec of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#include "../../linux-g++/qplatformdefs.h"
---- a/include/QtCore/headers.pri 2007-08-02 15:03:31.000000000 +0200
-+++ b/include/QtCore/headers.pri 2007-08-02 15:03:44.000000000 +0200
-@@ -1,2 +1,2 @@
--SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
-+SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_avr32.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
- SYNCQT.HEADER_CLASSES = ../../include/QtCore/QDataStream ../../include/QtCore/QtDebug ../../include/QtCore/QDebug ../../include/QtCore/QNoDebug ../../include/QtCore/QTextStream ../../include/QtCore/QTextStreamFunction ../../include/QtCore/QTextStreamManipulator ../../include/QtCore/QTS ../../include/QtCore/QTextIStream ../../include/QtCore/QTextOStream ../../include/QtCore/QTemporaryFile ../../include/QtCore/QFSFileEngine ../../include/QtCore/QIODevice ../../include/QtCore/Q_PID ../../include/QtCore/QProcess ../../include/QtCore/QResource ../../include/QtCore/QDirIterator ../../include/QtCore/QBuffer ../../include/QtCore/QFileSystemWatcher ../../include/QtCore/QDir ../../include/QtCore/QUrl ../../include/QtCore/QAbstractFileEngine ../../include/QtCore/QAbstractFileEngineHandler ../../include/QtCore/QAbstractFileEngineIterator ../../include/QtCore/QFileInfo ../../include/QtCore/QFileInfoList ../../include/QtCore/QFileInfoListIterator ../../include/QtCore/QSettings ../../include/QtCore/QFile ../../include/QtCore/QBasicAtomic ../../include/QtCore/QBasicAtomicPointer ../../include/QtCore/QCache ../../include/QtCore/QLine ../../include/QtCore/QLineF ../../include/QtCore/QListData ../../include/QtCore/QList ../../include/QtCore/QListIterator ../../include/QtCore/QMutableListIterator ../../include/QtCore/QPair ../../include/QtCore/QPoint ../../include/QtCore/QPointF ../../include/QtCore/QRect ../../include/QtCore/QRectF ../../include/QtCore/QSize ../../include/QtCore/QSizeF ../../include/QtCore/QStringListIterator ../../include/QtCore/QMutableStringListIterator ../../include/QtCore/QStringList ../../include/QtCore/QStringMatcher ../../include/QtCore/QLinkedListData ../../include/QtCore/QLinkedListNode ../../include/QtCore/QLinkedList ../../include/QtCore/QLinkedListIterator ../../include/QtCore/QMutableLinkedListIterator ../../include/QtCore/QBitArray ../../include/QtCore/QBitRef ../../include/QtCore/QVectorData ../../include/QtCore/QVectorTypedData ../../include/QtCore/QVector ../../include/QtCore/QVectorIterator ../../include/QtCore/QMutableVectorIterator ../../include/QtCore/QByteArrayMatcher ../../include/QtCore/QQueue ../../include/QtCore/QByteArray ../../include/QtCore/QByteRef ../../include/QtCore/QtAlgorithms ../../include/QtCore/QVarLengthArray ../../include/QtCore/QSharedData ../../include/QtCore/QSharedDataPointer ../../include/QtCore/QExplicitlySharedDataPointer ../../include/QtCore/QCryptographicHash ../../include/QtCore/QLocale ../../include/QtCore/QSystemLocale ../../include/QtCore/QStack ../../include/QtCore/QMapData ../../include/QtCore/QMap ../../include/QtCore/QMultiMap ../../include/QtCore/QMapIterator ../../include/QtCore/QMutableMapIterator ../../include/QtCore/QSet ../../include/QtCore/QSetIterator ../../include/QtCore/QMutableSetIterator ../../include/QtCore/QDate ../../include/QtCore/QTime ../../include/QtCore/QDateTime ../../include/QtCore/QStdWString ../../include/QtCore/QString ../../include/QtCore/QLatin1String ../../include/QtCore/QCharRef ../../include/QtCore/QConstString ../../include/QtCore/QStringRef ../../include/QtCore/QtContainerFwd ../../include/QtCore/QRegExp ../../include/QtCore/QLatin1Char ../../include/QtCore/QChar ../../include/QtCore/QHashData ../../include/QtCore/QHashDummyValue ../../include/QtCore/QHashDummyNode ../../include/QtCore/QHashNode ../../include/QtCore/QHash ../../include/QtCore/QMultiHash ../../include/QtCore/QHashIterator ../../include/QtCore/QMutableHashIterator ../../include/QtCore/QTimeLine ../../include/QtCore/QTextCodecFactoryInterface ../../include/QtCore/QTextCodecPlugin ../../include/QtCore/QTextCodec ../../include/QtCore/QTextEncoder ../../include/QtCore/QTextDecoder ../../include/QtCore/QLibraryInfo ../../include/QtCore/QtEndian ../../include/QtCore/QtGlobal ../../include/QtCore/QUintForSize ../../include/QtCore/QUintForType ../../include/QtCore/QIntForSize ../../include/QtCore/QIntForType ../../include/QtCore/QNoImplicitBoolCast ../../include/QtCore/Q_INT8 ../../include/QtCore/Q_UINT8 ../../include/QtCore/Q_INT16 ../../include/QtCore/Q_UINT16 ../../include/QtCore/Q_INT32 ../../include/QtCore/Q_UINT32 ../../include/QtCore/Q_INT64 ../../include/QtCore/Q_UINT64 ../../include/QtCore/Q_LLONG ../../include/QtCore/Q_ULLONG ../../include/QtCore/Q_LONG ../../include/QtCore/Q_ULONG ../../include/QtCore/QSysInfo ../../include/QtCore/QtMsgHandler ../../include/QtCore/QGlobalStatic ../../include/QtCore/QGlobalStaticDeleter ../../include/QtCore/QBool ../../include/QtCore/QTypeInfo ../../include/QtCore/QFlag ../../include/QtCore/QFlags ../../include/QtCore/QForeachContainer ../../include/QtCore/QForeachContainerBase ../../include/QtCore/Qt ../../include/QtCore/QInternal ../../include/QtCore/QCOORD ../../include/QtCore/QTranslator ../../include/QtCore/QVariant ../../include/QtCore/QVariantList ../../include/QtCore/QVariantMap ../../include/QtCore/QVariantComparisonHelper ../../include/QtCore/QMimeData ../../include/QtCore/QEventLoop ../../include/QtCore/QCoreApplication ../../include/QtCore/QtCleanUpFunction ../../include/QtCore/QModelIndex ../../include/QtCore/QPersistentModelIndex ../../include/QtCore/QModelIndexList ../../include/QtCore/QAbstractItemModel ../../include/QtCore/QAbstractTableModel ../../include/QtCore/QAbstractListModel ../../include/QtCore/QSignalMapper ../../include/QtCore/QObjectCleanupHandler ../../include/QtCore/QBasicTimer ../../include/QtCore/QSocketNotifier ../../include/QtCore/QObjectList ../../include/QtCore/QObjectData ../../include/QtCore/QObject ../../include/QtCore/QObjectUserData ../../include/QtCore/QTimer ../../include/QtCore/QMetaType ../../include/QtCore/QMetaTypeId ../../include/QtCore/QMetaTypeId2 ../../include/QtCore/QAbstractEventDispatcher ../../include/QtCore/QPointer ../../include/QtCore/QMetaMethod ../../include/QtCore/QMetaEnum ../../include/QtCore/QMetaProperty ../../include/QtCore/QMetaClassInfo ../../include/QtCore/QEvent ../../include/QtCore/QTimerEvent ../../include/QtCore/QChildEvent ../../include/QtCore/QCustomEvent ../../include/QtCore/QDynamicPropertyChangeEvent ../../include/QtCore/QGenericArgument ../../include/QtCore/QGenericReturnArgument ../../include/QtCore/QArgument ../../include/QtCore/QReturnArgument ../../include/QtCore/QMetaObject ../../include/QtCore/QPluginLoader ../../include/QtCore/QUuid ../../include/QtCore/QLibrary ../../include/QtCore/QtPlugin ../../include/QtCore/QtPluginInstanceFunction ../../include/QtCore/QFactoryInterface ../../include/QtCore/QSemaphore ../../include/QtCore/QThreadStorageData ../../include/QtCore/QThreadStorage ../../include/QtCore/QWaitCondition ../../include/QtCore/QThread ../../include/QtCore/QMutex ../../include/QtCore/QMutexLocker ../../include/QtCore/QReadWriteLock ../../include/QtCore/QReadLocker ../../include/QtCore/QWriteLocker ../../include/QtCore/QAtomic ../../include/QtCore/QAtomicPointer
--- /dev/null
+diff -Nupr a/include/Qt/qatomic_avr32.h b/include/Qt/qatomic_avr32.h
+--- a/include/Qt/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/include/Qt/qatomic_avr32.h 2006-07-27 07:55:09.000000000 +0200
+@@ -0,0 +1 @@
++#include "../../src/corelib/arch/qatomic_avr32.h"
+diff -Nupr a/include/QtCore/qatomic_avr32.h b/include/QtCore/qatomic_avr32.h
+--- a/include/QtCore/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/include/QtCore/qatomic_avr32.h 2006-07-27 07:55:28.000000000 +0200
+@@ -0,0 +1 @@
++#include "../../src/corelib/arch/qatomic_avr32.h"
+diff -Nupr a/src/corelib/arch/arch.pri b/src/corelib/arch/arch.pri
+--- a/src/corelib/arch/arch.pri 2006-06-30 09:49:44.000000000 +0200
++++ b/src/corelib/arch/arch.pri 2006-07-26 11:03:43.000000000 +0200
+@@ -13,6 +13,7 @@ mac:HEADERS += arch/qatomic_macosx.h \
+ arch/qatomic_generic.h \
+ arch/qatomic_powerpc.h \
+ arch/qatomic_arm.h \
++ arch/qatomic_avr32.h \
+ arch/qatomic_i386.h \
+ arch/qatomic_mips.h \
+ arch/qatomic_s390.h \
+diff -Nupr a/src/corelib/arch/avr32/arch.pri b/src/corelib/arch/avr32/arch.pri
+--- a/src/corelib/arch/avr32/arch.pri 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/arch.pri 2006-07-26 11:02:16.000000000 +0200
+@@ -0,0 +1,5 @@
++#
++# AVR32 architecture
++#
++SOURCES += $$QT_ARCH_CPP/qatomic.cpp \
++ $$QT_ARCH_CPP/malloc.c
+diff -Nupr a/src/corelib/arch/avr32/malloc.c b/src/corelib/arch/avr32/malloc.c
+--- a/src/corelib/arch/avr32/malloc.c 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/malloc.c 2006-07-28 10:29:44.000000000 +0200
+@@ -0,0 +1,5819 @@
++/****************************************************************************
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** This file contains third party code which is not governed by the Qt
++** Commercial License Agreement. Please read the license headers below
++** for more information.
++**
++** Further information about Qt licensing is available at:
++** http://www.trolltech.com/products/qt/licensing.html or by
++** contacting info@trolltech.com.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++/* ---- config.h */
++#define KDE_MALLOC
++#define KDE_MALLOC_FULL
++#define KDE_MALLOC_AVR32
++/* ---- */
++
++#ifdef KDE_MALLOC
++
++#ifdef KDE_MALLOC_DEBUG
++#define DEBUG
++#endif
++
++#define USE_MALLOC_LOCK
++#define INLINE __inline__
++/*#define INLINE*/
++#define USE_MEMCPY 0
++#define MMAP_CLEARS 1
++
++/*
++ This is a version (aka dlmalloc) of malloc/free/realloc written by
++ Doug Lea and released to the public domain. Use, modify, and
++ redistribute this code without permission or acknowledgment in any
++ way you wish. Send questions, comments, complaints, performance
++ data, etc to dl@cs.oswego.edu
++
++* VERSION 2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
++
++ Note: There may be an updated version of this malloc obtainable at
++ ftp://gee.cs.oswego.edu/pub/misc/malloc.c
++ Check before installing!
++
++* Quickstart
++
++ This library is all in one file to simplify the most common usage:
++ ftp it, compile it (-O), and link it into another program. All
++ of the compile-time options default to reasonable values for use on
++ most unix platforms. Compile -DWIN32 for reasonable defaults on windows.
++ You might later want to step through various compile-time and dynamic
++ tuning options.
++
++ For convenience, an include file for code using this malloc is at:
++ ftp://gee.cs.oswego.edu/pub/misc/malloc-2.7.0.h
++ You don't really need this .h file unless you call functions not
++ defined in your system include files. The .h file contains only the
++ excerpts from this file needed for using this malloc on ANSI C/C++
++ systems, so long as you haven't changed compile-time options about
++ naming and tuning parameters. If you do, then you can create your
++ own malloc.h that does include all settings by cutting at the point
++ indicated below.
++
++* Why use this malloc?
++
++ This is not the fastest, most space-conserving, most portable, or
++ most tunable malloc ever written. However it is among the fastest
++ while also being among the most space-conserving, portable and tunable.
++ Consistent balance across these factors results in a good general-purpose
++ allocator for malloc-intensive programs.
++
++ The main properties of the algorithms are:
++ * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
++ with ties normally decided via FIFO (i.e. least recently used).
++ * For small (<= 64 bytes by default) requests, it is a caching
++ allocator, that maintains pools of quickly recycled chunks.
++ * In between, and for combinations of large and small requests, it does
++ the best it can trying to meet both goals at once.
++ * For very large requests (>= 128KB by default), it relies on system
++ memory mapping facilities, if supported.
++
++ For a longer but slightly out of date high-level description, see
++ http://gee.cs.oswego.edu/dl/html/malloc.html
++
++ You may already by default be using a C library containing a malloc
++ that is based on some version of this malloc (for example in
++ linux). You might still want to use the one in this file in order to
++ customize settings or to avoid overheads associated with library
++ versions.
++
++* Contents, described in more detail in "description of public routines" below.
++
++ Standard (ANSI/SVID/...) functions:
++ malloc(size_t n);
++ calloc(size_t n_elements, size_t element_size);
++ free(Void_t* p);
++ realloc(Void_t* p, size_t n);
++ memalign(size_t alignment, size_t n);
++ valloc(size_t n);
++ mallinfo()
++ mallopt(int parameter_number, int parameter_value)
++
++ Additional functions:
++ independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);
++ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
++ pvalloc(size_t n);
++ cfree(Void_t* p);
++ malloc_trim(size_t pad);
++ malloc_usable_size(Void_t* p);
++ malloc_stats();
++
++* Vital statistics:
++
++ Supported pointer representation: 4 or 8 bytes
++ Supported size_t representation: 4 or 8 bytes
++ Note that size_t is allowed to be 4 bytes even if pointers are 8.
++ You can adjust this by defining INTERNAL_SIZE_T
++
++ Alignment: 2 * sizeof(size_t) (default)
++ (i.e., 8 byte alignment with 4byte size_t). This suffices for
++ nearly all current machines and C compilers. However, you can
++ define MALLOC_ALIGNMENT to be wider than this if necessary.
++
++ Minimum overhead per allocated chunk: 4 or 8 bytes
++ Each malloced chunk has a hidden word of overhead holding size
++ and status information.
++
++ Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
++ 8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
++
++ When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
++ ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
++ needed; 4 (8) for a trailing size field and 8 (16) bytes for
++ free list pointers. Thus, the minimum allocatable size is
++ 16/24/32 bytes.
++
++ Even a request for zero bytes (i.e., malloc(0)) returns a
++ pointer to something of the minimum allocatable size.
++
++ The maximum overhead wastage (i.e., number of extra bytes
++ allocated than were requested in malloc) is less than or equal
++ to the minimum size, except for requests >= mmap_threshold that
++ are serviced via mmap(), where the worst case wastage is 2 *
++ sizeof(size_t) bytes plus the remainder from a system page (the
++ minimal mmap unit); typically 4096 or 8192 bytes.
++
++ Maximum allocated size: 4-byte size_t: 2^32 minus about two pages
++ 8-byte size_t: 2^64 minus about two pages
++
++ It is assumed that (possibly signed) size_t values suffice to
++ represent chunk sizes. `Possibly signed' is due to the fact
++ that `size_t' may be defined on a system as either a signed or
++ an unsigned type. The ISO C standard says that it must be
++ unsigned, but a few systems are known not to adhere to this.
++ Additionally, even when size_t is unsigned, sbrk (which is by
++ default used to obtain memory from system) accepts signed
++ arguments, and may not be able to handle size_t-wide arguments
++ with negative sign bit. Generally, values that would
++ appear as negative after accounting for overhead and alignment
++ are supported only via mmap(), which does not have this
++ limitation.
++
++ Requests for sizes outside the allowed range will perform an optional
++ failure action and then return null. (Requests may also
++ also fail because a system is out of memory.)
++
++ Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined
++
++ When USE_MALLOC_LOCK is defined, wrappers are created to
++ surround every public call with either a pthread mutex or
++ a win32 spinlock (depending on WIN32). This is not
++ especially fast, and can be a major bottleneck.
++ It is designed only to provide minimal protection
++ in concurrent environments, and to provide a basis for
++ extensions. If you are using malloc in a concurrent program,
++ you would be far better off obtaining ptmalloc, which is
++ derived from a version of this malloc, and is well-tuned for
++ concurrent programs. (See http://www.malloc.de)
++
++ Compliance: I believe it is compliant with the 1997 Single Unix Specification
++ (See http://www.opennc.org). Also SVID/XPG, ANSI C, and probably
++ others as well.
++
++* Synopsis of compile-time options:
++
++ People have reported using previous versions of this malloc on all
++ versions of Unix, sometimes by tweaking some of the defines
++ below. It has been tested most extensively on Solaris and
++ Linux. It is also reported to work on WIN32 platforms.
++ People also report using it in stand-alone embedded systems.
++
++ The implementation is in straight, hand-tuned ANSI C. It is not
++ at all modular. (Sorry!) It uses a lot of macros. To be at all
++ usable, this code should be compiled using an optimizing compiler
++ (for example gcc -O3) that can simplify expressions and control
++ paths. (FAQ: some macros import variables as arguments rather than
++ declare locals because people reported that some debuggers
++ otherwise get confused.)
++
++ OPTION DEFAULT VALUE
++
++ Compilation Environment options:
++
++ __STD_C derived from C compiler defines
++ WIN32 NOT defined
++ HAVE_MEMCPY defined
++ USE_MEMCPY 1 if HAVE_MEMCPY is defined
++ HAVE_MMAP defined as 1
++ MMAP_CLEARS 1
++ HAVE_MREMAP 0 unless linux defined
++ malloc_getpagesize derived from system #includes, or 4096 if not
++ HAVE_USR_INCLUDE_MALLOC_H NOT defined
++ LACKS_UNISTD_H NOT defined unless WIN32
++ LACKS_SYS_PARAM_H NOT defined unless WIN32
++ LACKS_SYS_MMAN_H NOT defined unless WIN32
++
++ Changing default word sizes:
++
++ INTERNAL_SIZE_T size_t
++ MALLOC_ALIGNMENT 2 * sizeof(INTERNAL_SIZE_T)
++
++ Configuration and functionality options:
++
++ USE_DL_PREFIX NOT defined
++ USE_PUBLIC_MALLOC_WRAPPERS NOT defined
++ USE_MALLOC_LOCK NOT defined
++ DEBUG NOT defined
++ REALLOC_ZERO_BYTES_FREES NOT defined
++ MALLOC_FAILURE_ACTION errno = ENOMEM, if __STD_C defined, else no-op
++ TRIM_FASTBINS 0
++
++ Options for customizing MORECORE:
++
++ MORECORE sbrk
++ MORECORE_CONTIGUOUS 1
++ MORECORE_CANNOT_TRIM NOT defined
++ MMAP_AS_MORECORE_SIZE (1024 * 1024)
++
++ Tuning options that are also dynamically changeable via mallopt:
++
++ DEFAULT_MXFAST 64
++ DEFAULT_TRIM_THRESHOLD 128 * 1024
++ DEFAULT_TOP_PAD 0
++ DEFAULT_MMAP_THRESHOLD 128 * 1024
++ DEFAULT_MMAP_MAX 65536
++
++ There are several other #defined constants and macros that you
++ probably don't want to touch unless you are extending or adapting malloc.
++*/
++
++/*
++ WIN32 sets up defaults for MS environment and compilers.
++ Otherwise defaults are for unix.
++*/
++
++/* #define WIN32 */
++
++#ifdef WIN32
++
++#define WIN32_LEAN_AND_MEAN
++#include <windows.h>
++
++/* Win32 doesn't supply or need the following headers */
++#define LACKS_UNISTD_H
++#define LACKS_SYS_PARAM_H
++#define LACKS_SYS_MMAN_H
++
++/* Use the supplied emulation of sbrk */
++#define MORECORE sbrk
++#define MORECORE_CONTIGUOUS 1
++#define MORECORE_FAILURE ((void*)(-1))
++
++/* Use the supplied emulation of mmap and munmap */
++#define HAVE_MMAP 1
++#define MUNMAP_FAILURE (-1)
++#define MMAP_CLEARS 1
++
++/* These values don't really matter in windows mmap emulation */
++#define MAP_PRIVATE 1
++#define MAP_ANONYMOUS 2
++#define PROT_READ 1
++#define PROT_WRITE 2
++
++/* Emulation functions defined at the end of this file */
++
++/* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */
++#ifdef USE_MALLOC_LOCK
++static int slwait(int *sl);
++static int slrelease(int *sl);
++#endif
++
++static long getpagesize(void);
++static long getregionsize(void);
++static void *sbrk(long size);
++static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg);
++static long munmap(void *ptr, long size);
++
++static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed);
++static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user);
++
++#endif
++
++/*
++ __STD_C should be nonzero if using ANSI-standard C compiler, a C++
++ compiler, or a C compiler sufficiently close to ANSI to get away
++ with it.
++*/
++
++#ifndef __STD_C
++#if defined(__STDC__) || defined(_cplusplus)
++#define __STD_C 1
++#else
++#define __STD_C 0
++#endif
++#endif /*__STD_C*/
++
++
++/*
++ Void_t* is the pointer type that malloc should say it returns
++*/
++
++#ifndef Void_t
++#if (__STD_C || defined(WIN32))
++#define Void_t void
++#else
++#define Void_t char
++#endif
++#endif /*Void_t*/
++
++#if __STD_C
++#include <stddef.h> /* for size_t */
++#else
++#include <sys/types.h>
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */
++
++/* #define LACKS_UNISTD_H */
++
++#ifndef LACKS_UNISTD_H
++#include <unistd.h>
++#endif
++
++/* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */
++
++/* #define LACKS_SYS_PARAM_H */
++
++
++#include <stdio.h> /* needed for malloc_stats */
++#include <errno.h> /* needed for optional MALLOC_FAILURE_ACTION */
++
++
++/*
++ Debugging:
++
++ Because freed chunks may be overwritten with bookkeeping fields, this
++ malloc will often die when freed memory is overwritten by user
++ programs. This can be very effective (albeit in an annoying way)
++ in helping track down dangling pointers.
++
++ If you compile with -DDEBUG, a number of assertion checks are
++ enabled that will catch more memory errors. You probably won't be
++ able to make much sense of the actual assertion errors, but they
++ should help you locate incorrectly overwritten memory. The
++ checking is fairly extensive, and will slow down execution
++ noticeably. Calling malloc_stats or mallinfo with DEBUG set will
++ attempt to check every non-mmapped allocated and free chunk in the
++ course of computing the summmaries. (By nature, mmapped regions
++ cannot be checked very much automatically.)
++
++ Setting DEBUG may also be helpful if you are trying to modify
++ this code. The assertions in the check routines spell out in more
++ detail the assumptions and invariants underlying the algorithms.
++
++ Setting DEBUG does NOT provide an automated mechanism for checking
++ that all accesses to malloced memory stay within their
++ bounds. However, there are several add-ons and adaptations of this
++ or other mallocs available that do this.
++*/
++
++#ifdef DEBUG
++#include <assert.h>
++#else
++#define assert(x) ((void)0)
++#endif
++
++
++/*
++ INTERNAL_SIZE_T is the word-size used for internal bookkeeping
++ of chunk sizes.
++
++ The default version is the same as size_t.
++
++ While not strictly necessary, it is best to define this as an
++ unsigned type, even if size_t is a signed type. This may avoid some
++ artificial size limitations on some systems.
++
++ On a 64-bit machine, you may be able to reduce malloc overhead by
++ defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the
++ expense of not being able to handle more than 2^32 of malloced
++ space. If this limitation is acceptable, you are encouraged to set
++ this unless you are on a platform requiring 16byte alignments. In
++ this case the alignment requirements turn out to negate any
++ potential advantages of decreasing size_t word size.
++
++ Implementors: Beware of the possible combinations of:
++ - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,
++ and might be the same width as int or as long
++ - size_t might have different width and signedness as INTERNAL_SIZE_T
++ - int and long might be 32 or 64 bits, and might be the same width
++ To deal with this, most comparisons and difference computations
++ among INTERNAL_SIZE_Ts should cast them to unsigned long, being
++ aware of the fact that casting an unsigned int to a wider long does
++ not sign-extend. (This also makes checking for negative numbers
++ awkward.) Some of these casts result in harmless compiler warnings
++ on some systems.
++*/
++
++#ifndef INTERNAL_SIZE_T
++#define INTERNAL_SIZE_T size_t
++#endif
++
++/* The corresponding word size */
++#define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
++
++
++/*
++ MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
++ It must be a power of two at least 2 * SIZE_SZ, even on machines
++ for which smaller alignments would suffice. It may be defined as
++ larger than this though. Note however that code and data structures
++ are optimized for the case of 8-byte alignment.
++*/
++
++
++#ifndef MALLOC_ALIGNMENT
++#define MALLOC_ALIGNMENT (2 * SIZE_SZ)
++#endif
++
++/* The corresponding bit mask value */
++#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
++
++
++
++/*
++ REALLOC_ZERO_BYTES_FREES should be set if a call to
++ realloc with zero bytes should be the same as a call to free.
++ Some people think it should. Otherwise, since this malloc
++ returns a unique pointer for malloc(0), so does realloc(p, 0).
++*/
++
++/* #define REALLOC_ZERO_BYTES_FREES */
++
++/*
++ TRIM_FASTBINS controls whether free() of a very small chunk can
++ immediately lead to trimming. Setting to true (1) can reduce memory
++ footprint, but will almost always slow down programs that use a lot
++ of small chunks.
++
++ Define this only if you are willing to give up some speed to more
++ aggressively reduce system-level memory footprint when releasing
++ memory in programs that use many small chunks. You can get
++ essentially the same effect by setting MXFAST to 0, but this can
++ lead to even greater slowdowns in programs using many small chunks.
++ TRIM_FASTBINS is an in-between compile-time option, that disables
++ only those chunks bordering topmost memory from being placed in
++ fastbins.
++*/
++
++#ifndef TRIM_FASTBINS
++#define TRIM_FASTBINS 0
++#endif
++
++
++/*
++ USE_DL_PREFIX will prefix all public routines with the string 'dl'.
++ This is necessary when you only want to use this malloc in one part
++ of a program, using your regular system malloc elsewhere.
++*/
++
++/* #define USE_DL_PREFIX */
++
++
++/*
++ USE_MALLOC_LOCK causes wrapper functions to surround each
++ callable routine with pthread mutex lock/unlock.
++
++ USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined
++*/
++
++
++/* #define USE_MALLOC_LOCK */
++
++
++/*
++ If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is
++ actually a wrapper function that first calls MALLOC_PREACTION, then
++ calls the internal routine, and follows it with
++ MALLOC_POSTACTION. This is needed for locking, but you can also use
++ this, without USE_MALLOC_LOCK, for purposes of interception,
++ instrumentation, etc. It is a sad fact that using wrappers often
++ noticeably degrades performance of malloc-intensive programs.
++*/
++
++#ifdef USE_MALLOC_LOCK
++#define USE_PUBLIC_MALLOC_WRAPPERS
++#else
++/* #define USE_PUBLIC_MALLOC_WRAPPERS */
++#endif
++
++
++/*
++ Two-phase name translation.
++ All of the actual routines are given mangled names.
++ When wrappers are used, they become the public callable versions.
++ When DL_PREFIX is used, the callable names are prefixed.
++*/
++
++#ifndef USE_PUBLIC_MALLOC_WRAPPERS
++#define cALLOc public_cALLOc
++#define fREe public_fREe
++#define cFREe public_cFREe
++#define mALLOc public_mALLOc
++#define mEMALIGn public_mEMALIGn
++#define rEALLOc public_rEALLOc
++#define vALLOc public_vALLOc
++#define pVALLOc public_pVALLOc
++#define mALLINFo public_mALLINFo
++#define mALLOPt public_mALLOPt
++#define mTRIm public_mTRIm
++#define mSTATs public_mSTATs
++#define mUSABLe public_mUSABLe
++#define iCALLOc public_iCALLOc
++#define iCOMALLOc public_iCOMALLOc
++#endif
++
++#ifdef USE_DL_PREFIX
++#define public_cALLOc dlcalloc
++#define public_fREe dlfree
++#define public_cFREe dlcfree
++#define public_mALLOc dlmalloc
++#define public_mEMALIGn dlmemalign
++#define public_rEALLOc dlrealloc
++#define public_vALLOc dlvalloc
++#define public_pVALLOc dlpvalloc
++#define public_mALLINFo dlmallinfo
++#define public_mALLOPt dlmallopt
++#define public_mTRIm dlmalloc_trim
++#define public_mSTATs dlmalloc_stats
++#define public_mUSABLe dlmalloc_usable_size
++#define public_iCALLOc dlindependent_calloc
++#define public_iCOMALLOc dlindependent_comalloc
++#else /* USE_DL_PREFIX */
++#define public_cALLOc calloc
++#define public_fREe free
++#define public_cFREe cfree
++#define public_mALLOc malloc
++#define public_mEMALIGn memalign
++#define public_rEALLOc realloc
++#define public_vALLOc valloc
++#define public_pVALLOc pvalloc
++#define public_mALLINFo mallinfo
++#define public_mALLOPt mallopt
++#define public_mTRIm malloc_trim
++#define public_mSTATs malloc_stats
++#define public_mUSABLe malloc_usable_size
++#define public_iCALLOc independent_calloc
++#define public_iCOMALLOc independent_comalloc
++#endif /* USE_DL_PREFIX */
++
++
++/*
++ HAVE_MEMCPY should be defined if you are not otherwise using
++ ANSI STD C, but still have memcpy and memset in your C library
++ and want to use them in calloc and realloc. Otherwise simple
++ macro versions are defined below.
++
++ USE_MEMCPY should be defined as 1 if you actually want to
++ have memset and memcpy called. People report that the macro
++ versions are faster than libc versions on some systems.
++
++ Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks
++ (of <= 36 bytes) are manually unrolled in realloc and calloc.
++*/
++
++/* If it's available it's defined in config.h. */
++/* #define HAVE_MEMCPY */
++
++#ifndef USE_MEMCPY
++#ifdef HAVE_MEMCPY
++#define USE_MEMCPY 1
++#else
++#define USE_MEMCPY 0
++#endif
++#endif
++
++
++#if (__STD_C || defined(HAVE_MEMCPY))
++
++#ifdef WIN32
++/* On Win32 memset and memcpy are already declared in windows.h */
++#else
++#if __STD_C
++void* memset(void*, int, size_t);
++void* memcpy(void*, const void*, size_t);
++#else
++Void_t* memset();
++Void_t* memcpy();
++#endif
++#endif
++#endif
++
++/*
++ MALLOC_FAILURE_ACTION is the action to take before "return 0" when
++ malloc fails to be able to return memory, either because memory is
++ exhausted or because of illegal arguments.
++
++ By default, sets errno if running on STD_C platform, else does nothing.
++*/
++
++#ifndef MALLOC_FAILURE_ACTION
++#if __STD_C
++#define MALLOC_FAILURE_ACTION \
++ errno = ENOMEM;
++
++#else
++#define MALLOC_FAILURE_ACTION
++#endif
++#endif
++
++/*
++ MORECORE-related declarations. By default, rely on sbrk
++*/
++
++
++#ifdef LACKS_UNISTD_H
++#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
++#if __STD_C
++extern Void_t* sbrk(ptrdiff_t);
++#else
++extern Void_t* sbrk();
++#endif
++#endif
++#endif
++
++/*
++ MORECORE is the name of the routine to call to obtain more memory
++ from the system. See below for general guidance on writing
++ alternative MORECORE functions, as well as a version for WIN32 and a
++ sample version for pre-OSX macos.
++*/
++
++#ifndef MORECORE
++#define MORECORE sbrk
++#endif
++
++/*
++ MORECORE_FAILURE is the value returned upon failure of MORECORE
++ as well as mmap. Since it cannot be an otherwise valid memory address,
++ and must reflect values of standard sys calls, you probably ought not
++ try to redefine it.
++*/
++
++#ifndef MORECORE_FAILURE
++#define MORECORE_FAILURE (-1)
++#endif
++
++/*
++ If MORECORE_CONTIGUOUS is true, take advantage of fact that
++ consecutive calls to MORECORE with positive arguments always return
++ contiguous increasing addresses. This is true of unix sbrk. Even
++ if not defined, when regions happen to be contiguous, malloc will
++ permit allocations spanning regions obtained from different
++ calls. But defining this when applicable enables some stronger
++ consistency checks and space efficiencies.
++*/
++
++#ifndef MORECORE_CONTIGUOUS
++#define MORECORE_CONTIGUOUS 1
++#endif
++
++/*
++ Define MORECORE_CANNOT_TRIM if your version of MORECORE
++ cannot release space back to the system when given negative
++ arguments. This is generally necessary only if you are using
++ a hand-crafted MORECORE function that cannot handle negative arguments.
++*/
++
++/* #define MORECORE_CANNOT_TRIM */
++
++
++/*
++ Define HAVE_MMAP as true to optionally make malloc() use mmap() to
++ allocate very large blocks. These will be returned to the
++ operating system immediately after a free(). Also, if mmap
++ is available, it is used as a backup strategy in cases where
++ MORECORE fails to provide space from system.
++
++ This malloc is best tuned to work with mmap for large requests.
++ If you do not have mmap, operations involving very large chunks (1MB
++ or so) may be slower than you'd like.
++*/
++
++#ifndef HAVE_MMAP
++#define HAVE_MMAP 1
++#endif
++
++#if HAVE_MMAP
++/*
++ Standard unix mmap using /dev/zero clears memory so calloc doesn't
++ need to.
++*/
++
++#ifndef MMAP_CLEARS
++#define MMAP_CLEARS 1
++#endif
++
++#else /* no mmap */
++#ifndef MMAP_CLEARS
++#define MMAP_CLEARS 0
++#endif
++#endif
++
++
++/*
++ MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if
++ sbrk fails, and mmap is used as a backup (which is done only if
++ HAVE_MMAP). The value must be a multiple of page size. This
++ backup strategy generally applies only when systems have "holes" in
++ address space, so sbrk cannot perform contiguous expansion, but
++ there is still space available on system. On systems for which
++ this is known to be useful (i.e. most linux kernels), this occurs
++ only when programs allocate huge amounts of memory. Between this,
++ and the fact that mmap regions tend to be limited, the size should
++ be large, to avoid too many mmap calls and thus avoid running out
++ of kernel resources.
++*/
++
++#ifndef MMAP_AS_MORECORE_SIZE
++#define MMAP_AS_MORECORE_SIZE (1024 * 1024)
++#endif
++
++/*
++ Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
++ large blocks. This is currently only possible on Linux with
++ kernel versions newer than 1.3.77.
++*/
++
++#ifndef HAVE_MREMAP
++#if defined(linux) || defined(__linux__) || defined(__linux)
++#define HAVE_MREMAP 1
++#else
++#define HAVE_MREMAP 0
++#endif
++
++#endif /* HAVE_MMAP */
++
++
++/*
++ The system page size. To the extent possible, this malloc manages
++ memory from the system in page-size units. Note that this value is
++ cached during initialization into a field of malloc_state. So even
++ if malloc_getpagesize is a function, it is only called once.
++
++ The following mechanics for getpagesize were adapted from bsd/gnu
++ getpagesize.h. If none of the system-probes here apply, a value of
++ 4096 is used, which should be OK: If they don't apply, then using
++ the actual value probably doesn't impact performance.
++*/
++
++
++#ifndef malloc_getpagesize
++
++#ifndef LACKS_UNISTD_H
++# include <unistd.h>
++#endif
++
++# 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 */
++# define malloc_getpagesize getpagesize()
++# else
++# ifndef LACKS_SYS_PARAM_H
++# include <sys/param.h>
++# endif
++# ifdef EXEC_PAGESIZE
++# define malloc_getpagesize EXEC_PAGESIZE
++# else
++# ifdef NBPG
++# ifndef CLSIZE
++# define malloc_getpagesize NBPG
++# else
++# define malloc_getpagesize (NBPG * CLSIZE)
++# endif
++# else
++# ifdef NBPC
++# define malloc_getpagesize NBPC
++# else
++# ifdef PAGESIZE
++# define malloc_getpagesize PAGESIZE
++# else /* just guess */
++# define malloc_getpagesize (4096)
++# endif
++# endif
++# endif
++# endif
++# endif
++# endif
++# endif
++#endif
++
++/*
++ This version of malloc supports the standard SVID/XPG mallinfo
++ routine that returns a struct containing usage properties and
++ statistics. It should work on any SVID/XPG compliant system that has
++ a /usr/include/malloc.h defining struct mallinfo. (If you'd like to
++ install such a thing yourself, cut out the preliminary declarations
++ as described above and below and save them in a malloc.h file. But
++ there's no compelling reason to bother to do this.)
++
++ The main declaration needed is the mallinfo struct that is returned
++ (by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a
++ bunch of field that are not even meaningful in this version of
++ malloc. These fields are are instead filled by mallinfo() with
++ other numbers that might be of interest.
++
++ HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
++ /usr/include/malloc.h file that includes a declaration of struct
++ mallinfo. If so, it is included; else an SVID2/XPG2 compliant
++ version is declared below. These must be precisely the same for
++ mallinfo() to work. The original SVID version of this struct,
++ defined on most systems with mallinfo, declares all fields as
++ ints. But some others define as unsigned long. If your system
++ defines the fields using a type of different width than listed here,
++ you must #include your system version and #define
++ HAVE_USR_INCLUDE_MALLOC_H.
++*/
++
++/* #define HAVE_USR_INCLUDE_MALLOC_H */
++
++/*#ifdef HAVE_USR_INCLUDE_MALLOC_H*/
++#if 0
++#include "/usr/include/malloc.h"
++#else
++
++/* SVID2/XPG mallinfo structure */
++
++struct mallinfo {
++ int arena; /* non-mmapped space allocated from system */
++ int ordblks; /* number of free chunks */
++ int smblks; /* number of fastbin blocks */
++ int hblks; /* number of mmapped regions */
++ int hblkhd; /* space in mmapped regions */
++ int usmblks; /* maximum total allocated space */
++ int fsmblks; /* space available in freed fastbin blocks */
++ int uordblks; /* total allocated space */
++ int fordblks; /* total free space */
++ int keepcost; /* top-most, releasable (via malloc_trim) space */
++};
++
++/*
++ SVID/XPG defines four standard parameter numbers for mallopt,
++ normally defined in malloc.h. Only one of these (M_MXFAST) is used
++ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
++ so setting them has no effect. But this malloc also supports other
++ options in mallopt described below.
++*/
++#endif
++
++
++/* ---------- description of public routines ------------ */
++
++/*
++ malloc(size_t n)
++ Returns a pointer to a newly allocated chunk of at least n bytes, or null
++ if no space is available. Additionally, on failure, errno is
++ set to ENOMEM on ANSI C systems.
++
++ If n is zero, malloc returns a minumum-sized chunk. (The minimum
++ size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
++ systems.) On most systems, size_t is an unsigned type, so calls
++ with negative arguments 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.
++*/
++#if __STD_C
++Void_t* public_mALLOc(size_t);
++#else
++Void_t* public_mALLOc();
++#endif
++
++/*
++ free(Void_t* 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. It can have arbitrary (i.e., bad!)
++ effects if p has already been freed.
++
++ Unless disabled (using mallopt), freeing very large spaces will
++ when possible, automatically trigger operations that give
++ back unused memory to the system, thus reducing program footprint.
++*/
++#if __STD_C
++void public_fREe(Void_t*);
++#else
++void public_fREe();
++#endif
++
++/*
++ calloc(size_t n_elements, size_t element_size);
++ Returns a pointer to n_elements * element_size bytes, with all locations
++ set to zero.
++*/
++#if __STD_C
++Void_t* public_cALLOc(size_t, size_t);
++#else
++Void_t* public_cALLOc();
++#endif
++
++/*
++ realloc(Void_t* 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
++ if no space is available.
++
++ The returned pointer may or may not be the same as p. The algorithm
++ prefers extending p when possible, otherwise it employs the
++ equivalent of a malloc-copy-free sequence.
++
++ If p is null, realloc is equivalent to malloc.
++
++ If space is not available, realloc returns null, errno is set (if on
++ ANSI) and p is NOT freed.
++
++ if n is for fewer bytes than already held by p, the newly unused
++ space is lopped off and freed if possible. Unless the #define
++ REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of
++ zero (re)allocates a minimum-sized chunk.
++
++ Large chunks that were internally obtained via mmap will always
++ be reallocated using malloc-copy-free sequences unless
++ the system supports MREMAP (currently only linux).
++
++ The old unix realloc convention of allowing the last-free'd chunk
++ to be used as an argument to realloc is not supported.
++*/
++#if __STD_C
++Void_t* public_rEALLOc(Void_t*, size_t);
++#else
++Void_t* public_rEALLOc();
++#endif
++
++/*
++ 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.
++
++ The alignment argument should be a power of two. If the argument is
++ not a power of two, the nearest greater power is used.
++ 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.
++*/
++#if __STD_C
++Void_t* public_mEMALIGn(size_t, size_t);
++#else
++Void_t* public_mEMALIGn();
++#endif
++
++/*
++ 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.
++*/
++#if __STD_C
++Void_t* public_vALLOc(size_t);
++#else
++Void_t* public_vALLOc();
++#endif
++
++
++
++/*
++ 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
++ corresponding parameter to the argument value if it can (i.e., so
++ long as the value is meaningful), and returns 1 if successful else
++ 0. SVID/XPG/ANSI defines four standard param numbers for mallopt,
++ normally defined in malloc.h. Only one of these (M_MXFAST) is used
++ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
++ so setting them has no effect. But this malloc also supports four
++ other options in mallopt. See below for details. Briefly, supported
++ parameters are as follows (listed defaults are for "typical"
++ configurations).
++
++ Symbol param # default allowed param values
++ M_MXFAST 1 64 0-80 (0 disables fastbins)
++ M_TRIM_THRESHOLD -1 128*1024 any (-1U disables trimming)
++ M_TOP_PAD -2 0 any
++ M_MMAP_THRESHOLD -3 128*1024 any (or 0 if no MMAP support)
++ M_MMAP_MAX -4 65536 any (0 disables use of mmap)
++*/
++#if __STD_C
++int public_mALLOPt(int, int);
++#else
++int public_mALLOPt();
++#endif
++
++
++/*
++ mallinfo()
++ Returns (by copy) a struct containing various summary statistics:
++
++ arena: current total non-mmapped bytes allocated from system
++ ordblks: the number of free chunks
++ smblks: the number of fastbin blocks (i.e., small chunks that
++ have been freed but not use resused or consolidated)
++ hblks: current number of mmapped regions
++ hblkhd: total bytes held in mmapped regions
++ usmblks: the maximum total allocated space. This will be greater
++ than current total if trimming has occurred.
++ fsmblks: total bytes held in fastbin blocks
++ uordblks: current total allocated space (normal or mmapped)
++ fordblks: total free space
++ keepcost: the maximum number of bytes that could ideally be released
++ back to system via malloc_trim. ("ideally" means that
++ it ignores page restrictions etc.)
++
++ Because these fields are ints, but internal bookkeeping may
++ be kept as longs, the reported values may wrap around zero and
++ thus be inaccurate.
++*/
++#if __STD_C
++struct mallinfo public_mALLINFo(void);
++#else
++struct mallinfo public_mALLINFo();
++#endif
++
++/*
++ independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
++
++ independent_calloc is similar to calloc, but instead of returning a
++ single cleared space, it returns an array of pointers to n_elements
++ independent elements that can hold contents of size elem_size, each
++ of which starts out cleared, and can be independently freed,
++ realloc'ed etc. The elements are guaranteed to be adjacently
++ allocated (this is not guaranteed to occur with multiple callocs or
++ mallocs), which may also improve cache locality in some
++ applications.
++
++ The "chunks" argument is optional (i.e., may be null, which is
++ probably the most typical usage). If it is null, the returned array
++ is itself dynamically allocated and should also be freed when it is
++ no longer needed. Otherwise, the chunks array must be of at least
++ n_elements in length. It is filled in with the pointers to the
++ chunks.
++
++ In either case, independent_calloc returns this pointer array, or
++ null if the allocation failed. If n_elements is zero and "chunks"
++ is null, it returns a chunk representing an array with zero elements
++ (which should be freed if not wanted).
++
++ Each element must be individually freed when it is no longer
++ needed. If you'd like to instead be able to free all at once, you
++ should instead use regular calloc and assign pointers into this
++ space to represent elements. (In this case though, you cannot
++ independently free elements.)
++
++ independent_calloc simplifies and speeds up implementations of many
++ kinds of pools. It may also be useful when constructing large data
++ structures that initially have a fixed number of fixed-sized nodes,
++ but the number is not known at compile time, and some of the nodes
++ may later need to be freed. For example:
++
++ struct Node { int item; struct Node* next; };
++
++ struct Node* build_list() {
++ struct Node** pool;
++ int n = read_number_of_nodes_needed();
++ if (n <= 0) return 0;
++ pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
++ if (pool == 0) die();
++ // organize into a linked list...
++ struct Node* first = pool[0];
++ for (i = 0; i < n-1; ++i)
++ pool[i]->next = pool[i+1];
++ free(pool); // Can now free the array (or not, if it is needed later)
++ return first;
++ }
++*/
++#if __STD_C
++Void_t** public_iCALLOc(size_t, size_t, Void_t**);
++#else
++Void_t** public_iCALLOc();
++#endif
++
++/*
++ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
++
++ independent_comalloc allocates, all at once, a set of n_elements
++ chunks with sizes indicated in the "sizes" array. It returns
++ an array of pointers to these elements, each of which can be
++ independently freed, realloc'ed etc. The elements are guaranteed to
++ be adjacently allocated (this is not guaranteed to occur with
++ multiple callocs or mallocs), which may also improve cache locality
++ in some applications.
++
++ The "chunks" argument is optional (i.e., may be null). If it is null
++ the returned array is itself dynamically allocated and should also
++ be freed when it is no longer needed. Otherwise, the chunks array
++ must be of at least n_elements in length. It is filled in with the
++ pointers to the chunks.
++
++ In either case, independent_comalloc returns this pointer array, or
++ null if the allocation failed. If n_elements is zero and chunks is
++ null, it returns a chunk representing an array with zero elements
++ (which should be freed if not wanted).
++
++ Each element must be individually freed when it is no longer
++ needed. If you'd like to instead be able to free all at once, you
++ should instead use a single regular malloc, and assign pointers at
++ particular offsets in the aggregate space. (In this case though, you
++ cannot independently free elements.)
++
++ independent_comallac differs from independent_calloc in that each
++ element may have a different size, and also that it does not
++ automatically clear elements.
++
++ independent_comalloc can be used to speed up allocation in cases
++ where several structs or objects must always be allocated at the
++ same time. For example:
++
++ struct Head { ... }
++ struct Foot { ... }
++
++ void send_message(char* msg) {
++ int msglen = strlen(msg);
++ size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
++ void* chunks[3];
++ if (independent_comalloc(3, sizes, chunks) == 0)
++ die();
++ struct Head* head = (struct Head*)(chunks[0]);
++ char* body = (char*)(chunks[1]);
++ struct Foot* foot = (struct Foot*)(chunks[2]);
++ // ...
++ }
++
++ In general though, independent_comalloc is worth using only for
++ larger values of n_elements. For small values, you probably won't
++ detect enough difference from series of malloc calls to bother.
++
++ 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.
++*/
++#if __STD_C
++Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
++#else
++Void_t** public_iCOMALLOc();
++#endif
++
++
++/*
++ pvalloc(size_t n);
++ Equivalent to valloc(minimum-page-that-holds(n)), that is,
++ round up n to nearest pagesize.
++ */
++#if __STD_C
++Void_t* public_pVALLOc(size_t);
++#else
++Void_t* public_pVALLOc();
++#endif
++
++/*
++ cfree(Void_t* p);
++ Equivalent to free(p).
++
++ cfree is needed/defined on some systems that pair it with calloc,
++ for odd historical reasons (such as: cfree is used in example
++ code in the first edition of K&R).
++*/
++#if __STD_C
++void public_cFREe(Void_t*);
++#else
++void public_cFREe();
++#endif
++
++/*
++ malloc_trim(size_t pad);
++
++ If possible, gives memory back to the system (via negative
++ arguments to sbrk) if there is unused memory at the `high' end of
++ the malloc pool. You can call this after freeing large blocks of
++ memory to potentially reduce the system-level memory requirements
++ of a program. However, it cannot guarantee to reduce memory. Under
++ some allocation patterns, some large free blocks of memory will be
++ locked between two used chunks, so they cannot be given back to
++ the system.
++
++ The `pad' argument to malloc_trim represents the amount of free
++ trailing space to leave untrimmed. If this argument is zero,
++ only the minimum amount of memory to maintain internal data
++ structures will be left (one page or less). Non-zero arguments
++ can be supplied to maintain enough 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.
++ On systems that do not support "negative sbrks", it will always
++ rreturn 0.
++*/
++#if __STD_C
++int public_mTRIm(size_t);
++#else
++int public_mTRIm();
++#endif
++
++/*
++ malloc_usable_size(Void_t* p);
++
++ Returns the number of bytes you can actually use in
++ an allocated chunk, which may be more than you requested (although
++ often not) due to alignment and minimum size constraints.
++ You can use this many bytes without worrying about
++ overwriting other allocated objects. This is not a particularly great
++ programming practice. malloc_usable_size can be more useful in
++ debugging and assertions, for example:
++
++ p = malloc(n);
++ assert(malloc_usable_size(p) >= 256);
++
++*/
++#if __STD_C
++size_t public_mUSABLe(Void_t*);
++#else
++size_t public_mUSABLe();
++#endif
++
++/*
++ 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
++ current if malloc_trim and/or munmap got called), and the current
++ number of bytes allocated via malloc (or realloc, etc) but not yet
++ freed. Note that this is the number of bytes allocated, not the
++ number requested. It will be larger than the number requested
++ because of alignment and bookkeeping overhead. Because it includes
++ alignment wastage as being in use, this figure may be greater than
++ zero even when no user-level chunks are allocated.
++
++ The reported current and maximum system memory can be inaccurate if
++ a program makes other calls to system memory allocation functions
++ (normally sbrk) outside of malloc.
++
++ malloc_stats prints only the most commonly interesting statistics.
++ More information can be obtained by calling mallinfo.
++
++*/
++#if __STD_C
++void public_mSTATs();
++#else
++void public_mSTATs();
++#endif
++
++/* mallopt tuning options */
++
++/*
++ M_MXFAST is the maximum request size used for "fastbins", special bins
++ that hold returned chunks without consolidating their spaces. This
++ enables future requests for chunks of the same size to be handled
++ very quickly, but can increase fragmentation, and thus increase the
++ overall memory footprint of a program.
++
++ This malloc manages fastbins very conservatively yet still
++ efficiently, so fragmentation is rarely a problem for values less
++ than or equal to the default. The maximum supported value of MXFAST
++ is 80. You wouldn't want it any higher than this anyway. Fastbins
++ are designed especially for use with many small structs, objects or
++ strings -- the default handles structs/objects/arrays with sizes up
++ to 8 4byte fields, or small strings representing words, tokens,
++ etc. Using fastbins for larger objects normally worsens
++ fragmentation without improving speed.
++
++ M_MXFAST is set in REQUEST size units. It is internally used in
++ chunksize units, which adds padding and alignment. You can reduce
++ M_MXFAST to 0 to disable all use of fastbins. This causes the malloc
++ algorithm to be a closer approximation of fifo-best-fit in all cases,
++ not just for larger requests, but will generally cause it to be
++ slower.
++*/
++
++
++/* M_MXFAST is a standard SVID/XPG tuning option, usually listed in malloc.h */
++#ifndef M_MXFAST
++#define M_MXFAST 1
++#endif
++
++#ifndef DEFAULT_MXFAST
++#define DEFAULT_MXFAST 64
++#endif
++
++
++/*
++ M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
++ to keep before releasing via malloc_trim in free().
++
++ Automatic trimming is mainly useful in long-lived programs.
++ Because trimming via sbrk can be slow on some systems, and can
++ sometimes be wasteful (in cases where programs immediately
++ afterward allocate more large chunks) the value should be high
++ enough so that your overall system performance would improve by
++ releasing this much memory.
++
++ The trim threshold and the mmap control parameters (see below)
++ can be traded off with one another. Trimming and mmapping are
++ two different ways of releasing unused memory back to the
++ system. Between these two, it is often possible to keep
++ system-level demands of a long-lived program down to a bare
++ minimum. For example, in one test suite of sessions measuring
++ the XF86 X server on Linux, using a trim threshold of 128K and a
++ mmap threshold of 192K led to near-minimal long term resource
++ consumption.
++
++ If you are using this malloc in a long-lived program, it should
++ pay to experiment with these values. As a rough guide, you
++ might set to a value close to the average size of a process
++ (program) running on your system. Releasing this much memory
++ would allow such a process to run in memory. Generally, it's
++ worth it to tune for trimming rather tham memory mapping when a
++ program undergoes phases where several large chunks are
++ allocated and released in ways that can reuse each other's
++ storage, perhaps mixed with phases where there are no such
++ chunks at all. And in well-behaved long-lived programs,
++ controlling release of large blocks via trimming versus mapping
++ is usually faster.
++
++ However, in most programs, these parameters serve mainly as
++ protection against the system-level effects of carrying around
++ massive amounts of unneeded memory. Since frequent calls to
++ sbrk, mmap, and munmap otherwise degrade performance, the default
++ parameters are set to relatively high values that serve only as
++ safeguards.
++
++ The trim value It must be greater than page size to have any useful
++ effect. To disable trimming completely, you can set to
++ (unsigned long)(-1)
++
++ Trim settings interact with fastbin (MXFAST) settings: Unless
++ TRIM_FASTBINS is defined, automatic trimming never takes place upon
++ freeing a chunk with size less than or equal to MXFAST. Trimming is
++ instead delayed until subsequent freeing of larger chunks. However,
++ you can still force an attempted trim by calling malloc_trim.
++
++ Also, trimming is not generally possible in cases where
++ the main arena is obtained via mmap.
++
++ Note that the trick some people use of mallocing a huge space and
++ then freeing it at program startup, in an attempt to reserve system
++ memory, doesn't have the intended effect under automatic trimming,
++ since that memory will immediately be returned to the system.
++*/
++
++#define M_TRIM_THRESHOLD -1
++
++#ifndef DEFAULT_TRIM_THRESHOLD
++#define DEFAULT_TRIM_THRESHOLD (128 * 1024)
++#endif
++
++/*
++ M_TOP_PAD is the amount of extra `padding' space to allocate or
++ retain whenever sbrk is called. It is used in two ways internally:
++
++ * When sbrk is called to extend the top of the arena to satisfy
++ a new malloc request, this much padding is added to the sbrk
++ request.
++
++ * When malloc_trim is called automatically from free(),
++ it is used as the `pad' argument.
++
++ In both cases, the actual amount of padding is rounded
++ so that the end of the arena is always a system page boundary.
++
++ The main reason for using padding is to avoid calling sbrk so
++ often. Having even a small pad greatly reduces the likelihood
++ that nearly every malloc request during program start-up (or
++ after trimming) will invoke sbrk, which needlessly wastes
++ time.
++
++ Automatic rounding-up to page-size units is normally sufficient
++ to avoid measurable overhead, so the default is 0. However, in
++ systems where sbrk is relatively slow, it can pay to increase
++ this value, at the expense of carrying around more memory than
++ the program needs.
++*/
++
++#define M_TOP_PAD -2
++
++#ifndef DEFAULT_TOP_PAD
++#define DEFAULT_TOP_PAD (0)
++#endif
++
++/*
++ M_MMAP_THRESHOLD is the request size threshold for using mmap()
++ to service a request. Requests of at least this size that cannot
++ be allocated using already-existing space will be serviced via mmap.
++ (If enough normal freed space already exists it is used instead.)
++
++ Using mmap segregates relatively large chunks of memory so that
++ they can be individually obtained and released from the host
++ system. A request serviced through mmap is never reused by any
++ other request (at least not directly; the system may just so
++ happen to remap successive requests to the same locations).
++
++ Segregating space in this way has the benefits that:
++
++ 1. Mmapped space can ALWAYS be individually released back
++ to the system, which helps keep the system level memory
++ demands of a long-lived program low.
++ 2. Mapped memory can never become `locked' between
++ other chunks, as can happen with normally allocated chunks, which
++ means that even trimming via malloc_trim would not release them.
++ 3. On some systems with "holes" in address spaces, mmap can obtain
++ memory that sbrk cannot.
++
++ However, it has the disadvantages that:
++
++ 1. The space cannot be reclaimed, consolidated, and then
++ used to service later requests, as happens with normal chunks.
++ 2. It can lead to more wastage because of mmap page alignment
++ requirements
++ 3. It causes malloc performance to be more dependent on host
++ system memory management support routines which may vary in
++ implementation quality and may impose arbitrary
++ limitations. Generally, servicing a request via normal
++ malloc steps is faster than going through a system's mmap.
++
++ The advantages of mmap nearly always outweigh disadvantages for
++ "large" chunks, but the value of "large" varies across systems. The
++ default is an empirically derived value that works well in most
++ systems.
++*/
++
++#define M_MMAP_THRESHOLD -3
++
++#ifndef DEFAULT_MMAP_THRESHOLD
++#define DEFAULT_MMAP_THRESHOLD (128 * 1024)
++#endif
++
++/*
++ M_MMAP_MAX is the maximum number of requests to simultaneously
++ service using mmap. This parameter exists because
++. Some systems have a limited number of internal tables for
++ use by mmap, and using more than a few of them may degrade
++ performance.
++
++ The default is set to a value that serves only as a safeguard.
++ Setting to 0 disables use of mmap for servicing large requests. If
++ HAVE_MMAP is not set, the default value is 0, and attempts to set it
++ to non-zero values in mallopt will fail.
++*/
++
++#define M_MMAP_MAX -4
++
++#ifndef DEFAULT_MMAP_MAX
++#if HAVE_MMAP
++#define DEFAULT_MMAP_MAX (65536)
++#else
++#define DEFAULT_MMAP_MAX (0)
++#endif
++#endif
++
++#ifdef __cplusplus
++}; /* end of extern "C" */
++#endif
++
++/*
++ ========================================================================
++ To make a fully customizable malloc.h header file, cut everything
++ above this line, put into file malloc.h, edit to suit, and #include it
++ on the next line, as well as in programs that use this malloc.
++ ========================================================================
++*/
++
++/* #include "malloc.h" */
++
++/* --------------------- public wrappers ---------------------- */
++
++#ifdef USE_PUBLIC_MALLOC_WRAPPERS
++
++/* Declare all routines as internal */
++#if __STD_C
++static Void_t* mALLOc(size_t);
++static void fREe(Void_t*);
++static Void_t* rEALLOc(Void_t*, size_t);
++static Void_t* mEMALIGn(size_t, size_t);
++static Void_t* vALLOc(size_t);
++static Void_t* pVALLOc(size_t);
++static Void_t* cALLOc(size_t, size_t);
++static Void_t** iCALLOc(size_t, size_t, Void_t**);
++static Void_t** iCOMALLOc(size_t, size_t*, Void_t**);
++static void cFREe(Void_t*);
++static int mTRIm(size_t);
++static size_t mUSABLe(Void_t*);
++static void mSTATs();
++static int mALLOPt(int, int);
++static struct mallinfo mALLINFo(void);
++#else
++static Void_t* mALLOc();
++static void fREe();
++static Void_t* rEALLOc();
++static Void_t* mEMALIGn();
++static Void_t* vALLOc();
++static Void_t* pVALLOc();
++static Void_t* cALLOc();
++static Void_t** iCALLOc();
++static Void_t** iCOMALLOc();
++static void cFREe();
++static int mTRIm();
++static size_t mUSABLe();
++static void mSTATs();
++static int mALLOPt();
++static struct mallinfo mALLINFo();
++#endif
++
++/*
++ MALLOC_PREACTION and MALLOC_POSTACTION should be
++ defined to return 0 on success, and nonzero on failure.
++ The return value of MALLOC_POSTACTION is currently ignored
++ in wrapper functions since there is no reasonable default
++ action to take on failure.
++*/
++
++
++#ifdef USE_MALLOC_LOCK
++
++#ifdef WIN32
++
++static int mALLOC_MUTEx;
++#define MALLOC_PREACTION slwait(&mALLOC_MUTEx)
++#define MALLOC_POSTACTION slrelease(&mALLOC_MUTEx)
++
++#else
++
++#if 0
++#include <pthread.h>
++
++static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER;
++
++#define MALLOC_PREACTION pthread_mutex_lock(&mALLOC_MUTEx)
++#define MALLOC_POSTACTION pthread_mutex_unlock(&mALLOC_MUTEx)
++
++#else
++
++#ifdef KDE_MALLOC_X86
++#include "x86.h"
++#elif defined(KDE_MALLOC_AVR32)
++
++#include <sched.h>
++#include <time.h>
++
++static __inline__ int q_atomic_swp(volatile unsigned int *ptr,
++ unsigned int newval)
++{
++ register int ret;
++ asm volatile("xchg %0,%1,%2"
++ : "=&r"(ret)
++ : "r"(ptr), "r"(newval)
++ : "memory", "cc");
++ return ret;
++}
++
++typedef struct {
++ volatile unsigned int lock;
++ int pad0_;
++} mutex_t;
++
++#define MUTEX_INITIALIZER { 0, 0 }
++
++static __inline__ int lock(mutex_t *m) {
++ int cnt = 0;
++ struct timespec tm;
++
++ for(;;) {
++ if (q_atomic_swp(&m->lock, 1) == 0)
++ return 0;
++#ifdef _POSIX_PRIORITY_SCHEDULING
++ if(cnt < 50) {
++ sched_yield();
++ cnt++;
++ } else
++#endif
++ {
++ tm.tv_sec = 0;
++ tm.tv_nsec = 2000001;
++ nanosleep(&tm, NULL);
++ cnt = 0;
++ }
++ }
++}
++
++static __inline__ int unlock(mutex_t *m) {
++ m->lock = 0;
++ return 0;
++}
++
++#else
++#error Unknown spinlock implementation
++#endif
++
++static mutex_t spinlock = MUTEX_INITIALIZER;
++
++#define MALLOC_PREACTION lock( &spinlock )
++#define MALLOC_POSTACTION unlock( &spinlock )
++
++#endif
++
++#endif /* USE_MALLOC_LOCK */
++
++#else
++
++/* Substitute anything you like for these */
++
++#define MALLOC_PREACTION (0)
++#define MALLOC_POSTACTION (0)
++
++#endif
++
++#if 0
++Void_t* public_mALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++void public_fREe(Void_t* m) {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ fREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = rEALLOc(m, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mEMALIGn(alignment, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_vALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = vALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_pVALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = pVALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_cALLOc(size_t n, size_t elem_size) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = cALLOc(n, elem_size);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++
++Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {
++ Void_t** m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = iCALLOc(n, elem_size, chunks);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {
++ Void_t** m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = iCOMALLOc(n, sizes, chunks);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++void public_cFREe(Void_t* m) {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ cFREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++int public_mTRIm(size_t s) {
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mTRIm(s);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++
++size_t public_mUSABLe(Void_t* m) {
++ size_t result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mUSABLe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++
++void public_mSTATs() {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ mSTATs();
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++struct mallinfo public_mALLINFo() {
++ struct mallinfo m;
++ if (MALLOC_PREACTION != 0) {
++ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
++ return nm;
++ }
++ m = mALLINFo();
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++int public_mALLOPt(int p, int v) {
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mALLOPt(p, v);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++#endif
++
++#endif
++
++
++
++/* ------------- Optional versions of memcopy ---------------- */
++
++
++#if USE_MEMCPY
++
++/*
++ Note: memcpy is ONLY invoked with non-overlapping regions,
++ so the (usually slower) memmove is not needed.
++*/
++
++#define MALLOC_COPY(dest, src, nbytes) memcpy(dest, src, nbytes)
++#define MALLOC_ZERO(dest, nbytes) memset(dest, 0, nbytes)
++
++#else /* !USE_MEMCPY */
++
++/* Use Duff's device for good zeroing/copying performance. */
++
++#define MALLOC_ZERO(charp, nbytes) \
++do { \
++ INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \
++ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
++ long mcn; \
++ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
++ switch (mctmp) { \
++ case 0: for(;;) { *mzp++ = 0; \
++ case 7: *mzp++ = 0; \
++ case 6: *mzp++ = 0; \
++ case 5: *mzp++ = 0; \
++ case 4: *mzp++ = 0; \
++ case 3: *mzp++ = 0; \
++ case 2: *mzp++ = 0; \
++ case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \
++ } \
++} while(0)
++
++#define MALLOC_COPY(dest,src,nbytes) \
++do { \
++ INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \
++ INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \
++ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
++ long mcn; \
++ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
++ switch (mctmp) { \
++ case 0: for(;;) { *mcdst++ = *mcsrc++; \
++ case 7: *mcdst++ = *mcsrc++; \
++ case 6: *mcdst++ = *mcsrc++; \
++ case 5: *mcdst++ = *mcsrc++; \
++ case 4: *mcdst++ = *mcsrc++; \
++ case 3: *mcdst++ = *mcsrc++; \
++ case 2: *mcdst++ = *mcsrc++; \
++ case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \
++ } \
++} while(0)
++
++#endif
++
++/* ------------------ MMAP support ------------------ */
++
++
++#if HAVE_MMAP
++
++#include <fcntl.h>
++#ifndef LACKS_SYS_MMAN_H
++#include <sys/mman.h>
++#endif
++
++#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
++#define MAP_ANONYMOUS MAP_ANON
++#endif
++
++/*
++ Nearly all versions of mmap support MAP_ANONYMOUS,
++ so the following is unlikely to be needed, but is
++ supplied just in case.
++*/
++
++#ifndef MAP_ANONYMOUS
++
++static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
++
++#define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? \
++ (dev_zero_fd = open("/dev/zero", O_RDWR), \
++ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : \
++ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0))
++
++#else
++
++#define MMAP(addr, size, prot, flags) \
++ (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0))
++
++#endif
++
++
++#endif /* HAVE_MMAP */
++
++
++/*
++ ----------------------- Chunk representations -----------------------
++*/
++
++
++/*
++ This struct declaration is misleading (but accurate and necessary).
++ It declares a "view" into memory allowing access to necessary
++ fields at known offsets from a given base. See explanation below.
++*/
++
++struct malloc_chunk {
++
++ INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
++ INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
++
++ struct malloc_chunk* fd; /* double links -- used only if free. */
++ struct malloc_chunk* bk;
++};
++
++
++typedef struct malloc_chunk* mchunkptr;
++
++/*
++ malloc_chunk details:
++
++ (The following includes lightly edited explanations by Colin Plumb.)
++
++ Chunks of memory are maintained using a `boundary tag' method as
++ described in e.g., Knuth or Standish. (See the paper by Paul
++ Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
++ survey of such techniques.) Sizes of free chunks are stored both
++ in the front of each chunk and at the end. This makes
++ consolidating fragmented chunks into bigger chunks very fast. The
++ size fields also hold bits representing whether chunks are free or
++ in use.
++
++ An allocated chunk looks like this:
++
++
++ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of previous chunk, if allocated | |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of chunk, in bytes |P|
++ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | User data starts here... .
++ . .
++ . (malloc_usable_space() bytes) .
++ . |
++nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of chunk |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++
++
++ Where "chunk" is the front of the chunk for the purpose of most of
++ the malloc code, but "mem" is the pointer that is returned to the
++ user. "Nextchunk" is the beginning of the next contiguous chunk.
++
++ Chunks always begin on even word boundaries, so the mem portion
++ (which is returned to the user) is also on an even word boundary, and
++ thus at least double-word aligned.
++
++ Free chunks are stored in circular doubly-linked lists, and look like this:
++
++ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of previous chunk |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ `head:' | Size of chunk, in bytes |P|
++ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Forward pointer to next chunk in list |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Back pointer to previous chunk in list |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Unused space (may be 0 bytes long) .
++ . .
++ . |
++nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ `foot:' | Size of chunk, in bytes |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++
++ The P (PREV_INUSE) bit, stored in the unused low-order bit of the
++ chunk size (which is always a multiple of two words), is an in-use
++ bit for the *previous* chunk. If that bit is *clear*, then the
++ word before the current chunk size contains the previous chunk
++ size, and can be used to find the front of the previous chunk.
++ The very first chunk allocated always has this bit set,
++ preventing access to non-existent (or non-owned) memory. If
++ prev_inuse is set for any given chunk, then you CANNOT determine
++ the size of the previous chunk, and might even get a memory
++ addressing fault when trying to do so.
++
++ Note that the `foot' of the current chunk is actually represented
++ as the prev_size of the NEXT chunk. This makes it easier to
++ deal with alignments etc but can be very confusing when trying
++ to extend or adapt this code.
++
++ The two exceptions to all this are
++
++ 1. The special chunk `top' doesn't bother using the
++ trailing size field since there is no next contiguous chunk
++ that would have to index off it. After initialization, `top'
++ is forced to always exist. If it would become less than
++ MINSIZE bytes long, it is replenished.
++
++ 2. Chunks allocated via mmap, which have the second-lowest-order
++ bit (IS_MMAPPED) set in their size fields. Because they are
++ allocated one-by-one, each must contain its own trailing size field.
++
++*/
++
++/*
++ ---------- Size and alignment checks and conversions ----------
++*/
++
++/* conversion from malloc headers to user pointers, and back */
++
++#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ))
++#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
++
++/* The smallest possible chunk */
++#define MIN_CHUNK_SIZE (sizeof(struct malloc_chunk))
++
++/* The smallest size we can malloc is an aligned minimal chunk */
++
++#define MINSIZE \
++ (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
++
++/* Check if m has acceptable alignment */
++
++#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
++
++
++/*
++ Check if a request is so large that it would wrap around zero when
++ padded and aligned. To simplify some other code, the bound is made
++ low enough so that adding MINSIZE will also not wrap around zero.
++*/
++
++#define REQUEST_OUT_OF_RANGE(req) \
++ ((unsigned long)(req) >= \
++ (unsigned long)(INTERNAL_SIZE_T)(-2 * MINSIZE))
++
++/* pad request bytes into a usable size -- internal version */
++
++#define request2size(req) \
++ (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \
++ MINSIZE : \
++ ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
++
++/* Same, except also perform argument check */
++
++#define checked_request2size(req, sz) \
++ if (REQUEST_OUT_OF_RANGE(req)) { \
++ MALLOC_FAILURE_ACTION; \
++ return 0; \
++ } \
++ (sz) = request2size(req);
++
++/*
++ --------------- Physical chunk operations ---------------
++*/
++
++
++/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
++#define PREV_INUSE 0x1
++
++/* extract inuse bit of previous chunk */
++#define prev_inuse(p) ((p)->size & PREV_INUSE)
++
++
++/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
++#define IS_MMAPPED 0x2
++
++/* check for mmap()'ed chunk */
++#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
++
++/*
++ Bits to mask off when extracting size
++
++ Note: IS_MMAPPED is intentionally not masked off from size field in
++ macros for which mmapped chunks should never be seen. This should
++ cause helpful core dumps to occur if it is tried by accident by
++ people extending or adapting this malloc.
++*/
++#define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
++
++/* Get size, ignoring use bits */
++#define chunksize(p) ((p)->size & ~(SIZE_BITS))
++
++
++/* Ptr to next physical malloc_chunk. */
++#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
++
++/* Ptr to previous physical malloc_chunk */
++#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
++
++/* Treat space at ptr + offset as a chunk */
++#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
++
++/* extract p's inuse bit */
++#define inuse(p)\
++((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
++
++/* set/clear chunk as being inuse without otherwise disturbing */
++#define set_inuse(p)\
++((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
++
++#define clear_inuse(p)\
++((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
++
++
++/* check/set/clear inuse bits in known places */
++#define inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
++
++#define set_inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
++
++#define clear_inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
++
++
++/* Set size at head, without disturbing its use bit */
++#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s)))
++
++/* Set size/use field */
++#define set_head(p, s) ((p)->size = (s))
++
++/* Set size at footer (only when chunk is not in use) */
++#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
++
++
++/*
++ -------------------- Internal data structures --------------------
++
++ All internal state is held in an instance of malloc_state defined
++ below. There are no other static variables, except in two optional
++ cases:
++ * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
++ * If HAVE_MMAP is true, but mmap doesn't support
++ MAP_ANONYMOUS, a dummy file descriptor for mmap.
++
++ Beware of lots of tricks that minimize the total bookkeeping space
++ requirements. The result is a little over 1K bytes (for 4byte
++ pointers and size_t.)
++*/
++
++/*
++ Bins
++
++ An array of bin headers for free chunks. Each bin is doubly
++ linked. The bins are approximately proportionally (log) spaced.
++ There are a lot of these bins (128). This may look excessive, but
++ works very well in practice. Most bins hold sizes that are
++ unusual as malloc request sizes, but are more usual for fragments
++ and consolidated sets of chunks, which is what these bins hold, so
++ they can be found quickly. All procedures maintain the invariant
++ that no consolidated chunk physically borders another one, so each
++ chunk in a list is known to be preceded and followed by either
++ inuse chunks or the ends of memory.
++
++ Chunks in bins are kept in size order, with ties going to the
++ approximately least recently used chunk. Ordering isn't needed
++ for the small bins, which all contain the same-sized chunks, but
++ facilitates best-fit allocation for larger chunks. These lists
++ are just sequential. Keeping them in order almost never requires
++ enough traversal to warrant using fancier ordered data
++ structures.
++
++ Chunks of the same size are linked with the most
++ recently freed at the front, and allocations are taken from the
++ back. This results in LRU (FIFO) allocation order, which tends
++ to give each chunk an equal opportunity to be consolidated with
++ adjacent freed chunks, resulting in larger free chunks and less
++ fragmentation.
++
++ To simplify use in double-linked lists, each bin header acts
++ as a malloc_chunk. This avoids special-casing for headers.
++ But to conserve space and improve locality, we allocate
++ only the fd/bk pointers of bins, and then use repositioning tricks
++ to treat these as the fields of a malloc_chunk*.
++*/
++
++typedef struct malloc_chunk* mbinptr;
++
++/* addressing -- note that bin_at(0) does not exist */
++#define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1)))
++
++/* analog of ++bin */
++#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
++
++/* Reminders about list directionality within bins */
++#define first(b) ((b)->fd)
++#define last(b) ((b)->bk)
++
++/* Take a chunk off a bin list */
++#define unlink(P, BK, FD) { \
++ FD = P->fd; \
++ BK = P->bk; \
++ FD->bk = BK; \
++ BK->fd = FD; \
++}
++
++/*
++ Indexing
++
++ Bins for sizes < 512 bytes contain chunks of all the same size, spaced
++ 8 bytes apart. Larger bins are approximately logarithmically spaced:
++
++ 64 bins of size 8
++ 32 bins of size 64
++ 16 bins of size 512
++ 8 bins of size 4096
++ 4 bins of size 32768
++ 2 bins of size 262144
++ 1 bin of size what's left
++
++ There is actually a little bit of slop in the numbers in bin_index
++ for the sake of speed. This makes no difference elsewhere.
++
++ The bins top out around 1MB because we expect to service large
++ requests via mmap.
++*/
++
++#define NBINS 128
++#define NSMALLBINS 64
++#define SMALLBIN_WIDTH 8
++#define MIN_LARGE_SIZE 512
++
++#define in_smallbin_range(sz) \
++ ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
++
++#define smallbin_index(sz) (((unsigned)(sz)) >> 3)
++
++#define largebin_index(sz) \
++(((((unsigned long)(sz)) >> 6) <= 32)? 56 + (((unsigned long)(sz)) >> 6): \
++ ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
++ ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
++ ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
++ ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
++ 126)
++
++#define bin_index(sz) \
++ ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
++
++
++/*
++ Unsorted chunks
++
++ All remainders from chunk splits, as well as all returned chunks,
++ are first placed in the "unsorted" bin. They are then placed
++ in regular bins after malloc gives them ONE chance to be used before
++ binning. So, basically, the unsorted_chunks list acts as a queue,
++ with chunks being placed on it in free (and malloc_consolidate),
++ and taken off (to be either used or placed in bins) in malloc.
++*/
++
++/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
++#define unsorted_chunks(M) (bin_at(M, 1))
++
++/*
++ Top
++
++ The top-most available chunk (i.e., the one bordering the end of
++ available memory) is treated specially. It is never included in
++ any bin, is used only if no other chunk is available, and is
++ released back to the system if it is very large (see
++ M_TRIM_THRESHOLD). Because top initially
++ points to its own bin with initial zero size, thus forcing
++ extension on the first malloc request, we avoid having any special
++ code in malloc to check whether it even exists yet. But we still
++ need to do so when getting memory from system, so we make
++ initial_top treat the bin as a legal but unusable chunk during the
++ interval between initialization and the first call to
++ sYSMALLOc. (This is somewhat delicate, since it relies on
++ the 2 preceding words to be zero during this interval as well.)
++*/
++
++/* Conveniently, the unsorted bin can be used as dummy top on first call */
++#define initial_top(M) (unsorted_chunks(M))
++
++/*
++ Binmap
++
++ To help compensate for the large number of bins, a one-level index
++ structure is used for bin-by-bin searching. `binmap' is a
++ bitvector recording whether bins are definitely empty so they can
++ be skipped over during during traversals. The bits are NOT always
++ cleared as soon as bins are empty, but instead only
++ when they are noticed to be empty during traversal in malloc.
++*/
++
++/* Conservatively use 32 bits per map word, even if on 64bit system */
++#define BINMAPSHIFT 5
++#define BITSPERMAP (1U << BINMAPSHIFT)
++#define BINMAPSIZE (NBINS / BITSPERMAP)
++
++#define idx2block(i) ((i) >> BINMAPSHIFT)
++#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
++
++#define mark_bin(m,i) ((m)->binmap[idx2block(i)] |= idx2bit(i))
++#define unmark_bin(m,i) ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
++#define get_binmap(m,i) ((m)->binmap[idx2block(i)] & idx2bit(i))
++
++/*
++ Fastbins
++
++ An array of lists holding recently freed small chunks. Fastbins
++ are not doubly linked. It is faster to single-link them, and
++ since chunks are never removed from the middles of these lists,
++ double linking is not necessary. Also, unlike regular bins, they
++ are not even processed in FIFO order (they use faster LIFO) since
++ ordering doesn't much matter in the transient contexts in which
++ fastbins are normally used.
++
++ Chunks in fastbins keep their inuse bit set, so they cannot
++ be consolidated with other free chunks. malloc_consolidate
++ releases all chunks in fastbins and consolidates them with
++ other free chunks.
++*/
++
++typedef struct malloc_chunk* mfastbinptr;
++
++/* offset 2 to use otherwise unindexable first 2 bins */
++#define fastbin_index(sz) ((((unsigned int)(sz)) >> 3) - 2)
++
++/* The maximum fastbin request size we support */
++#define MAX_FAST_SIZE 80
++
++#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE))+1)
++
++/*
++ FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
++ that triggers automatic consolidation of possibly-surrounding
++ fastbin chunks. This is a heuristic, so the exact value should not
++ matter too much. It is defined at half the default trim threshold as a
++ compromise heuristic to only attempt consolidation if it is likely
++ to lead to trimming. However, it is not dynamically tunable, since
++ consolidation reduces fragmentation surrounding loarge chunks even
++ if trimming is not used.
++*/
++
++#define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL)
++
++/*
++ Since the lowest 2 bits in max_fast don't matter in size comparisons,
++ they are used as flags.
++*/
++
++/*
++ FASTCHUNKS_BIT held in max_fast indicates that there are probably
++ some fastbin chunks. It is set true on entering a chunk into any
++ fastbin, and cleared only in malloc_consolidate.
++
++ The truth value is inverted so that have_fastchunks will be true
++ upon startup (since statics are zero-filled), simplifying
++ initialization checks.
++*/
++
++#define FASTCHUNKS_BIT (1U)
++
++#define have_fastchunks(M) (((M)->max_fast & FASTCHUNKS_BIT) == 0)
++#define clear_fastchunks(M) ((M)->max_fast |= FASTCHUNKS_BIT)
++#define set_fastchunks(M) ((M)->max_fast &= ~FASTCHUNKS_BIT)
++
++/*
++ NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
++ regions. Otherwise, contiguity is exploited in merging together,
++ when possible, results from consecutive MORECORE calls.
++
++ The initial value comes from MORECORE_CONTIGUOUS, but is
++ changed dynamically if mmap is ever used as an sbrk substitute.
++*/
++
++#define NONCONTIGUOUS_BIT (2U)
++
++#define contiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) == 0)
++#define noncontiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) != 0)
++#define set_noncontiguous(M) ((M)->max_fast |= NONCONTIGUOUS_BIT)
++#define set_contiguous(M) ((M)->max_fast &= ~NONCONTIGUOUS_BIT)
++
++/*
++ Set value of max_fast.
++ Use impossibly small value if 0.
++ Precondition: there are no existing fastbin chunks.
++ Setting the value clears fastchunk bit but preserves noncontiguous bit.
++*/
++
++#define set_max_fast(M, s) \
++ (M)->max_fast = (((s) == 0)? SMALLBIN_WIDTH: request2size(s)) | \
++ FASTCHUNKS_BIT | \
++ ((M)->max_fast & NONCONTIGUOUS_BIT)
++
++
++/*
++ ----------- Internal state representation and initialization -----------
++*/
++
++struct malloc_state {
++
++ /* The maximum chunk size to be eligible for fastbin */
++ INTERNAL_SIZE_T max_fast; /* low 2 bits used as flags */
++
++ /* Fastbins */
++ mfastbinptr fastbins[NFASTBINS];
++
++ /* Base of the topmost chunk -- not otherwise kept in a bin */
++ mchunkptr top;
++
++ /* The remainder from the most recent split of a small request */
++ mchunkptr last_remainder;
++
++ /* Normal bins packed as described above */
++ mchunkptr bins[NBINS * 2];
++
++ /* Bitmap of bins */
++ unsigned int binmap[BINMAPSIZE];
++
++ /* Tunable parameters */
++ unsigned long trim_threshold;
++ INTERNAL_SIZE_T top_pad;
++ INTERNAL_SIZE_T mmap_threshold;
++
++ /* Memory map support */
++ int n_mmaps;
++ int n_mmaps_max;
++ int max_n_mmaps;
++
++ /* Cache malloc_getpagesize */
++ unsigned int pagesize;
++
++ /* Statistics */
++ INTERNAL_SIZE_T mmapped_mem;
++ INTERNAL_SIZE_T sbrked_mem;
++ INTERNAL_SIZE_T max_sbrked_mem;
++ INTERNAL_SIZE_T max_mmapped_mem;
++ INTERNAL_SIZE_T max_total_mem;
++};
++
++typedef struct malloc_state *mstate;
++
++/*
++ There is exactly one instance of this struct in this malloc.
++ If you are adapting this malloc in a way that does NOT use a static
++ malloc_state, you MUST explicitly zero-fill it before using. This
++ malloc relies on the property that malloc_state is initialized to
++ all zeroes (as is true of C statics).
++*/
++
++static struct malloc_state av_; /* never directly referenced */
++
++/*
++ All uses of av_ are via get_malloc_state().
++ At most one "call" to get_malloc_state is made per invocation of
++ the public versions of malloc and free, but other routines
++ that in turn invoke malloc and/or free may call more then once.
++ Also, it is called in check* routines if DEBUG is set.
++*/
++
++#define get_malloc_state() (&(av_))
++
++/*
++ Initialize a malloc_state struct.
++
++ This is called only from within malloc_consolidate, which needs
++ be called in the same contexts anyway. It is never called directly
++ outside of malloc_consolidate because some optimizing compilers try
++ to inline it at all call points, which turns out not to be an
++ optimization at all. (Inlining it in malloc_consolidate is fine though.)
++*/
++
++#if __STD_C
++static void malloc_init_state(mstate av)
++#else
++static void malloc_init_state(av) mstate av;
++#endif
++{
++ int i;
++ mbinptr bin;
++
++ /* Establish circular links for normal bins */
++ for (i = 1; i < NBINS; ++i) {
++ bin = bin_at(av,i);
++ bin->fd = bin->bk = bin;
++ }
++
++ av->top_pad = DEFAULT_TOP_PAD;
++ av->n_mmaps_max = DEFAULT_MMAP_MAX;
++ av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
++ av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
++
++#if !MORECORE_CONTIGUOUS
++ set_noncontiguous(av);
++#endif
++
++ set_max_fast(av, DEFAULT_MXFAST);
++
++ av->top = initial_top(av);
++ av->pagesize = malloc_getpagesize;
++}
++
++/*
++ Other internal utilities operating on mstates
++*/
++
++#if __STD_C
++static Void_t* sYSMALLOc(INTERNAL_SIZE_T, mstate);
++static int sYSTRIm(size_t, mstate);
++static void malloc_consolidate(mstate);
++static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
++#else
++static Void_t* sYSMALLOc();
++static int sYSTRIm();
++static void malloc_consolidate();
++static Void_t** iALLOc();
++#endif
++
++/*
++ Debugging support
++
++ These routines make a number of assertions about the states
++ of data structures that should be true at all times. If any
++ are not true, it's very likely that a user program has somehow
++ trashed memory. (It's also possible that there is a coding error
++ in malloc. In which case, please report it!)
++*/
++
++#ifndef DEBUG
++
++#define check_chunk(P)
++#define check_free_chunk(P)
++#define check_inuse_chunk(P)
++#define check_remalloced_chunk(P,N)
++#define check_malloced_chunk(P,N)
++#define check_malloc_state()
++
++#else
++#define check_chunk(P) do_check_chunk(P)
++#define check_free_chunk(P) do_check_free_chunk(P)
++#define check_inuse_chunk(P) do_check_inuse_chunk(P)
++#define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N)
++#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
++#define check_malloc_state() do_check_malloc_state()
++
++/*
++ Properties of all chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_chunk(mchunkptr p)
++#else
++static void do_check_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++ unsigned long sz = chunksize(p);
++ /* min and max possible addresses assuming contiguous allocation */
++ char* max_address = (char*)(av->top) + chunksize(av->top);
++ char* min_address = max_address - av->sbrked_mem;
++
++ if (!chunk_is_mmapped(p)) {
++
++ /* Has legal address ... */
++ if (p != av->top) {
++ if (contiguous(av)) {
++ assert(((char*)p) >= min_address);
++ assert(((char*)p + sz) <= ((char*)(av->top)));
++ }
++ }
++ else {
++ /* top size is always at least MINSIZE */
++ assert((unsigned long)(sz) >= MINSIZE);
++ /* top predecessor always marked inuse */
++ assert(prev_inuse(p));
++ }
++
++ }
++ else {
++#if HAVE_MMAP
++ /* address is outside main heap */
++ if (contiguous(av) && av->top != initial_top(av)) {
++ assert(((char*)p) < min_address || ((char*)p) > max_address);
++ }
++ /* chunk is page-aligned */
++ assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
++ /* mem is aligned */
++ assert(aligned_OK(chunk2mem(p)));
++#else
++ /* force an appropriate assert violation if debug set */
++ assert(!chunk_is_mmapped(p));
++#endif
++ }
++}
++
++/*
++ Properties of free chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_free_chunk(mchunkptr p)
++#else
++static void do_check_free_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
++ mchunkptr next = chunk_at_offset(p, sz);
++
++ do_check_chunk(p);
++
++ /* Chunk must claim to be free ... */
++ assert(!inuse(p));
++ assert (!chunk_is_mmapped(p));
++
++ /* Unless a special marker, must have OK fields */
++ if ((unsigned long)(sz) >= MINSIZE)
++ {
++ assert((sz & MALLOC_ALIGN_MASK) == 0);
++ assert(aligned_OK(chunk2mem(p)));
++ /* ... matching footer field */
++ assert(next->prev_size == sz);
++ /* ... and is fully consolidated */
++ assert(prev_inuse(p));
++ assert (next == av->top || inuse(next));
++
++ /* ... and has minimally sane links */
++ assert(p->fd->bk == p);
++ assert(p->bk->fd == p);
++ }
++ else /* markers are always of size SIZE_SZ */
++ assert(sz == SIZE_SZ);
++}
++
++/*
++ Properties of inuse chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_inuse_chunk(mchunkptr p)
++#else
++static void do_check_inuse_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++ mchunkptr next;
++ do_check_chunk(p);
++
++ if (chunk_is_mmapped(p))
++ return; /* mmapped chunks have no next/prev */
++
++ /* Check whether it claims to be in use ... */
++ assert(inuse(p));
++
++ next = next_chunk(p);
++
++ /* ... and is surrounded by OK chunks.
++ Since more things can be checked with free chunks than inuse ones,
++ if an inuse chunk borders them and debug is on, it's worth doing them.
++ */
++ if (!prev_inuse(p)) {
++ /* Note that we cannot even look at prev unless it is not inuse */
++ mchunkptr prv = prev_chunk(p);
++ assert(next_chunk(prv) == p);
++ do_check_free_chunk(prv);
++ }
++
++ if (next == av->top) {
++ assert(prev_inuse(next));
++ assert(chunksize(next) >= MINSIZE);
++ }
++ else if (!inuse(next))
++ do_check_free_chunk(next);
++}
++
++/*
++ Properties of chunks recycled from fastbins
++*/
++
++INLINE
++#if __STD_C
++static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
++#else
++static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
++#endif
++{
++ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
++
++ do_check_inuse_chunk(p);
++
++ /* Legal size ... */
++ assert((sz & MALLOC_ALIGN_MASK) == 0);
++ assert((unsigned long)(sz) >= MINSIZE);
++ /* ... and alignment */
++ assert(aligned_OK(chunk2mem(p)));
++ /* chunk is less than MINSIZE more than request */
++ assert((long)(sz) - (long)(s) >= 0);
++ assert((long)(sz) - (long)(s + MINSIZE) < 0);
++}
++
++/*
++ Properties of nonrecycled chunks at the point they are malloced
++*/
++
++INLINE
++#if __STD_C
++static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
++#else
++static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
++#endif
++{
++ /* same as recycled case ... */
++ do_check_remalloced_chunk(p, s);
++
++ /*
++ ... plus, must obey implementation invariant that prev_inuse is
++ always true of any allocated chunk; i.e., that each allocated
++ chunk borders either a previously allocated and still in-use
++ chunk, or the base of its memory arena. This is ensured
++ by making all allocations from the the `lowest' part of any found
++ chunk. This does not necessarily hold however for chunks
++ recycled via fastbins.
++ */
++
++ assert(prev_inuse(p));
++}
++
++
++/*
++ Properties of malloc_state.
++
++ This may be useful for debugging malloc, as well as detecting user
++ programmer errors that somehow write into malloc_state.
++
++ If you are extending or experimenting with this malloc, you can
++ probably figure out how to hack this routine to print out or
++ display chunk addresses, sizes, bins, and other instrumentation.
++*/
++
++static void do_check_malloc_state()
++{
++ mstate av = get_malloc_state();
++ int i;
++ mchunkptr p;
++ mchunkptr q;
++ mbinptr b;
++ unsigned int binbit;
++ int empty;
++ unsigned int idx;
++ INTERNAL_SIZE_T size;
++ unsigned long total = 0;
++ int max_fast_bin;
++
++ /* internal size_t must be no wider than pointer type */
++ assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*));
++
++ /* alignment is a power of 2 */
++ assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0);
++
++ /* cannot run remaining checks until fully initialized */
++ if (av->top == 0 || av->top == initial_top(av))
++ return;
++
++ /* pagesize is a power of 2 */
++ assert((av->pagesize & (av->pagesize-1)) == 0);
++
++ /* properties of fastbins */
++
++ /* max_fast is in allowed range */
++ assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE));
++
++ max_fast_bin = fastbin_index(av->max_fast);
++
++ for (i = 0; i < NFASTBINS; ++i) {
++ p = av->fastbins[i];
++
++ /* all bins past max_fast are empty */
++ if (i > max_fast_bin)
++ assert(p == 0);
++
++ while (p != 0) {
++ /* each chunk claims to be inuse */
++ do_check_inuse_chunk(p);
++ total += chunksize(p);
++ /* chunk belongs in this bin */
++ assert(fastbin_index(chunksize(p)) == i);
++ p = p->fd;
++ }
++ }
++
++ if (total != 0)
++ assert(have_fastchunks(av));
++ else if (!have_fastchunks(av))
++ assert(total == 0);
++
++ /* check normal bins */
++ for (i = 1; i < NBINS; ++i) {
++ b = bin_at(av,i);
++
++ /* binmap is accurate (except for bin 1 == unsorted_chunks) */
++ if (i >= 2) {
++ binbit = get_binmap(av,i);
++ empty = last(b) == b;
++ if (!binbit)
++ assert(empty);
++ else if (!empty)
++ assert(binbit);
++ }
++
++ for (p = last(b); p != b; p = p->bk) {
++ /* each chunk claims to be free */
++ do_check_free_chunk(p);
++ size = chunksize(p);
++ total += size;
++ if (i >= 2) {
++ /* chunk belongs in bin */
++ idx = bin_index(size);
++ assert(idx == i);
++ /* lists are sorted */
++ assert(p->bk == b ||
++ (unsigned long)chunksize(p->bk) >= (unsigned long)chunksize(p));
++ }
++ /* chunk is followed by a legal chain of inuse chunks */
++ for (q = next_chunk(p);
++ (q != av->top && inuse(q) &&
++ (unsigned long)(chunksize(q)) >= MINSIZE);
++ q = next_chunk(q))
++ do_check_inuse_chunk(q);
++ }
++ }
++
++ /* top chunk is OK */
++ check_chunk(av->top);
++
++ /* sanity checks for statistics */
++
++ assert(total <= (unsigned long)(av->max_total_mem));
++ assert(av->n_mmaps >= 0);
++ assert(av->n_mmaps <= av->n_mmaps_max);
++ assert(av->n_mmaps <= av->max_n_mmaps);
++
++ assert((unsigned long)(av->sbrked_mem) <=
++ (unsigned long)(av->max_sbrked_mem));
++
++ assert((unsigned long)(av->mmapped_mem) <=
++ (unsigned long)(av->max_mmapped_mem));
++
++ assert((unsigned long)(av->max_total_mem) >=
++ (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
++}
++#endif
++
++
++/* ----------- Routines dealing with system allocation -------------- */
++
++/*
++ sYSTRIm is an inverse of sorts to sYSMALLOc. It gives memory back
++ to the system (via negative arguments to sbrk) if there is unused
++ memory at the `high' end of the malloc pool. It is called
++ automatically by free() when top space exceeds the trim
++ threshold. It is also called by the public malloc_trim routine. It
++ returns 1 if it actually released any memory, else 0.
++*/
++
++INLINE
++#if __STD_C
++static int sYSTRIm(size_t pad, mstate av)
++#else
++static int sYSTRIm(pad, av) size_t pad; mstate av;
++#endif
++{
++ long top_size; /* Amount of top-most memory */
++ long extra; /* Amount to release */
++ long released; /* Amount actually released */
++ char* current_brk; /* address returned by pre-check sbrk call */
++ char* new_brk; /* address returned by post-check sbrk call */
++ size_t pagesz;
++
++ pagesz = av->pagesize;
++ top_size = chunksize(av->top);
++
++ /* Release in pagesize units, keeping at least one page */
++ extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
++
++ if (extra > 0) {
++
++ /*
++ Only proceed if end of memory is where we last set it.
++ This avoids problems if there were foreign sbrk calls.
++ */
++ current_brk = (char*)(MORECORE(0));
++ if (current_brk == (char*)(av->top) + top_size) {
++
++ /*
++ Attempt to release memory. We ignore MORECORE return value,
++ and instead call again to find out where new end of memory is.
++ This avoids problems if first call releases less than we asked,
++ of if failure somehow altered brk value. (We could still
++ encounter problems if it altered brk in some very bad way,
++ but the only thing we can do is adjust anyway, which will cause
++ some downstream failure.)
++ */
++
++ MORECORE(-extra);
++ new_brk = (char*)(MORECORE(0));
++
++ if (new_brk != (char*)MORECORE_FAILURE) {
++ released = (long)(current_brk - new_brk);
++
++ if (released != 0) {
++ /* Success. Adjust top. */
++ av->sbrked_mem -= released;
++ set_head(av->top, (top_size - released) | PREV_INUSE);
++ check_malloc_state();
++ return 1;
++ }
++ }
++ }
++ }
++ return 0;
++}
++
++/*
++ ------------------------- malloc_consolidate -------------------------
++
++ malloc_consolidate is a specialized version of free() that tears
++ down chunks held in fastbins. Free itself cannot be used for this
++ purpose since, among other things, it might place chunks back onto
++ fastbins. So, instead, we need to use a minor variant of the same
++ code.
++
++ Also, because this routine needs to be called the first time through
++ malloc anyway, it turns out to be the perfect place to trigger
++ initialization code.
++*/
++
++INLINE
++#if __STD_C
++static void malloc_consolidate(mstate av)
++#else
++static void malloc_consolidate(av) mstate av;
++#endif
++{
++ mfastbinptr* fb; /* current fastbin being consolidated */
++ mfastbinptr* maxfb; /* last fastbin (for loop control) */
++ mchunkptr p; /* current chunk being consolidated */
++ mchunkptr nextp; /* next chunk to consolidate */
++ mchunkptr unsorted_bin; /* bin header */
++ mchunkptr first_unsorted; /* chunk to link to */
++
++ /* These have same use as in free() */
++ mchunkptr nextchunk;
++ INTERNAL_SIZE_T size;
++ INTERNAL_SIZE_T nextsize;
++ INTERNAL_SIZE_T prevsize;
++ int nextinuse;
++ mchunkptr bck;
++ mchunkptr fwd;
++
++ /*
++ If max_fast is 0, we know that av hasn't
++ yet been initialized, in which case do so below
++ */
++
++ if (av->max_fast != 0) {
++ clear_fastchunks(av);
++
++ unsorted_bin = unsorted_chunks(av);
++
++ /*
++ Remove each chunk from fast bin and consolidate it, placing it
++ then in unsorted bin. Among other reasons for doing this,
++ placing in unsorted bin avoids needing to calculate actual bins
++ until malloc is sure that chunks aren't immediately going to be
++ reused anyway.
++ */
++
++ maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
++ fb = &(av->fastbins[0]);
++ do {
++ if ( (p = *fb) != 0) {
++ *fb = 0;
++
++ do {
++ check_inuse_chunk(p);
++ nextp = p->fd;
++
++ /* Slightly streamlined version of consolidation code in free() */
++ size = p->size & ~PREV_INUSE;
++ nextchunk = chunk_at_offset(p, size);
++ nextsize = chunksize(nextchunk);
++
++ if (!prev_inuse(p)) {
++ prevsize = p->prev_size;
++ size += prevsize;
++ p = chunk_at_offset(p, -((long) prevsize));
++ unlink(p, bck, fwd);
++ }
++
++ if (nextchunk != av->top) {
++ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
++ set_head(nextchunk, nextsize);
++
++ if (!nextinuse) {
++ size += nextsize;
++ unlink(nextchunk, bck, fwd);
++ }
++
++ first_unsorted = unsorted_bin->fd;
++ unsorted_bin->fd = p;
++ first_unsorted->bk = p;
++
++ set_head(p, size | PREV_INUSE);
++ p->bk = unsorted_bin;
++ p->fd = first_unsorted;
++ set_foot(p, size);
++ }
++
++ else {
++ size += nextsize;
++ set_head(p, size | PREV_INUSE);
++ av->top = p;
++ }
++
++ } while ( (p = nextp) != 0);
++
++ }
++ } while (fb++ != maxfb);
++ }
++ else {
++ malloc_init_state(av);
++ check_malloc_state();
++ }
++}
++
++/*
++ ------------------------------ free ------------------------------
++*/
++
++INLINE
++#if __STD_C
++void fREe(Void_t* mem)
++#else
++void fREe(mem) Void_t* mem;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ mchunkptr p; /* chunk corresponding to mem */
++ INTERNAL_SIZE_T size; /* its size */
++ mfastbinptr* fb; /* associated fastbin */
++ mchunkptr nextchunk; /* next contiguous chunk */
++ INTERNAL_SIZE_T nextsize; /* its size */
++ int nextinuse; /* true if nextchunk is used */
++ INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
++ mchunkptr bck; /* misc temp for linking */
++ mchunkptr fwd; /* misc temp for linking */
++
++
++ /* free(0) has no effect */
++ if (mem != 0) {
++ p = mem2chunk(mem);
++ size = chunksize(p);
++
++ check_inuse_chunk(p);
++
++ /*
++ If eligible, place chunk on a fastbin so it can be found
++ and used quickly in malloc.
++ */
++
++ if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
++
++#if TRIM_FASTBINS
++ /*
++ If TRIM_FASTBINS set, don't place chunks
++ bordering top into fastbins
++ */
++ && (chunk_at_offset(p, size) != av->top)
++#endif
++ ) {
++
++ set_fastchunks(av);
++ fb = &(av->fastbins[fastbin_index(size)]);
++ p->fd = *fb;
++ *fb = p;
++ }
++
++ /*
++ Consolidate other non-mmapped chunks as they arrive.
++ */
++
++ else if (!chunk_is_mmapped(p)) {
++ nextchunk = chunk_at_offset(p, size);
++ nextsize = chunksize(nextchunk);
++
++ /* consolidate backward */
++ if (!prev_inuse(p)) {
++ prevsize = p->prev_size;
++ size += prevsize;
++ p = chunk_at_offset(p, -((long) prevsize));
++ unlink(p, bck, fwd);
++ }
++
++ if (nextchunk != av->top) {
++ /* get and clear inuse bit */
++ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
++ set_head(nextchunk, nextsize);
++
++ /* consolidate forward */
++ if (!nextinuse) {
++ unlink(nextchunk, bck, fwd);
++ size += nextsize;
++ }
++
++ /*
++ Place the chunk in unsorted chunk list. Chunks are
++ not placed into regular bins until after they have
++ been given one chance to be used in malloc.
++ */
++
++ bck = unsorted_chunks(av);
++ fwd = bck->fd;
++ p->bk = bck;
++ p->fd = fwd;
++ bck->fd = p;
++ fwd->bk = p;
++
++ set_head(p, size | PREV_INUSE);
++ set_foot(p, size);
++
++ check_free_chunk(p);
++ }
++
++ /*
++ If the chunk borders the current high end of memory,
++ consolidate into top
++ */
++
++ else {
++ size += nextsize;
++ set_head(p, size | PREV_INUSE);
++ av->top = p;
++ check_chunk(p);
++ }
++
++ /*
++ If freeing a large space, consolidate possibly-surrounding
++ chunks. Then, if the total unused topmost memory exceeds trim
++ threshold, ask malloc_trim to reduce top.
++
++ Unless max_fast is 0, we don't know if there are fastbins
++ bordering top, so we cannot tell for sure whether threshold
++ has been reached unless fastbins are consolidated. But we
++ don't want to consolidate on each free. As a compromise,
++ consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
++ is reached.
++ */
++
++ if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
++ if (have_fastchunks(av))
++ malloc_consolidate(av);
++
++#ifndef MORECORE_CANNOT_TRIM
++ if ((unsigned long)(chunksize(av->top)) >=
++ (unsigned long)(av->trim_threshold))
++ sYSTRIm(av->top_pad, av);
++#endif
++ }
++
++ }
++ /*
++ If the chunk was allocated via mmap, release via munmap()
++ Note that if HAVE_MMAP is false but chunk_is_mmapped is
++ true, then user must have overwritten memory. There's nothing
++ we can do to catch this error unless DEBUG is set, in which case
++ check_inuse_chunk (above) will have triggered error.
++ */
++
++ else {
++#if HAVE_MMAP
++ int ret;
++ INTERNAL_SIZE_T offset = p->prev_size;
++ av->n_mmaps--;
++ av->mmapped_mem -= (size + offset);
++ ret = munmap((char*)p - offset, size + offset);
++ /* munmap returns non-zero on failure */
++ assert(ret == 0);
++#endif
++ }
++ }
++}
++
++/*
++ sysmalloc handles malloc cases requiring more memory from the system.
++ On entry, it is assumed that av->top does not have enough
++ space to service request for nb bytes, thus requiring that av->top
++ be extended or replaced.
++*/
++
++INLINE
++#if __STD_C
++static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
++#else
++static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
++#endif
++{
++ mchunkptr old_top; /* incoming value of av->top */
++ INTERNAL_SIZE_T old_size; /* its size */
++ char* old_end; /* its end address */
++
++ long size; /* arg to first MORECORE or mmap call */
++ char* brk; /* return value from MORECORE */
++
++ long correction; /* arg to 2nd MORECORE call */
++ char* snd_brk; /* 2nd return val */
++
++ INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
++ INTERNAL_SIZE_T end_misalign; /* partial page left at end of new space */
++ char* aligned_brk; /* aligned offset into brk */
++
++ mchunkptr p; /* the allocated/returned chunk */
++ mchunkptr remainder; /* remainder from allocation */
++ unsigned long remainder_size; /* its size */
++
++ unsigned long sum; /* for updating stats */
++
++ size_t pagemask = av->pagesize - 1;
++
++
++#if HAVE_MMAP
++
++ /*
++ If have mmap, and the request size meets the mmap threshold, and
++ the system supports mmap, and there are few enough currently
++ allocated mmapped regions, try to directly map this request
++ rather than expanding top.
++ */
++
++ if ((unsigned long)(nb) >= (unsigned long)(av->mmap_threshold) &&
++ (av->n_mmaps < av->n_mmaps_max)) {
++
++ char* mm; /* return value from mmap call*/
++
++ /*
++ Round up size to nearest page. For mmapped chunks, the overhead
++ is one SIZE_SZ unit larger than for normal chunks, because there
++ is no following chunk whose prev_size field could be used.
++ */
++ size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
++
++ /* Don't try if size wraps around 0 */
++ if ((unsigned long)(size) > (unsigned long)(nb)) {
++
++ mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
++
++ if (mm != (char*)(MORECORE_FAILURE)) {
++
++ /*
++ The offset to the start of the mmapped region is stored
++ in the prev_size field of the chunk. This allows us to adjust
++ returned start address to meet alignment requirements here
++ and in memalign(), and still be able to compute proper
++ address argument for later munmap in free() and realloc().
++ */
++
++ front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK;
++ if (front_misalign > 0) {
++ correction = MALLOC_ALIGNMENT - front_misalign;
++ p = (mchunkptr)(mm + correction);
++ p->prev_size = correction;
++ set_head(p, (size - correction) |IS_MMAPPED);
++ }
++ else {
++ p = (mchunkptr)mm;
++ p->prev_size = 0;
++ set_head(p, size|IS_MMAPPED);
++ }
++
++ /* update statistics */
++
++ if (++av->n_mmaps > av->max_n_mmaps)
++ av->max_n_mmaps = av->n_mmaps;
++
++ sum = av->mmapped_mem += size;
++ if (sum > (unsigned long)(av->max_mmapped_mem))
++ av->max_mmapped_mem = sum;
++ sum += av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ check_chunk(p);
++
++ return chunk2mem(p);
++ }
++ }
++ }
++#endif
++
++ /* Record incoming configuration of top */
++
++ old_top = av->top;
++ old_size = chunksize(old_top);
++ old_end = (char*)(chunk_at_offset(old_top, old_size));
++
++ brk = snd_brk = (char*)(MORECORE_FAILURE);
++
++ /*
++ If not the first time through, we require old_size to be
++ at least MINSIZE and to have prev_inuse set.
++ */
++
++ assert((old_top == initial_top(av) && old_size == 0) ||
++ ((unsigned long) (old_size) >= MINSIZE &&
++ prev_inuse(old_top)));
++
++ /* Precondition: not enough current space to satisfy nb request */
++ assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
++
++ /* Precondition: all fastbins are consolidated */
++ assert(!have_fastchunks(av));
++
++
++ /* Request enough space for nb + pad + overhead */
++
++ size = nb + av->top_pad + MINSIZE;
++
++ /*
++ If contiguous, we can subtract out existing space that we hope to
++ combine with new space. We add it back later only if
++ we don't actually get contiguous space.
++ */
++
++ if (contiguous(av))
++ size -= old_size;
++
++ /*
++ Round to a multiple of page size.
++ If MORECORE is not contiguous, this ensures that we only call it
++ with whole-page arguments. And if MORECORE is contiguous and
++ this is not first time through, this preserves page-alignment of
++ previous calls. Otherwise, we correct to page-align below.
++ */
++
++ size = (size + pagemask) & ~pagemask;
++
++ /*
++ Don't try to call MORECORE if argument is so big as to appear
++ negative. Note that since mmap takes size_t arg, it may succeed
++ below even if we cannot call MORECORE.
++ */
++
++ if (size > 0)
++ brk = (char*)(MORECORE(size));
++
++ /*
++ If have mmap, try using it as a backup when MORECORE fails or
++ cannot be used. This is worth doing on systems that have "holes" in
++ address space, so sbrk cannot extend to give contiguous space, but
++ space is available elsewhere. Note that we ignore mmap max count
++ and threshold limits, since the space will not be used as a
++ segregated mmap region.
++ */
++
++#if HAVE_MMAP
++ if (brk == (char*)(MORECORE_FAILURE)) {
++
++ /* Cannot merge with old top, so add its size back in */
++ if (contiguous(av))
++ size = (size + old_size + pagemask) & ~pagemask;
++
++ /* If we are relying on mmap as backup, then use larger units */
++ if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
++ size = MMAP_AS_MORECORE_SIZE;
++
++ /* Don't try if size wraps around 0 */
++ if ((unsigned long)(size) > (unsigned long)(nb)) {
++
++ brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
++
++ if (brk != (char*)(MORECORE_FAILURE)) {
++
++ /* We do not need, and cannot use, another sbrk call to find end */
++ snd_brk = brk + size;
++
++ /*
++ Record that we no longer have a contiguous sbrk region.
++ After the first time mmap is used as backup, we do not
++ ever rely on contiguous space since this could incorrectly
++ bridge regions.
++ */
++ set_noncontiguous(av);
++ }
++ }
++ }
++#endif
++
++ if (brk != (char*)(MORECORE_FAILURE)) {
++ av->sbrked_mem += size;
++
++ /*
++ If MORECORE extends previous space, we can likewise extend top size.
++ */
++
++ if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
++ set_head(old_top, (size + old_size) | PREV_INUSE);
++ }
++
++ /*
++ Otherwise, make adjustments:
++
++ * If the first time through or noncontiguous, we need to call sbrk
++ just to find out where the end of memory lies.
++
++ * We need to ensure that all returned chunks from malloc will meet
++ MALLOC_ALIGNMENT
++
++ * If there was an intervening foreign sbrk, we need to adjust sbrk
++ request size to account for fact that we will not be able to
++ combine new space with existing space in old_top.
++
++ * Almost all systems internally allocate whole pages at a time, in
++ which case we might as well use the whole last page of request.
++ So we allocate enough more memory to hit a page boundary now,
++ which in turn causes future contiguous calls to page-align.
++ */
++
++ else {
++ front_misalign = 0;
++ end_misalign = 0;
++ correction = 0;
++ aligned_brk = brk;
++
++ /* handle contiguous cases */
++ if (contiguous(av)) {
++
++ /* Guarantee alignment of first new chunk made from this space */
++
++ front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
++ if (front_misalign > 0) {
++
++ /*
++ Skip over some bytes to arrive at an aligned position.
++ We don't need to specially mark these wasted front bytes.
++ They will never be accessed anyway because
++ prev_inuse of av->top (and any chunk created from its start)
++ is always true after initialization.
++ */
++
++ correction = MALLOC_ALIGNMENT - front_misalign;
++ aligned_brk += correction;
++ }
++
++ /*
++ If this isn't adjacent to existing space, then we will not
++ be able to merge with old_top space, so must add to 2nd request.
++ */
++
++ correction += old_size;
++
++ /* Extend the end address to hit a page boundary */
++ end_misalign = (INTERNAL_SIZE_T)(brk + size + correction);
++ correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
++
++ assert(correction >= 0);
++ snd_brk = (char*)(MORECORE(correction));
++
++ /*
++ If can't allocate correction, try to at least find out current
++ brk. It might be enough to proceed without failing.
++
++ Note that if second sbrk did NOT fail, we assume that space
++ is contiguous with first sbrk. This is a safe assumption unless
++ program is multithreaded but doesn't use locks and a foreign sbrk
++ occurred between our first and second calls.
++ */
++
++ if (snd_brk == (char*)(MORECORE_FAILURE)) {
++ correction = 0;
++ snd_brk = (char*)(MORECORE(0));
++ }
++ }
++
++ /* handle non-contiguous cases */
++ else {
++ /* MORECORE/mmap must correctly align */
++ assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
++
++ /* Find out current end of memory */
++ if (snd_brk == (char*)(MORECORE_FAILURE)) {
++ snd_brk = (char*)(MORECORE(0));
++ }
++ }
++
++ /* Adjust top based on results of second sbrk */
++ if (snd_brk != (char*)(MORECORE_FAILURE)) {
++ av->top = (mchunkptr)aligned_brk;
++ set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
++ av->sbrked_mem += correction;
++
++ /*
++ If not the first time through, we either have a
++ gap due to foreign sbrk or a non-contiguous region. Insert a
++ double fencepost at old_top to prevent consolidation with space
++ we don't own. These fenceposts are artificial chunks that are
++ marked as inuse and are in any case too small to use. We need
++ two to make sizes and alignments work out.
++ */
++
++ if (old_size != 0) {
++ /*
++ Shrink old_top to insert fenceposts, keeping size a
++ multiple of MALLOC_ALIGNMENT. We know there is at least
++ enough space in old_top to do this.
++ */
++ old_size = (old_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
++ set_head(old_top, old_size | PREV_INUSE);
++
++ /*
++ Note that the following assignments completely overwrite
++ old_top when old_size was previously MINSIZE. This is
++ intentional. We need the fencepost, even if old_top otherwise gets
++ lost.
++ */
++ chunk_at_offset(old_top, old_size )->size =
++ SIZE_SZ|PREV_INUSE;
++
++ chunk_at_offset(old_top, old_size + SIZE_SZ)->size =
++ SIZE_SZ|PREV_INUSE;
++
++ /* If possible, release the rest. */
++ if (old_size >= MINSIZE) {
++ fREe(chunk2mem(old_top));
++ }
++
++ }
++ }
++ }
++
++ /* Update statistics */
++ sum = av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_sbrked_mem))
++ av->max_sbrked_mem = sum;
++
++ sum += av->mmapped_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ check_malloc_state();
++
++ /* finally, do the allocation */
++ p = av->top;
++ size = chunksize(p);
++
++ /* check that one of the above allocation paths succeeded */
++ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(p, nb);
++ av->top = remainder;
++ set_head(p, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ check_malloced_chunk(p, nb);
++ return chunk2mem(p);
++ }
++ }
++
++ /* catch all failure paths */
++ MALLOC_FAILURE_ACTION;
++ return 0;
++}
++
++
++/*
++ ------------------------------ malloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* mALLOc(size_t bytes)
++#else
++ Void_t* mALLOc(bytes) size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T nb; /* normalized request size */
++ unsigned int idx; /* associated bin index */
++ mbinptr bin; /* associated bin */
++ mfastbinptr* fb; /* associated fastbin */
++
++ mchunkptr victim; /* inspected/selected chunk */
++ INTERNAL_SIZE_T size; /* its size */
++ int victim_index; /* its bin index */
++
++ mchunkptr remainder; /* remainder from a split */
++ unsigned long remainder_size; /* its size */
++
++ unsigned int block; /* bit map traverser */
++ unsigned int bit; /* bit map traverser */
++ unsigned int map; /* current word of binmap */
++
++ mchunkptr fwd; /* misc temp for linking */
++ mchunkptr bck; /* misc temp for linking */
++
++ /*
++ Convert request size to internal form by adding SIZE_SZ bytes
++ overhead plus possibly more to obtain necessary alignment and/or
++ to obtain a size of at least MINSIZE, the smallest allocatable
++ size. Also, checked_request2size traps (returning 0) request sizes
++ that are so large that they wrap around zero when padded and
++ aligned.
++ */
++
++ checked_request2size(bytes, nb);
++
++ /*
++ If the size qualifies as a fastbin, first check corresponding bin.
++ This code is safe to execute even if av is not yet initialized, so we
++ can try it without checking, which saves some time on this fast path.
++ */
++
++ if ((unsigned long)(nb) <= (unsigned long)(av->max_fast)) {
++ fb = &(av->fastbins[(fastbin_index(nb))]);
++ if ( (victim = *fb) != 0) {
++ *fb = victim->fd;
++ check_remalloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++
++ /*
++ If a small request, check regular bin. Since these "smallbins"
++ hold one size each, no searching within bins is necessary.
++ (For a large request, we need to wait until unsorted chunks are
++ processed to find best fit. But for small ones, fits are exact
++ anyway, so we can check now, which is faster.)
++ */
++
++ if (in_smallbin_range(nb)) {
++ idx = smallbin_index(nb);
++ bin = bin_at(av,idx);
++
++ if ( (victim = last(bin)) != bin) {
++ if (victim == 0) /* initialization check */
++ malloc_consolidate(av);
++ else {
++ bck = victim->bk;
++ set_inuse_bit_at_offset(victim, nb);
++ bin->bk = bck;
++ bck->fd = bin;
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ /*
++ If this is a large request, consolidate fastbins before continuing.
++ While it might look excessive to kill all fastbins before
++ even seeing if there is space available, this avoids
++ fragmentation problems normally associated with fastbins.
++ Also, in practice, programs tend to have runs of either small or
++ large requests, but less often mixtures, so consolidation is not
++ invoked all that often in most programs. And the programs that
++ it is called frequently in otherwise tend to fragment.
++ */
++
++ else {
++ idx = largebin_index(nb);
++ if (have_fastchunks(av))
++ malloc_consolidate(av);
++ }
++
++ /*
++ Process recently freed or remaindered chunks, taking one only if
++ it is exact fit, or, if this a small request, the chunk is remainder from
++ the most recent non-exact fit. Place other traversed chunks in
++ bins. Note that this step is the only place in any routine where
++ chunks are placed in bins.
++
++ The outer loop here is needed because we might not realize until
++ near the end of malloc that we should have consolidated, so must
++ do so and retry. This happens at most once, and only when we would
++ otherwise need to expand memory to service a "small" request.
++ */
++
++ for(;;) {
++
++ while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
++ bck = victim->bk;
++ size = chunksize(victim);
++
++ /*
++ If a small request, try to use last remainder if it is the
++ only chunk in unsorted bin. This helps promote locality for
++ runs of consecutive small requests. This is the only
++ exception to best-fit, and applies only when there is
++ no exact fit for a small chunk.
++ */
++
++ if (in_smallbin_range(nb) &&
++ bck == unsorted_chunks(av) &&
++ victim == av->last_remainder &&
++ (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
++
++ /* split and reattach remainder */
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(victim, nb);
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ av->last_remainder = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* remove from unsorted list */
++ unsorted_chunks(av)->bk = bck;
++ bck->fd = unsorted_chunks(av);
++
++ /* Take now instead of binning if exact fit */
++
++ if (size == nb) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* place chunk in bin */
++
++ if (in_smallbin_range(size)) {
++ victim_index = smallbin_index(size);
++ bck = bin_at(av, victim_index);
++ fwd = bck->fd;
++ }
++ else {
++ victim_index = largebin_index(size);
++ bck = bin_at(av, victim_index);
++ fwd = bck->fd;
++
++ /* maintain large bins in sorted order */
++ if (fwd != bck) {
++ size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
++ /* if smaller than smallest, bypass loop below */
++ if ((unsigned long)(size) <= (unsigned long)(bck->bk->size)) {
++ fwd = bck;
++ bck = bck->bk;
++ }
++ else {
++ while ((unsigned long)(size) < (unsigned long)(fwd->size))
++ fwd = fwd->fd;
++ bck = fwd->bk;
++ }
++ }
++ }
++
++ mark_bin(av, victim_index);
++ victim->bk = bck;
++ victim->fd = fwd;
++ fwd->bk = victim;
++ bck->fd = victim;
++ }
++
++ /*
++ If a large request, scan through the chunks of current bin in
++ sorted order to find smallest that fits. This is the only step
++ where an unbounded number of chunks might be scanned without doing
++ anything useful with them. However the lists tend to be short.
++ */
++
++ if (!in_smallbin_range(nb)) {
++ bin = bin_at(av, idx);
++
++ /* skip scan if empty or largest chunk is too small */
++ if ((victim = last(bin)) != bin &&
++ (unsigned long)(first(bin)->size) >= (unsigned long)(nb)) {
++
++ while (((unsigned long)(size = chunksize(victim)) <
++ (unsigned long)(nb)))
++ victim = victim->bk;
++
++ remainder_size = size - nb;
++ unlink(victim, bck, fwd);
++
++ /* Exhaust */
++ if (remainder_size < MINSIZE) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ /* Split */
++ else {
++ remainder = chunk_at_offset(victim, nb);
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ /*
++ Search for a chunk by scanning bins, starting with next largest
++ bin. This search is strictly by best-fit; i.e., the smallest
++ (with ties going to approximately the least recently used) chunk
++ that fits is selected.
++
++ The bitmap avoids needing to check that most blocks are nonempty.
++ The particular case of skipping all bins during warm-up phases
++ when no chunks have been returned yet is faster than it might look.
++ */
++
++ ++idx;
++ bin = bin_at(av,idx);
++ block = idx2block(idx);
++ map = av->binmap[block];
++ bit = idx2bit(idx);
++
++ for (;;) {
++
++ /* Skip rest of block if there are no more set bits in this block. */
++ if (bit > map || bit == 0) {
++ do {
++ if (++block >= BINMAPSIZE) /* out of bins */
++ goto use_top;
++ } while ( (map = av->binmap[block]) == 0);
++
++ bin = bin_at(av, (block << BINMAPSHIFT));
++ bit = 1;
++ }
++
++ /* Advance to bin with set bit. There must be one. */
++ while ((bit & map) == 0) {
++ bin = next_bin(bin);
++ bit <<= 1;
++ assert(bit != 0);
++ }
++
++ /* Inspect the bin. It is likely to be non-empty */
++ victim = last(bin);
++
++ /* If a false alarm (empty bin), clear the bit. */
++ if (victim == bin) {
++ av->binmap[block] = map &= ~bit; /* Write through */
++ bin = next_bin(bin);
++ bit <<= 1;
++ }
++
++ else {
++ size = chunksize(victim);
++
++ /* We know the first chunk in this bin is big enough to use. */
++ assert((unsigned long)(size) >= (unsigned long)(nb));
++
++ remainder_size = size - nb;
++
++ /* unlink */
++ bck = victim->bk;
++ bin->bk = bck;
++ bck->fd = bin;
++
++ /* Exhaust */
++ if (remainder_size < MINSIZE) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* Split */
++ else {
++ remainder = chunk_at_offset(victim, nb);
++
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++ /* advertise as last remainder */
++ if (in_smallbin_range(nb))
++ av->last_remainder = remainder;
++
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ use_top:
++ /*
++ If large enough, split off the chunk bordering the end of memory
++ (held in av->top). Note that this is in accord with the best-fit
++ search rule. In effect, av->top is treated as larger (and thus
++ less well fitting) than any other available chunk since it can
++ be extended to be as large as necessary (up to system
++ limitations).
++
++ We require that av->top always exists (i.e., has size >=
++ MINSIZE) after initialization, so if it would otherwise be
++ exhuasted by current request, it is replenished. (The main
++ reason for ensuring it exists is that we may need MINSIZE space
++ to put in fenceposts in sysmalloc.)
++ */
++
++ victim = av->top;
++ size = chunksize(victim);
++
++ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(victim, nb);
++ av->top = remainder;
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /*
++ If there is space available in fastbins, consolidate and retry,
++ to possibly avoid expanding memory. This can occur only if nb is
++ in smallbin range so we didn't consolidate upon entry.
++ */
++
++ else if (have_fastchunks(av)) {
++ assert(in_smallbin_range(nb));
++ malloc_consolidate(av);
++ idx = smallbin_index(nb); /* restore original bin index */
++ }
++
++ /*
++ Otherwise, relay to handle system-dependent cases
++ */
++ else
++ return sYSMALLOc(nb, av);
++ }
++}
++
++/*
++ ------------------------------ realloc ------------------------------
++*/
++
++
++INLINE
++#if __STD_C
++Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
++#else
++Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T nb; /* padded request size */
++
++ mchunkptr oldp; /* chunk corresponding to oldmem */
++ INTERNAL_SIZE_T oldsize; /* its size */
++
++ mchunkptr newp; /* chunk to return */
++ INTERNAL_SIZE_T newsize; /* its size */
++ Void_t* newmem; /* corresponding user mem */
++
++ mchunkptr next; /* next contiguous chunk after oldp */
++
++ mchunkptr remainder; /* extra space at end of newp */
++ unsigned long remainder_size; /* its size */
++
++ mchunkptr bck; /* misc temp for linking */
++ mchunkptr fwd; /* misc temp for linking */
++
++ unsigned long copysize; /* bytes to copy */
++ unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
++ INTERNAL_SIZE_T* s; /* copy source */
++ INTERNAL_SIZE_T* d; /* copy destination */
++
++
++#ifdef REALLOC_ZERO_BYTES_FREES
++ if (bytes == 0) {
++ fREe(oldmem);
++ return 0;
++ }
++#endif
++
++ /* realloc of null is supposed to be same as malloc */
++ if (oldmem == 0) return mALLOc(bytes);
++
++ checked_request2size(bytes, nb);
++
++ oldp = mem2chunk(oldmem);
++ oldsize = chunksize(oldp);
++
++ check_inuse_chunk(oldp);
++
++ if (!chunk_is_mmapped(oldp)) {
++
++ if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
++ /* already big enough; split below */
++ newp = oldp;
++ newsize = oldsize;
++ }
++
++ else {
++ next = chunk_at_offset(oldp, oldsize);
++
++ /* Try to expand forward into top */
++ if (next == av->top &&
++ (unsigned long)(newsize = oldsize + chunksize(next)) >=
++ (unsigned long)(nb + MINSIZE)) {
++ set_head_size(oldp, nb);
++ av->top = chunk_at_offset(oldp, nb);
++ set_head(av->top, (newsize - nb) | PREV_INUSE);
++ return chunk2mem(oldp);
++ }
++
++ /* Try to expand forward into next chunk; split off remainder below */
++ else if (next != av->top &&
++ !inuse(next) &&
++ (unsigned long)(newsize = oldsize + chunksize(next)) >=
++ (unsigned long)(nb)) {
++ newp = oldp;
++ unlink(next, bck, fwd);
++ }
++
++ /* allocate, copy, free */
++ else {
++ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
++ if (newmem == 0)
++ return 0; /* propagate failure */
++
++ newp = mem2chunk(newmem);
++ newsize = chunksize(newp);
++
++ /*
++ Avoid copy if newp is next chunk after oldp.
++ */
++ if (newp == next) {
++ newsize += oldsize;
++ newp = oldp;
++ }
++ else {
++ /*
++ Unroll copy of <= 36 bytes (72 if 8byte sizes)
++ We know that contents have an odd number of
++ INTERNAL_SIZE_T-sized words; minimally 3.
++ */
++
++ copysize = oldsize - SIZE_SZ;
++ s = (INTERNAL_SIZE_T*)(oldmem);
++ d = (INTERNAL_SIZE_T*)(newmem);
++ ncopies = copysize / sizeof(INTERNAL_SIZE_T);
++ assert(ncopies >= 3);
++
++ if (ncopies > 9)
++ MALLOC_COPY(d, s, copysize);
++
++ else {
++ *(d+0) = *(s+0);
++ *(d+1) = *(s+1);
++ *(d+2) = *(s+2);
++ if (ncopies > 4) {
++ *(d+3) = *(s+3);
++ *(d+4) = *(s+4);
++ if (ncopies > 6) {
++ *(d+5) = *(s+5);
++ *(d+6) = *(s+6);
++ if (ncopies > 8) {
++ *(d+7) = *(s+7);
++ *(d+8) = *(s+8);
++ }
++ }
++ }
++ }
++
++ fREe(oldmem);
++ check_inuse_chunk(newp);
++ return chunk2mem(newp);
++ }
++ }
++ }
++
++ /* If possible, free extra space in old or extended chunk */
++
++ assert((unsigned long)(newsize) >= (unsigned long)(nb));
++
++ remainder_size = newsize - nb;
++
++ if (remainder_size < MINSIZE) { /* not enough extra to split off */
++ set_head_size(newp, newsize);
++ set_inuse_bit_at_offset(newp, newsize);
++ }
++ else { /* split remainder */
++ remainder = chunk_at_offset(newp, nb);
++ set_head_size(newp, nb);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ /* Mark remainder as inuse so free() won't complain */
++ set_inuse_bit_at_offset(remainder, remainder_size);
++ fREe(chunk2mem(remainder));
++ }
++
++ check_inuse_chunk(newp);
++ return chunk2mem(newp);
++ }
++
++ /*
++ Handle mmap cases
++ */
++
++ else {
++#if HAVE_MMAP
++
++#if HAVE_MREMAP
++ INTERNAL_SIZE_T offset = oldp->prev_size;
++ size_t pagemask = av->pagesize - 1;
++ char *cp;
++ unsigned long sum;
++
++ /* Note the extra SIZE_SZ overhead */
++ newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask;
++
++ /* don't need to remap if still within same page */
++ if (oldsize == newsize - offset)
++ return oldmem;
++
++ cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
++
++ if (cp != (char*)MORECORE_FAILURE) {
++
++ newp = (mchunkptr)(cp + offset);
++ set_head(newp, (newsize - offset)|IS_MMAPPED);
++
++ assert(aligned_OK(chunk2mem(newp)));
++ assert((newp->prev_size == offset));
++
++ /* update statistics */
++ sum = av->mmapped_mem += newsize - oldsize;
++ if (sum > (unsigned long)(av->max_mmapped_mem))
++ av->max_mmapped_mem = sum;
++ sum += av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ return chunk2mem(newp);
++ }
++#endif
++
++ /* Note the extra SIZE_SZ overhead. */
++ if ((unsigned long)(oldsize) >= (unsigned long)(nb + SIZE_SZ))
++ newmem = oldmem; /* do nothing */
++ else {
++ /* Must alloc, copy, free. */
++ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
++ if (newmem != 0) {
++ MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
++ fREe(oldmem);
++ }
++ }
++ return newmem;
++
++#else
++ /* If !HAVE_MMAP, but chunk_is_mmapped, user must have overwritten mem */
++ check_malloc_state();
++ MALLOC_FAILURE_ACTION;
++ return 0;
++#endif
++ }
++}
++
++/*
++ ------------------------------ memalign ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* mEMALIGn(size_t alignment, size_t bytes)
++#else
++Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
++#endif
++{
++ INTERNAL_SIZE_T nb; /* padded request size */
++ char* m; /* memory returned by malloc call */
++ mchunkptr p; /* corresponding chunk */
++ char* brk; /* alignment point within p */
++ mchunkptr newp; /* chunk to return */
++ INTERNAL_SIZE_T newsize; /* its size */
++ INTERNAL_SIZE_T leadsize; /* leading space before alignment point */
++ mchunkptr remainder; /* spare room at end to split off */
++ unsigned long remainder_size; /* its size */
++ INTERNAL_SIZE_T size;
++
++ /* If need less alignment than we give anyway, just relay to malloc */
++
++ if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
++
++ /* Otherwise, ensure that it is at least a minimum chunk size */
++
++ if (alignment < MINSIZE) alignment = MINSIZE;
++
++ /* Make sure alignment is power of 2 (in case MINSIZE is not). */
++ if ((alignment & (alignment - 1)) != 0) {
++ size_t a = MALLOC_ALIGNMENT * 2;
++ while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
++ alignment = a;
++ }
++
++ checked_request2size(bytes, nb);
++
++ /*
++ Strategy: find a spot within that chunk that meets the alignment
++ request, and then possibly free the leading and trailing space.
++ */
++
++
++ /* Call malloc with worst case padding to hit alignment. */
++
++ m = (char*)(mALLOc(nb + alignment + MINSIZE));
++
++ if (m == 0) return 0; /* propagate failure */
++
++ p = mem2chunk(m);
++
++ if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
++
++ /*
++ Find an aligned spot inside chunk. Since we need to give back
++ leading space in a chunk of at least MINSIZE, if the first
++ calculation places us at a spot with less than MINSIZE leader,
++ we can move to the next aligned spot -- we've allocated enough
++ total room so that this is always possible.
++ */
++
++ brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) &
++ -((signed long) alignment));
++ if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
++ brk += alignment;
++
++ newp = (mchunkptr)brk;
++ leadsize = brk - (char*)(p);
++ newsize = chunksize(p) - leadsize;
++
++ /* For mmapped chunks, just adjust offset */
++ if (chunk_is_mmapped(p)) {
++ newp->prev_size = p->prev_size + leadsize;
++ set_head(newp, newsize|IS_MMAPPED);
++ return chunk2mem(newp);
++ }
++
++ /* Otherwise, give back leader, use the rest */
++ set_head(newp, newsize | PREV_INUSE);
++ set_inuse_bit_at_offset(newp, newsize);
++ set_head_size(p, leadsize);
++ fREe(chunk2mem(p));
++ p = newp;
++
++ assert (newsize >= nb &&
++ (((unsigned long)(chunk2mem(p))) % alignment) == 0);
++ }
++
++ /* Also give back spare room at the end */
++ if (!chunk_is_mmapped(p)) {
++ size = chunksize(p);
++ if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(p, nb);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_head_size(p, nb);
++ fREe(chunk2mem(remainder));
++ }
++ }
++
++ check_inuse_chunk(p);
++ return chunk2mem(p);
++}
++
++/*
++ ------------------------------ calloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* cALLOc(size_t n_elements, size_t elem_size)
++#else
++Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size;
++#endif
++{
++ mchunkptr p;
++ unsigned long clearsize;
++ unsigned long nclears;
++ INTERNAL_SIZE_T* d;
++
++ Void_t* mem = mALLOc(n_elements * elem_size);
++
++ if (mem != 0) {
++ p = mem2chunk(mem);
++
++ if (!chunk_is_mmapped(p))
++ {
++ /*
++ Unroll clear of <= 36 bytes (72 if 8byte sizes)
++ We know that contents have an odd number of
++ INTERNAL_SIZE_T-sized words; minimally 3.
++ */
++
++ d = (INTERNAL_SIZE_T*)mem;
++ clearsize = chunksize(p) - SIZE_SZ;
++ nclears = clearsize / sizeof(INTERNAL_SIZE_T);
++ assert(nclears >= 3);
++
++ if (nclears > 9)
++ MALLOC_ZERO(d, clearsize);
++
++ else {
++ *(d+0) = 0;
++ *(d+1) = 0;
++ *(d+2) = 0;
++ if (nclears > 4) {
++ *(d+3) = 0;
++ *(d+4) = 0;
++ if (nclears > 6) {
++ *(d+5) = 0;
++ *(d+6) = 0;
++ if (nclears > 8) {
++ *(d+7) = 0;
++ *(d+8) = 0;
++ }
++ }
++ }
++ }
++ }
++#if ! MMAP_CLEARS
++ else
++ {
++ d = (INTERNAL_SIZE_T*)mem;
++ clearsize = chunksize(p) - 2 * SIZE_SZ;
++ MALLOC_ZERO(d, clearsize);
++ }
++#endif
++ }
++ return mem;
++}
++
++/*
++ ------------------------------ cfree ------------------------------
++*/
++
++INLINE
++#if __STD_C
++void cFREe(Void_t *mem)
++#else
++void cFREe(mem) Void_t *mem;
++#endif
++{
++ fREe(mem);
++}
++
++/*
++ ------------------------------ ialloc ------------------------------
++ ialloc 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
++*/
++
++
++INLINE
++#if __STD_C
++static Void_t** iALLOc(size_t n_elements,
++ size_t* sizes,
++ int opts,
++ Void_t* chunks[])
++#else
++static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];
++#endif
++{
++ mstate av = get_malloc_state();
++ INTERNAL_SIZE_T element_size; /* chunksize of each element, if all same */
++ INTERNAL_SIZE_T contents_size; /* total size of elements */
++ INTERNAL_SIZE_T array_size; /* request size of pointer array */
++ Void_t* mem; /* malloced aggregate space */
++ mchunkptr p; /* corresponding chunk */
++ INTERNAL_SIZE_T remainder_size; /* remaining bytes while splitting */
++ Void_t** marray; /* either "chunks" or malloced ptr array */
++ mchunkptr array_chunk; /* chunk for malloced ptr array */
++ int mmx; /* to disable mmap */
++ INTERNAL_SIZE_T size;
++ size_t i;
++
++ /* Ensure initialization/consolidation */
++ if (have_fastchunks(av)) malloc_consolidate(av);
++
++ /* 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_t**) mALLOc(0);
++ marray = 0;
++ array_size = request2size(n_elements * (sizeof(Void_t*)));
++ }
++
++ /* 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]);
++ }
++
++ /* subtract out alignment bytes from total to minimize overallocation */
++ size = contents_size + array_size - MALLOC_ALIGN_MASK;
++
++ /*
++ Allocate the aggregate chunk.
++ But first disable mmap so malloc won't use it, since
++ we would not be able to later free/realloc space internal
++ to a segregated mmap region.
++ */
++ mmx = av->n_mmaps_max; /* disable mmap */
++ av->n_mmaps_max = 0;
++ mem = mALLOc(size);
++ av->n_mmaps_max = mmx; /* reset mmap */
++ if (mem == 0)
++ return 0;
++
++ p = mem2chunk(mem);
++ assert(!chunk_is_mmapped(p));
++ remainder_size = chunksize(p);
++
++ if (opts & 0x2) { /* optionally clear the elements */
++ MALLOC_ZERO(mem, remainder_size - SIZE_SZ - array_size);
++ }
++
++ /* If not provided, allocate the pointer array as final part of chunk */
++ if (marray == 0) {
++ array_chunk = chunk_at_offset(p, contents_size);
++ marray = (Void_t**) (chunk2mem(array_chunk));
++ set_head(array_chunk, (remainder_size - contents_size) | PREV_INUSE);
++ 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_head(p, size | PREV_INUSE);
++ p = chunk_at_offset(p, size);
++ }
++ else { /* the final element absorbs any overallocation slop */
++ set_head(p, remainder_size | PREV_INUSE);
++ break;
++ }
++ }
++
++#ifdef 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(mem2chunk(marray));
++ }
++
++ for (i = 0; i != n_elements; ++i)
++ check_inuse_chunk(mem2chunk(marray[i]));
++#endif
++
++ return marray;
++}
++
++
++/*
++ ------------------------- independent_calloc -------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])
++#else
++Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];
++#endif
++{
++ size_t sz = elem_size; /* serves as 1-element array */
++ /* opts arg of 3 means all elements are same size, and should be cleared */
++ return iALLOc(n_elements, &sz, 3, chunks);
++}
++
++/*
++ ------------------------- independent_comalloc -------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])
++#else
++Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];
++#endif
++{
++ return iALLOc(n_elements, sizes, 0, chunks);
++}
++
++
++/*
++ ------------------------------ valloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* vALLOc(size_t bytes)
++#else
++Void_t* vALLOc(bytes) size_t bytes;
++#endif
++{
++ /* Ensure initialization/consolidation */
++ mstate av = get_malloc_state();
++ if (have_fastchunks(av)) malloc_consolidate(av);
++ return mEMALIGn(av->pagesize, bytes);
++}
++
++/*
++ ------------------------------ pvalloc ------------------------------
++*/
++
++
++#if __STD_C
++Void_t* pVALLOc(size_t bytes)
++#else
++Void_t* pVALLOc(bytes) size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++ size_t pagesz;
++
++ /* Ensure initialization/consolidation */
++ if (have_fastchunks(av)) malloc_consolidate(av);
++ pagesz = av->pagesize;
++ return mEMALIGn(pagesz, (bytes + pagesz - 1) & ~(pagesz - 1));
++}
++
++
++/*
++ ------------------------------ malloc_trim ------------------------------
++*/
++
++INLINE
++#if __STD_C
++int mTRIm(size_t pad)
++#else
++int mTRIm(pad) size_t pad;
++#endif
++{
++ mstate av = get_malloc_state();
++ /* Ensure initialization/consolidation */
++ malloc_consolidate(av);
++
++#ifndef MORECORE_CANNOT_TRIM
++ return sYSTRIm(pad, av);
++#else
++ return 0;
++#endif
++}
++
++
++/*
++ ------------------------- malloc_usable_size -------------------------
++*/
++
++INLINE
++#if __STD_C
++size_t mUSABLe(Void_t* mem)
++#else
++size_t mUSABLe(mem) Void_t* mem;
++#endif
++{
++ mchunkptr p;
++ if (mem != 0) {
++ p = mem2chunk(mem);
++ if (chunk_is_mmapped(p))
++ return chunksize(p) - 2*SIZE_SZ;
++ else if (inuse(p))
++ return chunksize(p) - SIZE_SZ;
++ }
++ return 0;
++}
++
++/*
++ ------------------------------ mallinfo ------------------------------
++*/
++
++struct mallinfo mALLINFo()
++{
++ mstate av = get_malloc_state();
++ struct mallinfo mi;
++ unsigned int i;
++ mbinptr b;
++ mchunkptr p;
++ INTERNAL_SIZE_T avail;
++ INTERNAL_SIZE_T fastavail;
++ int nblocks;
++ int nfastblocks;
++
++ /* Ensure initialization */
++ if (av->top == 0) malloc_consolidate(av);
++
++ check_malloc_state();
++
++ /* Account for top */
++ avail = chunksize(av->top);
++ nblocks = 1; /* top always exists */
++
++ /* traverse fastbins */
++ nfastblocks = 0;
++ fastavail = 0;
++
++ for (i = 0; i < NFASTBINS; ++i) {
++ for (p = av->fastbins[i]; p != 0; p = p->fd) {
++ ++nfastblocks;
++ fastavail += chunksize(p);
++ }
++ }
++
++ avail += fastavail;
++
++ /* traverse regular bins */
++ for (i = 1; i < NBINS; ++i) {
++ b = bin_at(av, i);
++ for (p = last(b); p != b; p = p->bk) {
++ ++nblocks;
++ avail += chunksize(p);
++ }
++ }
++
++ mi.smblks = nfastblocks;
++ mi.ordblks = nblocks;
++ mi.fordblks = avail;
++ mi.uordblks = av->sbrked_mem - avail;
++ mi.arena = av->sbrked_mem;
++ mi.hblks = av->n_mmaps;
++ mi.hblkhd = av->mmapped_mem;
++ mi.fsmblks = fastavail;
++ mi.keepcost = chunksize(av->top);
++ mi.usmblks = av->max_total_mem;
++ return mi;
++}
++
++/*
++ ------------------------------ malloc_stats ------------------------------
++*/
++
++void mSTATs()
++{
++ struct mallinfo mi = mALLINFo();
++
++#ifdef WIN32
++ {
++ unsigned long free, reserved, committed;
++ vminfo (&free, &reserved, &committed);
++ fprintf(stderr, "free bytes = %10lu\n",
++ free);
++ fprintf(stderr, "reserved bytes = %10lu\n",
++ reserved);
++ fprintf(stderr, "committed bytes = %10lu\n",
++ committed);
++ }
++#endif
++
++
++ fprintf(stderr, "max system bytes = %10lu\n",
++ (unsigned long)(mi.usmblks));
++ fprintf(stderr, "system bytes = %10lu\n",
++ (unsigned long)(mi.arena + mi.hblkhd));
++ fprintf(stderr, "in use bytes = %10lu\n",
++ (unsigned long)(mi.uordblks + mi.hblkhd));
++
++
++#ifdef WIN32
++ {
++ unsigned long kernel, user;
++ if (cpuinfo (TRUE, &kernel, &user)) {
++ fprintf(stderr, "kernel ms = %10lu\n",
++ kernel);
++ fprintf(stderr, "user ms = %10lu\n",
++ user);
++ }
++ }
++#endif
++}
++
++
++/*
++ ------------------------------ mallopt ------------------------------
++*/
++
++INLINE
++#if __STD_C
++int mALLOPt(int param_number, int value)
++#else
++int mALLOPt(param_number, value) int param_number; int value;
++#endif
++{
++ mstate av = get_malloc_state();
++ /* Ensure initialization/consolidation */
++ malloc_consolidate(av);
++
++ switch(param_number) {
++ case M_MXFAST:
++ if (value >= 0 && value <= MAX_FAST_SIZE) {
++ set_max_fast(av, value);
++ return 1;
++ }
++ else
++ return 0;
++
++ case M_TRIM_THRESHOLD:
++ av->trim_threshold = value;
++ return 1;
++
++ case M_TOP_PAD:
++ av->top_pad = value;
++ return 1;
++
++ case M_MMAP_THRESHOLD:
++ av->mmap_threshold = value;
++ return 1;
++
++ case M_MMAP_MAX:
++#if !HAVE_MMAP
++ if (value != 0)
++ return 0;
++#endif
++ av->n_mmaps_max = value;
++ return 1;
++
++ default:
++ return 0;
++ }
++}
++
++
++/*
++ -------------------- Alternative MORECORE functions --------------------
++*/
++
++
++/*
++ General Requirements for MORECORE.
++
++ The MORECORE function must have the following properties:
++
++ If MORECORE_CONTIGUOUS is false:
++
++ * MORECORE must allocate in multiples of pagesize. It will
++ only be called with arguments that are multiples of pagesize.
++
++ * MORECORE(0) must return an address that is at least
++ MALLOC_ALIGNMENT aligned. (Page-aligning always suffices.)
++
++ else (i.e. If MORECORE_CONTIGUOUS is true):
++
++ * Consecutive calls to MORECORE with positive arguments
++ return increasing addresses, indicating that space has been
++ contiguously extended.
++
++ * MORECORE need not allocate in multiples of pagesize.
++ Calls to MORECORE need not have args of multiples of pagesize.
++
++ * MORECORE need not page-align.
++
++ In either case:
++
++ * MORECORE may allocate more memory than requested. (Or even less,
++ but this will generally result in a malloc failure.)
++
++ * MORECORE must not allocate memory when given argument zero, but
++ instead return one past the end address of memory from previous
++ nonzero call. This malloc does NOT call MORECORE(0)
++ until at least one call with positive arguments is made, so
++ the initial value returned is not important.
++
++ * Even though consecutive calls to MORECORE need not return contiguous
++ addresses, it must be OK for malloc'ed chunks to span multiple
++ regions in those cases where they do happen to be contiguous.
++
++ * MORECORE need not handle negative arguments -- it may instead
++ just return MORECORE_FAILURE when given negative arguments.
++ Negative arguments are always multiples of pagesize. MORECORE
++ must not misinterpret negative args as large positive unsigned
++ args. You can suppress all such calls from even occurring by defining
++ MORECORE_CANNOT_TRIM,
++
++ There is some variation across systems about the type of the
++ argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
++ actually be size_t, because sbrk supports negative args, so it is
++ normally the signed type of the same width as size_t (sometimes
++ declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much
++ matter though. Internally, we use "long" as arguments, which should
++ work across all reasonable possibilities.
++
++ Additionally, if MORECORE ever returns failure for a positive
++ 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 map noncontiguous space.
++
++ If you'd like mmap to ALWAYS be used, you can define MORECORE to be
++ a function that always returns MORECORE_FAILURE.
++
++ If you are using this malloc with something other than sbrk (or its
++ emulation) to supply memory regions, you probably want to set
++ MORECORE_CONTIGUOUS as false. As an example, here is a custom
++ allocator kindly contributed for pre-OSX macOS. It uses virtually
++ but not necessarily physically contiguous non-paged memory (locked
++ in, present and won't get swapped out). You can use it by
++ uncommenting this section, adding some #includes, and setting up the
++ appropriate defines above:
++
++ #define MORECORE osMoreCore
++ #define MORECORE_CONTIGUOUS 0
++
++ There is also a shutdown routine that should somehow be called for
++ cleanup upon program exit.
++
++ #define MAX_POOL_ENTRIES 100
++ #define MINIMUM_MORECORE_SIZE (64 * 1024)
++ static int next_os_pool;
++ void *our_os_pools[MAX_POOL_ENTRIES];
++
++ void *osMoreCore(int size)
++ {
++ void *ptr = 0;
++ static void *sbrk_top = 0;
++
++ if (size > 0)
++ {
++ if (size < MINIMUM_MORECORE_SIZE)
++ size = MINIMUM_MORECORE_SIZE;
++ if (CurrentExecutionLevel() == kTaskLevel)
++ ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
++ if (ptr == 0)
++ {
++ return (void *) MORECORE_FAILURE;
++ }
++ // save ptrs so they can be freed during cleanup
++ our_os_pools[next_os_pool] = ptr;
++ next_os_pool++;
++ ptr = (void *) ((((unsigned long) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
++ sbrk_top = (char *) ptr + size;
++ return ptr;
++ }
++ else if (size < 0)
++ {
++ // we don't currently support shrink behavior
++ return (void *) MORECORE_FAILURE;
++ }
++ else
++ {
++ return sbrk_top;
++ }
++ }
++
++ // cleanup any allocated memory pools
++ // called as last thing before shutting down driver
++
++ void osCleanupMem(void)
++ {
++ void **ptr;
++
++ for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
++ if (*ptr)
++ {
++ PoolDeallocate(*ptr);
++ *ptr = 0;
++ }
++ }
++
++*/
++
++
++/*
++ --------------------------------------------------------------
++
++ Emulation of sbrk for win32.
++ Donated by J. Walter <Walter@GeNeSys-e.de>.
++ For additional information about this code, and malloc on Win32, see
++ http://www.genesys-e.de/jwalter/
++*/
++
++
++#ifdef WIN32
++
++#ifdef _DEBUG
++/* #define TRACE */
++#endif
++
++/* Support for USE_MALLOC_LOCK */
++#ifdef USE_MALLOC_LOCK
++
++/* Wait for spin lock */
++static int slwait (int *sl) {
++ while (InterlockedCompareExchange ((void **) sl, (void *) 1, (void *) 0) != 0)
++ Sleep (0);
++ return 0;
++}
++
++/* Release spin lock */
++static int slrelease (int *sl) {
++ InterlockedExchange (sl, 0);
++ return 0;
++}
++
++#ifdef NEEDED
++/* Spin lock for emulation code */
++static int g_sl;
++#endif
++
++#endif /* USE_MALLOC_LOCK */
++
++/* getpagesize for windows */
++static long getpagesize (void) {
++ static long g_pagesize = 0;
++ if (! g_pagesize) {
++ SYSTEM_INFO system_info;
++ GetSystemInfo (&system_info);
++ g_pagesize = system_info.dwPageSize;
++ }
++ return g_pagesize;
++}
++static long getregionsize (void) {
++ static long g_regionsize = 0;
++ if (! g_regionsize) {
++ SYSTEM_INFO system_info;
++ GetSystemInfo (&system_info);
++ g_regionsize = system_info.dwAllocationGranularity;
++ }
++ return g_regionsize;
++}
++
++/* A region list entry */
++typedef struct _region_list_entry {
++ void *top_allocated;
++ void *top_committed;
++ void *top_reserved;
++ long reserve_size;
++ struct _region_list_entry *previous;
++} region_list_entry;
++
++/* Allocate and link a region entry in the region list */
++static int region_list_append (region_list_entry **last, void *base_reserved, long reserve_size) {
++ region_list_entry *next = HeapAlloc (GetProcessHeap (), 0, sizeof (region_list_entry));
++ if (! next)
++ return FALSE;
++ next->top_allocated = (char *) base_reserved;
++ next->top_committed = (char *) base_reserved;
++ next->top_reserved = (char *) base_reserved + reserve_size;
++ next->reserve_size = reserve_size;
++ next->previous = *last;
++ *last = next;
++ return TRUE;
++}
++/* Free and unlink the last region entry from the region list */
++static int region_list_remove (region_list_entry **last) {
++ region_list_entry *previous = (*last)->previous;
++ if (! HeapFree (GetProcessHeap (), sizeof (region_list_entry), *last))
++ return FALSE;
++ *last = previous;
++ return TRUE;
++}
++
++#define CEIL(size,to) (((size)+(to)-1)&~((to)-1))
++#define FLOOR(size,to) ((size)&~((to)-1))
++
++#define SBRK_SCALE 0
++/* #define SBRK_SCALE 1 */
++/* #define SBRK_SCALE 2 */
++/* #define SBRK_SCALE 4 */
++
++/* sbrk for windows */
++static void *sbrk (long size) {
++ static long g_pagesize, g_my_pagesize;
++ static long g_regionsize, g_my_regionsize;
++ static region_list_entry *g_last;
++ void *result = (void *) MORECORE_FAILURE;
++#ifdef TRACE
++ printf ("sbrk %d\n", size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize) {
++ g_pagesize = getpagesize ();
++ g_my_pagesize = g_pagesize << SBRK_SCALE;
++ }
++ if (! g_regionsize) {
++ g_regionsize = getregionsize ();
++ g_my_regionsize = g_regionsize << SBRK_SCALE;
++ }
++ if (! g_last) {
++ if (! region_list_append (&g_last, 0, 0))
++ goto sbrk_exit;
++ }
++ /* Assert invariants */
++ assert (g_last);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
++ g_last->top_allocated <= g_last->top_committed);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
++ g_last->top_committed <= g_last->top_reserved &&
++ (unsigned) g_last->top_committed % g_pagesize == 0);
++ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
++ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
++ /* Allocation requested? */
++ if (size >= 0) {
++ /* Allocation size is the requested size */
++ long allocate_size = size;
++ /* Compute the size to commit */
++ long to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Do we reach the commit limit? */
++ if (to_commit > 0) {
++ /* Round size to commit */
++ long commit_size = CEIL (to_commit, g_my_pagesize);
++ /* Compute the size to reserve */
++ long to_reserve = (char *) g_last->top_committed + commit_size - (char *) g_last->top_reserved;
++ /* Do we reach the reserve limit? */
++ if (to_reserve > 0) {
++ /* Compute the remaining size to commit in the current region */
++ long remaining_commit_size = (char *) g_last->top_reserved - (char *) g_last->top_committed;
++ if (remaining_commit_size > 0) {
++ /* Assert preconditions */
++ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
++ assert (0 < remaining_commit_size && remaining_commit_size % g_pagesize == 0); {
++ /* Commit this */
++ void *base_committed = VirtualAlloc (g_last->top_committed, remaining_commit_size,
++ MEM_COMMIT, PAGE_READWRITE);
++ /* Check returned pointer for consistency */
++ if (base_committed != g_last->top_committed)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", base_committed, remaining_commit_size);
++#endif
++ /* Adjust the regions commit top */
++ g_last->top_committed = (char *) base_committed + remaining_commit_size;
++ }
++ } {
++ /* Now we are going to search and reserve. */
++ int contiguous = -1;
++ int found = FALSE;
++ MEMORY_BASIC_INFORMATION memory_info;
++ void *base_reserved;
++ long reserve_size;
++ do {
++ /* Assume contiguous memory */
++ contiguous = TRUE;
++ /* Round size to reserve */
++ reserve_size = CEIL (to_reserve, g_my_regionsize);
++ /* Start with the current region's top */
++ memory_info.BaseAddress = g_last->top_reserved;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
++ /* Assert postconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Query %p %d %s\n", memory_info.BaseAddress, memory_info.RegionSize,
++ memory_info.State == MEM_FREE ? "FREE":
++ (memory_info.State == MEM_RESERVE ? "RESERVED":
++ (memory_info.State == MEM_COMMIT ? "COMMITTED": "?")));
++#endif
++ /* Region is free, well aligned and big enough: we are done */
++ if (memory_info.State == MEM_FREE &&
++ (unsigned) memory_info.BaseAddress % g_regionsize == 0 &&
++ memory_info.RegionSize >= (unsigned) reserve_size) {
++ found = TRUE;
++ break;
++ }
++ /* From now on we can't get contiguous memory! */
++ contiguous = FALSE;
++ /* Recompute size to reserve */
++ reserve_size = CEIL (allocate_size, g_my_regionsize);
++ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ }
++ /* Search failed? */
++ if (! found)
++ goto sbrk_exit;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_regionsize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ /* Try to reserve this */
++ base_reserved = VirtualAlloc (memory_info.BaseAddress, reserve_size,
++ MEM_RESERVE, PAGE_NOACCESS);
++ if (! base_reserved) {
++ int rc = GetLastError ();
++ if (rc != ERROR_INVALID_ADDRESS)
++ goto sbrk_exit;
++ }
++ /* A null pointer signals (hopefully) a race condition with another thread. */
++ /* In this case, we try again. */
++ } while (! base_reserved);
++ /* Check returned pointer for consistency */
++ if (memory_info.BaseAddress && base_reserved != memory_info.BaseAddress)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_reserved % g_regionsize == 0);
++#ifdef TRACE
++ printf ("Reserve %p %d\n", base_reserved, reserve_size);
++#endif
++ /* Did we get contiguous memory? */
++ if (contiguous) {
++ long start_size = (char *) g_last->top_committed - (char *) g_last->top_allocated;
++ /* Adjust allocation size */
++ allocate_size -= start_size;
++ /* Adjust the regions allocation top */
++ g_last->top_allocated = g_last->top_committed;
++ /* Recompute the size to commit */
++ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Round size to commit */
++ commit_size = CEIL (to_commit, g_my_pagesize);
++ }
++ /* Append the new region to the list */
++ if (! region_list_append (&g_last, base_reserved, reserve_size))
++ goto sbrk_exit;
++ /* Didn't we get contiguous memory? */
++ if (! contiguous) {
++ /* Recompute the size to commit */
++ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Round size to commit */
++ commit_size = CEIL (to_commit, g_my_pagesize);
++ }
++ }
++ }
++ /* Assert preconditions */
++ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
++ assert (0 < commit_size && commit_size % g_pagesize == 0); {
++ /* Commit this */
++ void *base_committed = VirtualAlloc (g_last->top_committed, commit_size,
++ MEM_COMMIT, PAGE_READWRITE);
++ /* Check returned pointer for consistency */
++ if (base_committed != g_last->top_committed)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", base_committed, commit_size);
++#endif
++ /* Adjust the regions commit top */
++ g_last->top_committed = (char *) base_committed + commit_size;
++ }
++ }
++ /* Adjust the regions allocation top */
++ g_last->top_allocated = (char *) g_last->top_allocated + allocate_size;
++ result = (char *) g_last->top_allocated - size;
++ /* Deallocation requested? */
++ } else if (size < 0) {
++ long deallocate_size = - size;
++ /* As long as we have a region to release */
++ while ((char *) g_last->top_allocated - deallocate_size < (char *) g_last->top_reserved - g_last->reserve_size) {
++ /* Get the size to release */
++ long release_size = g_last->reserve_size;
++ /* Get the base address */
++ void *base_reserved = (char *) g_last->top_reserved - release_size;
++ /* Assert preconditions */
++ assert ((unsigned) base_reserved % g_regionsize == 0);
++ assert (0 < release_size && release_size % g_regionsize == 0); {
++ /* Release this */
++ int rc = VirtualFree (base_reserved, 0,
++ MEM_RELEASE);
++ /* Check returned code for consistency */
++ if (! rc)
++ goto sbrk_exit;
++#ifdef TRACE
++ printf ("Release %p %d\n", base_reserved, release_size);
++#endif
++ }
++ /* Adjust deallocation size */
++ deallocate_size -= (char *) g_last->top_allocated - (char *) base_reserved;
++ /* Remove the old region from the list */
++ if (! region_list_remove (&g_last))
++ goto sbrk_exit;
++ } {
++ /* Compute the size to decommit */
++ long to_decommit = (char *) g_last->top_committed - ((char *) g_last->top_allocated - deallocate_size);
++ if (to_decommit >= g_my_pagesize) {
++ /* Compute the size to decommit */
++ long decommit_size = FLOOR (to_decommit, g_my_pagesize);
++ /* Compute the base address */
++ void *base_committed = (char *) g_last->top_committed - decommit_size;
++ /* Assert preconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++ assert (0 < decommit_size && decommit_size % g_pagesize == 0); {
++ /* Decommit this */
++ int rc = VirtualFree ((char *) base_committed, decommit_size,
++ MEM_DECOMMIT);
++ /* Check returned code for consistency */
++ if (! rc)
++ goto sbrk_exit;
++#ifdef TRACE
++ printf ("Decommit %p %d\n", base_committed, decommit_size);
++#endif
++ }
++ /* Adjust deallocation size and regions commit and allocate top */
++ deallocate_size -= (char *) g_last->top_allocated - (char *) base_committed;
++ g_last->top_committed = base_committed;
++ g_last->top_allocated = base_committed;
++ }
++ }
++ /* Adjust regions allocate top */
++ g_last->top_allocated = (char *) g_last->top_allocated - deallocate_size;
++ /* Check for underflow */
++ if ((char *) g_last->top_reserved - g_last->reserve_size > (char *) g_last->top_allocated ||
++ g_last->top_allocated > g_last->top_committed) {
++ /* Adjust regions allocate top */
++ g_last->top_allocated = (char *) g_last->top_reserved - g_last->reserve_size;
++ goto sbrk_exit;
++ }
++ result = g_last->top_allocated;
++ }
++ /* Assert invariants */
++ assert (g_last);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
++ g_last->top_allocated <= g_last->top_committed);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
++ g_last->top_committed <= g_last->top_reserved &&
++ (unsigned) g_last->top_committed % g_pagesize == 0);
++ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
++ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
++
++sbrk_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return result;
++}
++
++/* mmap for windows */
++static void *mmap (void *ptr, long size, long prot, long type, long handle, long arg) {
++ static long g_pagesize;
++ static long g_regionsize;
++#ifdef TRACE
++ printf ("mmap %d\n", size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize)
++ g_pagesize = getpagesize ();
++ if (! g_regionsize)
++ g_regionsize = getregionsize ();
++ /* Assert preconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++ assert (size % g_pagesize == 0);
++ /* Allocate this */
++ ptr = VirtualAlloc (ptr, size,
++ MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE);
++ if (! ptr) {
++ ptr = (void *) MORECORE_FAILURE;
++ goto mmap_exit;
++ }
++ /* Assert postconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", ptr, size);
++#endif
++mmap_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return ptr;
++}
++
++/* munmap for windows */
++static long munmap (void *ptr, long size) {
++ static long g_pagesize;
++ static long g_regionsize;
++ int rc = MUNMAP_FAILURE;
++#ifdef TRACE
++ printf ("munmap %p %d\n", ptr, size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize)
++ g_pagesize = getpagesize ();
++ if (! g_regionsize)
++ g_regionsize = getregionsize ();
++ /* Assert preconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++ assert (size % g_pagesize == 0);
++ /* Free this */
++ if (! VirtualFree (ptr, 0,
++ MEM_RELEASE))
++ goto munmap_exit;
++ rc = 0;
++#ifdef TRACE
++ printf ("Release %p %d\n", ptr, size);
++#endif
++munmap_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return rc;
++}
++
++static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed) {
++ MEMORY_BASIC_INFORMATION memory_info;
++ memory_info.BaseAddress = 0;
++ *free = *reserved = *committed = 0;
++ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
++ switch (memory_info.State) {
++ case MEM_FREE:
++ *free += memory_info.RegionSize;
++ break;
++ case MEM_RESERVE:
++ *reserved += memory_info.RegionSize;
++ break;
++ case MEM_COMMIT:
++ *committed += memory_info.RegionSize;
++ break;
++ }
++ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
++ }
++}
++
++static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user) {
++ if (whole) {
++ __int64 creation64, exit64, kernel64, user64;
++ int rc = GetProcessTimes (GetCurrentProcess (),
++ (FILETIME *) &creation64,
++ (FILETIME *) &exit64,
++ (FILETIME *) &kernel64,
++ (FILETIME *) &user64);
++ if (! rc) {
++ *kernel = 0;
++ *user = 0;
++ return FALSE;
++ }
++ *kernel = (unsigned long) (kernel64 / 10000);
++ *user = (unsigned long) (user64 / 10000);
++ return TRUE;
++ } else {
++ __int64 creation64, exit64, kernel64, user64;
++ int rc = GetThreadTimes (GetCurrentThread (),
++ (FILETIME *) &creation64,
++ (FILETIME *) &exit64,
++ (FILETIME *) &kernel64,
++ (FILETIME *) &user64);
++ if (! rc) {
++ *kernel = 0;
++ *user = 0;
++ return FALSE;
++ }
++ *kernel = (unsigned long) (kernel64 / 10000);
++ *user = (unsigned long) (user64 / 10000);
++ return TRUE;
++ }
++}
++
++#endif /* WIN32 */
++
++/* ------------------------------------------------------------
++History:
++
++ V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
++ * Introduce independent_comalloc and independent_calloc.
++ Thanks to Michael Pachos for motivation and help.
++ * Make optional .h file available
++ * Allow > 2GB requests on 32bit systems.
++ * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>.
++ Thanks also to Andreas Mueller <a.mueller at paradatec.de>,
++ and Anonymous.
++ * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for
++ helping test this.)
++ * memalign: check alignment arg
++ * realloc: don't try to shift chunks backwards, since this
++ leads to more fragmentation in some programs and doesn't
++ seem to help in any others.
++ * Collect all cases in malloc requiring system memory into sYSMALLOc
++ * Use mmap as backup to sbrk
++ * Place all internal state in malloc_state
++ * Introduce fastbins (although similar to 2.5.1)
++ * Many minor tunings and cosmetic improvements
++ * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK
++ * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS
++ Thanks to Tony E. Bennett <tbennett@nvidia.com> and others.
++ * Include errno.h to support default failure action.
++
++ V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee)
++ * return null for negative arguments
++ * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com>
++ * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h'
++ (e.g. WIN32 platforms)
++ * Cleanup header file inclusion for WIN32 platforms
++ * Cleanup code to avoid Microsoft Visual C++ compiler complaints
++ * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing
++ memory allocation routines
++ * Set 'malloc_getpagesize' for WIN32 platforms (needs more work)
++ * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to
++ usage of 'assert' in non-WIN32 code
++ * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to
++ avoid infinite loop
++ * Always call 'fREe()' rather than 'free()'
++
++ V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee)
++ * Fixed ordering problem with boundary-stamping
++
++ V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
++ * Added pvalloc, as recommended by H.J. Liu
++ * Added 64bit pointer support mainly from Wolfram Gloger
++ * Added anonymously donated WIN32 sbrk emulation
++ * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
++ * malloc_extend_top: fix mask error that caused wastage after
++ foreign sbrks
++ * Add linux mremap support code from HJ Liu
++
++ V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
++ * Integrated most documentation with the code.
++ * Add support for mmap, with help from
++ Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
++ * Use last_remainder in more cases.
++ * Pack bins using idea from colin@nyx10.cs.du.edu
++ * Use ordered bins instead of best-fit threshold
++ * Eliminate block-local decls to simplify tracing and debugging.
++ * Support another case of realloc via move into top
++ * Fix error occurring when initial sbrk_base not word-aligned.
++ * Rely on page size for units instead of SBRK_UNIT to
++ avoid surprises about sbrk alignment conventions.
++ * Add mallinfo, mallopt. Thanks to Raymond Nijssen
++ (raymond@es.ele.tue.nl) for the suggestion.
++ * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
++ * More precautions for cases where other routines call sbrk,
++ courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
++ * Added macros etc., allowing use in linux libc from
++ H.J. Lu (hjl@gnu.ai.mit.edu)
++ * Inverted this history list
++
++ V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
++ * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
++ * Removed all preallocation code since under current scheme
++ the work required to undo bad preallocations exceeds
++ the work saved in good cases for most test programs.
++ * No longer use return list or unconsolidated bins since
++ no scheme using them consistently outperforms those that don't
++ given above changes.
++ * Use best fit for very large chunks to prevent some worst-cases.
++ * Added some support for debugging
++
++ V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
++ * Removed footers when chunks are in use. Thanks to
++ Paul Wilson (wilson@cs.texas.edu) for the suggestion.
++
++ V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
++ * Added malloc_trim, with help from Wolfram Gloger
++ (wmglo@Dent.MED.Uni-Muenchen.DE).
++
++ V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
++
++ V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
++ * realloc: try to expand in both directions
++ * malloc: swap order of clean-bin strategy;
++ * realloc: only conditionally expand backwards
++ * Try not to scavenge used bins
++ * Use bin counts as a guide to preallocation
++ * Occasionally bin return list chunks in first scan
++ * Add a few optimizations from colin@nyx10.cs.du.edu
++
++ V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
++ * faster bin computation & slightly different binning
++ * merged all consolidations to one part of malloc proper
++ (eliminating old malloc_find_space & malloc_clean_bin)
++ * Scan 2 returns chunks (not just 1)
++ * Propagate failure in realloc if malloc returns 0
++ * Add stuff to allow compilation on non-ANSI compilers
++ from kpv@research.att.com
++
++ V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
++ * removed potential for odd address access in prev_chunk
++ * removed dependency on getpagesize.h
++ * misc cosmetics and a bit more internal documentation
++ * anticosmetics: mangled names in macros to evade debugger strangeness
++ * tested on sparc, hp-700, dec-mips, rs6000
++ with gcc & native cc (hp, dec only) allowing
++ Detlefs & Zorn comparison study (in SIGPLAN Notices.)
++
++ Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
++ * Based loosely on libg++-1.2X malloc. (It retains some of the overall
++ structure of old version, but most details differ.)
++
++*/
++
++#ifdef USE_PUBLIC_MALLOC_WRAPPERS
++
++#ifndef KDE_MALLOC_FULL
++
++#ifdef KDE_MALLOC_GLIBC
++#include "glibc.h"
++#else
++/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/
++#error Unknown libc
++#endif
++
++/* 0 - uninitialized
++ 1 - this malloc
++ 2 - standard libc malloc*/
++extern char* getenv(const char*);
++static int malloc_type = 0;
++static void init_malloc_type(void)
++ {
++ const char* const env = getenv( "KDE_MALLOC" );
++ if( env == NULL )
++ malloc_type = 1;
++ else if( env[ 0 ] == '0' || env[ 0 ] == 'n' || env[ 0 ] == 'N' )
++ malloc_type = 2;
++ else
++ malloc_type = 1;
++ }
++
++#endif
++
++Void_t* public_mALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_malloc( bytes );
++ init_malloc_type();
++ return public_mALLOc( bytes );
++#endif
++}
++
++void public_fREe(Void_t* m) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ fREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++#ifndef KDE_MALLOC_FULL
++ return;
++ }
++ if( malloc_type == 2 )
++ {
++ libc_free( m );
++ return;
++ }
++ init_malloc_type();
++ public_fREe( m );
++#endif
++}
++
++Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = rEALLOc(m, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_realloc( m, bytes );
++ init_malloc_type();
++ return public_rEALLOc( m, bytes );
++#endif
++}
++
++Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mEMALIGn(alignment, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_memalign( alignment, bytes );
++ init_malloc_type();
++ return public_mEMALIGn( alignment, bytes );
++#endif
++}
++
++Void_t* public_vALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = vALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_valloc( bytes );
++ init_malloc_type();
++ return public_vALLOc( bytes );
++#endif
++}
++
++Void_t* public_pVALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = pVALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_pvalloc( bytes );
++ init_malloc_type();
++ return public_pVALLOc( bytes );
++#endif
++}
++
++Void_t* public_cALLOc(size_t n, size_t elem_size) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = cALLOc(n, elem_size);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_calloc( n, elem_size );
++ init_malloc_type();
++ return public_cALLOc( n, elem_size );
++#endif
++}
++
++void public_cFREe(Void_t* m) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ cFREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++#ifndef KDE_MALLOC_FULL
++ return;
++ }
++ if( malloc_type == 2 )
++ {
++ libc_cfree( m );
++ return;
++ }
++ init_malloc_type();
++ public_cFREe( m );
++#endif
++}
++
++struct mallinfo public_mALLINFo() {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ struct mallinfo m;
++ if (MALLOC_PREACTION != 0) {
++ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
++ return nm;
++ }
++ m = mALLINFo();
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_mallinfo();
++ init_malloc_type();
++ return public_mALLINFo();
++#endif
++}
++
++int public_mALLOPt(int p, int v) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mALLOPt(p, v);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_mallopt( p, v );
++ init_malloc_type();
++ return public_mALLOPt( p, v );
++#endif
++}
++#endif
++
++int
++posix_memalign (void **memptr, size_t alignment, size_t size)
++{
++ void *mem;
++
++ /* Test whether the SIZE argument is valid. It must be a power of
++ two multiple of sizeof (void *). */
++ if (size % sizeof (void *) != 0 || (size & (size - 1)) != 0)
++ return EINVAL;
++
++ mem = memalign (alignment, size);
++
++ if (mem != NULL) {
++ *memptr = mem;
++ return 0;
++ }
++
++ return ENOMEM;
++}
++
++#else
++/* Some linkers (Solaris 2.6) don't like empty archives, but for
++ easier Makefile's we want to link against libklmalloc.la every time,
++ so simply make it non-empty. */
++void kde_malloc_dummy_function ()
++{
++ return;
++}
++#endif
+diff -Nupr a/src/corelib/arch/avr32/qatomic.cpp b/src/corelib/arch/avr32/qatomic.cpp
+--- a/src/corelib/arch/avr32/qatomic.cpp 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/qatomic.cpp 2006-07-26 11:02:43.000000000 +0200
+@@ -0,0 +1,24 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#include "QtCore/qatomic_avr32.h"
++
++Q_CORE_EXPORT long q_atomic_lock = 0;
+diff -Nupr a/src/corelib/arch/qatomic_arch.h b/src/corelib/arch/qatomic_arch.h
+--- a/src/corelib/arch/qatomic_arch.h 2006-06-30 09:49:44.000000000 +0200
++++ b/src/corelib/arch/qatomic_arch.h 2006-07-27 12:42:58.000000000 +0200
+@@ -47,6 +47,8 @@ QT_BEGIN_HEADER
+ # include "QtCore/qatomic_alpha.h"
+ #elif defined(QT_ARCH_ARM)
+ # include "QtCore/qatomic_arm.h"
++#elif defined(QT_ARCH_AVR32)
++# include "QtCore/qatomic_avr32.h"
+ #elif defined(QT_ARCH_BOUNDSCHECKER)
+ # include "QtCore/qatomic_boundschecker.h"
+ #elif defined(QT_ARCH_GENERIC)
+diff -Nupr a/src/corelib/arch/qatomic_avr32.h b/src/corelib/arch/qatomic_avr32.h
+--- a/src/corelib/arch/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/qatomic_avr32.h 2006-07-28 10:30:08.000000000 +0200
+@@ -0,0 +1,132 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#ifndef AVR32_QATOMIC_H
++#define AVR32_QATOMIC_H
++
++#include <QtCore/qglobal.h>
++
++QT_BEGIN_HEADER
++
++extern Q_CORE_EXPORT long q_atomic_lock;
++
++inline long q_atomic_swp(volatile long *ptr, long newval)
++{
++ register int ret;
++ asm volatile("xchg %0,%1,%2"
++ : "=&r"(ret)
++ : "r"(ptr), "r"(newval)
++ : "memory", "cc");
++ return ret;
++}
++
++inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
++{
++ int ret = 0;
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0);
++ if (*ptr == expected) {
++ *ptr = newval;
++ ret = 1;
++ }
++ q_atomic_swp(&q_atomic_lock, 0);
++ return ret;
++}
++
++inline int q_atomic_test_and_set_acquire_int(volatile int *ptr, int expected, int newval)
++{
++ return q_atomic_test_and_set_int(ptr, expected, newval);
++}
++
++inline int q_atomic_test_and_set_release_int(volatile int *ptr, int expected, int newval)
++{
++ return q_atomic_test_and_set_int(ptr, expected, newval);
++}
++
++inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
++{
++ int ret = 0;
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ if (*reinterpret_cast<void * volatile *>(ptr) == expected) {
++ *reinterpret_cast<void * volatile *>(ptr) = newval;
++ ret = 1;
++ }
++ q_atomic_swp(&q_atomic_lock, 0);
++ return ret;
++}
++
++inline int q_atomic_increment(volatile int *ptr)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = originalValue + 1;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue != -1;
++}
++
++inline int q_atomic_decrement(volatile int *ptr)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = originalValue - 1;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue != 1;
++}
++
++inline int q_atomic_set_int(volatile int *ptr, int newval)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = newval;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue;
++}
++
++inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ void *originalValue = *reinterpret_cast<void * volatile *>(ptr);
++ *reinterpret_cast<void * volatile *>(ptr) = newval;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue;
++}
++
++inline int q_atomic_fetch_and_add_int(volatile int *ptr, int value)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr += value;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue;
++}
++
++inline int q_atomic_fetch_and_add_acquire_int(volatile int *ptr, int value)
++{
++ return q_atomic_fetch_and_add_int(ptr, value);
++}
++
++inline int q_atomic_fetch_and_add_release_int(volatile int *ptr, int value)
++{
++ return q_atomic_fetch_and_add_int(ptr, value);
++}
++
++QT_END_HEADER
++
++#endif // AVR32_QATOMIC_H
+diff -Nupr a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
+--- a/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-06-30 09:49:45.000000000 +0200
++++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-07-27 13:24:27.000000000 +0200
+@@ -87,6 +87,10 @@
+ # define __NR_inotify_init 316
+ # define __NR_inotify_add_watch 317
+ # define __NR_inotify_rm_watch 318
++#elif defined (__avr32__)
++# define __NR_inotify_init 240
++# define __NR_inotify_add_watch 241
++# define __NR_inotify_rm_watch 242
+ #elif defined (__SH4__)
+ # define __NR_inotify_init 290
+ # define __NR_inotify_add_watch 291
+diff -uprN a/mkspecs/qws/linux-avr32-g++/qmake.conf b/mkspecs/qws/linux-avr32-g++/qmake.conf
+--- a/mkspecs/qws/linux-avr32-g++/qmake.conf 1970-01-01 01:00:00.000000000 +0100
++++ b/mkspecs/qws/linux-avr32-g++/qmake.conf 2006-08-01 08:47:12.000000000 +0200
+@@ -0,0 +1,85 @@
++#
++# qmake configuration for linux-g++ using the avr32-linux-g++ crosscompiler
++#
++
++MAKEFILE_GENERATOR = UNIX
++TEMPLATE = app
++CONFIG += qt warn_on release link_prl
++QT += core gui network
++QMAKE_INCREMENTAL_STYLE = sublib
++
++QMAKE_CC = avr32-linux-gcc
++QMAKE_LEX = flex
++QMAKE_LEXFLAGS =
++QMAKE_YACC = yacc
++QMAKE_YACCFLAGS = -d
++QMAKE_CFLAGS = -pipe
++QMAKE_CFLAGS_WARN_ON = -Wall -W
++QMAKE_CFLAGS_WARN_OFF =
++QMAKE_CFLAGS_RELEASE = -O2
++QMAKE_CFLAGS_DEBUG = -g -O2
++QMAKE_CFLAGS_SHLIB = -fPIC
++QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
++QMAKE_CFLAGS_THREAD = -D_REENTRANT
++QMAKE_CFLAGS_HIDESYMS = -fvisibility=hidden
++
++QMAKE_CXX = avr32-linux-g++
++QMAKE_CXXFLAGS = $$QMAKE_CFLAGS -fno-exceptions
++QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
++QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
++QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
++QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
++QMAKE_CXXFLAGS_SHLIB = $$QMAKE_CFLAGS_SHLIB
++QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
++QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD
++QMAKE_CXXFLAGS_HIDESYMS = $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden
++
++QMAKE_INCDIR =
++QMAKE_LIBDIR =
++QMAKE_INCDIR_X11 =
++QMAKE_LIBDIR_X11 =
++QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
++QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
++QMAKE_INCDIR_OPENGL =
++QMAKE_LIBDIR_OPENGL =
++QMAKE_INCDIR_QTOPIA = $(QPEDIR)/include
++QMAKE_LIBDIR_QTOPIA = $(QPEDIR)/lib
++
++QMAKE_LINK = avr32-linux-g++
++QMAKE_LINK_SHLIB = avr32-linux-g++
++QMAKE_LFLAGS =
++QMAKE_LFLAGS_RELEASE =
++QMAKE_LFLAGS_DEBUG =
++QMAKE_LFLAGS_SHLIB = -shared
++QMAKE_LFLAGS_PLUGIN = $$QMAKE_LFLAGS_SHLIB
++QMAKE_LFLAGS_SONAME = -Wl,-soname,
++QMAKE_LFLAGS_THREAD =
++QMAKE_RPATH = -Wl,-rpath,
++
++QMAKE_LIBS =
++QMAKE_LIBS_DYNLOAD = -ldl
++QMAKE_LIBS_X11 =
++QMAKE_LIBS_X11SM =
++QMAKE_LIBS_QT = -lqte
++QMAKE_LIBS_QT_THREAD = -lqte-mt
++QMAKE_LIBS_QT_OPENGL = -lqgl
++QMAKE_LIBS_QTOPIA = -lqpe -lqtopia
++QMAKE_LIBS_THREAD = -lpthread
++
++QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
++QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
++
++QMAKE_AR = avr32-linux-ar cqs
++QMAKE_RANLIB = avr32-linux-ranlib
++
++QMAKE_TAR = tar -cf
++QMAKE_GZIP = gzip -9f
++
++QMAKE_COPY = cp -f
++QMAKE_MOVE = mv -f
++QMAKE_DEL_FILE = rm -f
++QMAKE_DEL_DIR = rmdir
++QMAKE_STRIP = avr32-linux-strip
++QMAKE_CHK_DIR_EXISTS = test -d
++QMAKE_MKDIR = mkdir -p
++load(qt_config)
+diff -uprN a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h
+--- a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 1970-01-01 01:00:00.000000000 +0100
++++ b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 2006-07-26 09:16:52.000000000 +0200
+@@ -0,0 +1,22 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the qmake spec of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#include "../../linux-g++/qplatformdefs.h"
+--- a/include/QtCore/headers.pri 2007-08-02 15:03:31.000000000 +0200
++++ b/include/QtCore/headers.pri 2007-08-02 15:03:44.000000000 +0200
+@@ -1,2 +1,2 @@
+-SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
++SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_avr32.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
+ SYNCQT.HEADER_CLASSES = ../../include/QtCore/QDataStream ../../include/QtCore/QtDebug ../../include/QtCore/QDebug ../../include/QtCore/QNoDebug ../../include/QtCore/QTextStream ../../include/QtCore/QTextStreamFunction ../../include/QtCore/QTextStreamManipulator ../../include/QtCore/QTS ../../include/QtCore/QTextIStream ../../include/QtCore/QTextOStream ../../include/QtCore/QTemporaryFile ../../include/QtCore/QFSFileEngine ../../include/QtCore/QIODevice ../../include/QtCore/Q_PID ../../include/QtCore/QProcess ../../include/QtCore/QResource ../../include/QtCore/QDirIterator ../../include/QtCore/QBuffer ../../include/QtCore/QFileSystemWatcher ../../include/QtCore/QDir ../../include/QtCore/QUrl ../../include/QtCore/QAbstractFileEngine ../../include/QtCore/QAbstractFileEngineHandler ../../include/QtCore/QAbstractFileEngineIterator ../../include/QtCore/QFileInfo ../../include/QtCore/QFileInfoList ../../include/QtCore/QFileInfoListIterator ../../include/QtCore/QSettings ../../include/QtCore/QFile ../../include/QtCore/QBasicAtomic ../../include/QtCore/QBasicAtomicPointer ../../include/QtCore/QCache ../../include/QtCore/QLine ../../include/QtCore/QLineF ../../include/QtCore/QListData ../../include/QtCore/QList ../../include/QtCore/QListIterator ../../include/QtCore/QMutableListIterator ../../include/QtCore/QPair ../../include/QtCore/QPoint ../../include/QtCore/QPointF ../../include/QtCore/QRect ../../include/QtCore/QRectF ../../include/QtCore/QSize ../../include/QtCore/QSizeF ../../include/QtCore/QStringListIterator ../../include/QtCore/QMutableStringListIterator ../../include/QtCore/QStringList ../../include/QtCore/QStringMatcher ../../include/QtCore/QLinkedListData ../../include/QtCore/QLinkedListNode ../../include/QtCore/QLinkedList ../../include/QtCore/QLinkedListIterator ../../include/QtCore/QMutableLinkedListIterator ../../include/QtCore/QBitArray ../../include/QtCore/QBitRef ../../include/QtCore/QVectorData ../../include/QtCore/QVectorTypedData ../../include/QtCore/QVector ../../include/QtCore/QVectorIterator ../../include/QtCore/QMutableVectorIterator ../../include/QtCore/QByteArrayMatcher ../../include/QtCore/QQueue ../../include/QtCore/QByteArray ../../include/QtCore/QByteRef ../../include/QtCore/QtAlgorithms ../../include/QtCore/QVarLengthArray ../../include/QtCore/QSharedData ../../include/QtCore/QSharedDataPointer ../../include/QtCore/QExplicitlySharedDataPointer ../../include/QtCore/QCryptographicHash ../../include/QtCore/QLocale ../../include/QtCore/QSystemLocale ../../include/QtCore/QStack ../../include/QtCore/QMapData ../../include/QtCore/QMap ../../include/QtCore/QMultiMap ../../include/QtCore/QMapIterator ../../include/QtCore/QMutableMapIterator ../../include/QtCore/QSet ../../include/QtCore/QSetIterator ../../include/QtCore/QMutableSetIterator ../../include/QtCore/QDate ../../include/QtCore/QTime ../../include/QtCore/QDateTime ../../include/QtCore/QStdWString ../../include/QtCore/QString ../../include/QtCore/QLatin1String ../../include/QtCore/QCharRef ../../include/QtCore/QConstString ../../include/QtCore/QStringRef ../../include/QtCore/QtContainerFwd ../../include/QtCore/QRegExp ../../include/QtCore/QLatin1Char ../../include/QtCore/QChar ../../include/QtCore/QHashData ../../include/QtCore/QHashDummyValue ../../include/QtCore/QHashDummyNode ../../include/QtCore/QHashNode ../../include/QtCore/QHash ../../include/QtCore/QMultiHash ../../include/QtCore/QHashIterator ../../include/QtCore/QMutableHashIterator ../../include/QtCore/QTimeLine ../../include/QtCore/QTextCodecFactoryInterface ../../include/QtCore/QTextCodecPlugin ../../include/QtCore/QTextCodec ../../include/QtCore/QTextEncoder ../../include/QtCore/QTextDecoder ../../include/QtCore/QLibraryInfo ../../include/QtCore/QtEndian ../../include/QtCore/QtGlobal ../../include/QtCore/QUintForSize ../../include/QtCore/QUintForType ../../include/QtCore/QIntForSize ../../include/QtCore/QIntForType ../../include/QtCore/QNoImplicitBoolCast ../../include/QtCore/Q_INT8 ../../include/QtCore/Q_UINT8 ../../include/QtCore/Q_INT16 ../../include/QtCore/Q_UINT16 ../../include/QtCore/Q_INT32 ../../include/QtCore/Q_UINT32 ../../include/QtCore/Q_INT64 ../../include/QtCore/Q_UINT64 ../../include/QtCore/Q_LLONG ../../include/QtCore/Q_ULLONG ../../include/QtCore/Q_LONG ../../include/QtCore/Q_ULONG ../../include/QtCore/QSysInfo ../../include/QtCore/QtMsgHandler ../../include/QtCore/QGlobalStatic ../../include/QtCore/QGlobalStaticDeleter ../../include/QtCore/QBool ../../include/QtCore/QTypeInfo ../../include/QtCore/QFlag ../../include/QtCore/QFlags ../../include/QtCore/QForeachContainer ../../include/QtCore/QForeachContainerBase ../../include/QtCore/Qt ../../include/QtCore/QInternal ../../include/QtCore/QCOORD ../../include/QtCore/QTranslator ../../include/QtCore/QVariant ../../include/QtCore/QVariantList ../../include/QtCore/QVariantMap ../../include/QtCore/QVariantComparisonHelper ../../include/QtCore/QMimeData ../../include/QtCore/QEventLoop ../../include/QtCore/QCoreApplication ../../include/QtCore/QtCleanUpFunction ../../include/QtCore/QModelIndex ../../include/QtCore/QPersistentModelIndex ../../include/QtCore/QModelIndexList ../../include/QtCore/QAbstractItemModel ../../include/QtCore/QAbstractTableModel ../../include/QtCore/QAbstractListModel ../../include/QtCore/QSignalMapper ../../include/QtCore/QObjectCleanupHandler ../../include/QtCore/QBasicTimer ../../include/QtCore/QSocketNotifier ../../include/QtCore/QObjectList ../../include/QtCore/QObjectData ../../include/QtCore/QObject ../../include/QtCore/QObjectUserData ../../include/QtCore/QTimer ../../include/QtCore/QMetaType ../../include/QtCore/QMetaTypeId ../../include/QtCore/QMetaTypeId2 ../../include/QtCore/QAbstractEventDispatcher ../../include/QtCore/QPointer ../../include/QtCore/QMetaMethod ../../include/QtCore/QMetaEnum ../../include/QtCore/QMetaProperty ../../include/QtCore/QMetaClassInfo ../../include/QtCore/QEvent ../../include/QtCore/QTimerEvent ../../include/QtCore/QChildEvent ../../include/QtCore/QCustomEvent ../../include/QtCore/QDynamicPropertyChangeEvent ../../include/QtCore/QGenericArgument ../../include/QtCore/QGenericReturnArgument ../../include/QtCore/QArgument ../../include/QtCore/QReturnArgument ../../include/QtCore/QMetaObject ../../include/QtCore/QPluginLoader ../../include/QtCore/QUuid ../../include/QtCore/QLibrary ../../include/QtCore/QtPlugin ../../include/QtCore/QtPluginInstanceFunction ../../include/QtCore/QFactoryInterface ../../include/QtCore/QSemaphore ../../include/QtCore/QThreadStorageData ../../include/QtCore/QThreadStorage ../../include/QtCore/QWaitCondition ../../include/QtCore/QThread ../../include/QtCore/QMutex ../../include/QtCore/QMutexLocker ../../include/QtCore/QReadWriteLock ../../include/QtCore/QReadLocker ../../include/QtCore/QWriteLocker ../../include/QtCore/QAtomic ../../include/QtCore/QAtomicPointer
+++ /dev/null
-diff -urN qtopia-core-opensource-src-4.3.1-0rig/include/QtCore/headers.pri qtopia-core-opensource-src-4.3.1/include/QtCore/headers.pri
---- qtopia-core-opensource-src-4.3.1-0rig/include/QtCore/headers.pri 2007-08-07 15:20:34.000000000 +0200
-+++ qtopia-core-opensource-src-4.3.1/include/QtCore/headers.pri 2007-09-23 18:01:34.000000000 +0200
-@@ -1,2 +1,2 @@
--SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
-+SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_avr32.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
- SYNCQT.HEADER_CLASSES = ../../include/QtCore/QDataStream ../../include/QtCore/QtDebug ../../include/QtCore/QDebug ../../include/QtCore/QNoDebug ../../include/QtCore/QTextStream ../../include/QtCore/QTextStreamFunction ../../include/QtCore/QTextStreamManipulator ../../include/QtCore/QTS ../../include/QtCore/QTextIStream ../../include/QtCore/QTextOStream ../../include/QtCore/QTemporaryFile ../../include/QtCore/QFSFileEngine ../../include/QtCore/QIODevice ../../include/QtCore/Q_PID ../../include/QtCore/QProcess ../../include/QtCore/QResource ../../include/QtCore/QDirIterator ../../include/QtCore/QBuffer ../../include/QtCore/QFileSystemWatcher ../../include/QtCore/QDir ../../include/QtCore/QUrl ../../include/QtCore/QAbstractFileEngine ../../include/QtCore/QAbstractFileEngineHandler ../../include/QtCore/QAbstractFileEngineIterator ../../include/QtCore/QFileInfo ../../include/QtCore/QFileInfoList ../../include/QtCore/QFileInfoListIterator ../../include/QtCore/QSettings ../../include/QtCore/QFile ../../include/QtCore/QBasicAtomic ../../include/QtCore/QBasicAtomicPointer ../../include/QtCore/QCache ../../include/QtCore/QLine ../../include/QtCore/QLineF ../../include/QtCore/QListData ../../include/QtCore/QList ../../include/QtCore/QListIterator ../../include/QtCore/QMutableListIterator ../../include/QtCore/QPair ../../include/QtCore/QPoint ../../include/QtCore/QPointF ../../include/QtCore/QRect ../../include/QtCore/QRectF ../../include/QtCore/QSize ../../include/QtCore/QSizeF ../../include/QtCore/QStringListIterator ../../include/QtCore/QMutableStringListIterator ../../include/QtCore/QStringList ../../include/QtCore/QStringMatcher ../../include/QtCore/QLinkedListData ../../include/QtCore/QLinkedListNode ../../include/QtCore/QLinkedList ../../include/QtCore/QLinkedListIterator ../../include/QtCore/QMutableLinkedListIterator ../../include/QtCore/QBitArray ../../include/QtCore/QBitRef ../../include/QtCore/QVectorData ../../include/QtCore/QVectorTypedData ../../include/QtCore/QVector ../../include/QtCore/QVectorIterator ../../include/QtCore/QMutableVectorIterator ../../include/QtCore/QByteArrayMatcher ../../include/QtCore/QQueue ../../include/QtCore/QByteArray ../../include/QtCore/QByteRef ../../include/QtCore/QtAlgorithms ../../include/QtCore/QVarLengthArray ../../include/QtCore/QSharedData ../../include/QtCore/QSharedDataPointer ../../include/QtCore/QExplicitlySharedDataPointer ../../include/QtCore/QCryptographicHash ../../include/QtCore/QLocale ../../include/QtCore/QSystemLocale ../../include/QtCore/QStack ../../include/QtCore/QMapData ../../include/QtCore/QMap ../../include/QtCore/QMultiMap ../../include/QtCore/QMapIterator ../../include/QtCore/QMutableMapIterator ../../include/QtCore/QSet ../../include/QtCore/QSetIterator ../../include/QtCore/QMutableSetIterator ../../include/QtCore/QDate ../../include/QtCore/QTime ../../include/QtCore/QDateTime ../../include/QtCore/QStdWString ../../include/QtCore/QString ../../include/QtCore/QLatin1String ../../include/QtCore/QCharRef ../../include/QtCore/QConstString ../../include/QtCore/QStringRef ../../include/QtCore/QtContainerFwd ../../include/QtCore/QRegExp ../../include/QtCore/QLatin1Char ../../include/QtCore/QChar ../../include/QtCore/QHashData ../../include/QtCore/QHashDummyValue ../../include/QtCore/QHashDummyNode ../../include/QtCore/QHashNode ../../include/QtCore/QHash ../../include/QtCore/QMultiHash ../../include/QtCore/QHashIterator ../../include/QtCore/QMutableHashIterator ../../include/QtCore/QTimeLine ../../include/QtCore/QTextCodecFactoryInterface ../../include/QtCore/QTextCodecPlugin ../../include/QtCore/QTextCodec ../../include/QtCore/QTextEncoder ../../include/QtCore/QTextDecoder ../../include/QtCore/QLibraryInfo ../../include/QtCore/QtEndian ../../include/QtCore/QtGlobal ../../include/QtCore/QUintForSize ../../include/QtCore/QUintForType ../../include/QtCore/QIntForSize ../../include/QtCore/QIntForType ../../include/QtCore/QNoImplicitBoolCast ../../include/QtCore/Q_INT8 ../../include/QtCore/Q_UINT8 ../../include/QtCore/Q_INT16 ../../include/QtCore/Q_UINT16 ../../include/QtCore/Q_INT32 ../../include/QtCore/Q_UINT32 ../../include/QtCore/Q_INT64 ../../include/QtCore/Q_UINT64 ../../include/QtCore/Q_LLONG ../../include/QtCore/Q_ULLONG ../../include/QtCore/Q_LONG ../../include/QtCore/Q_ULONG ../../include/QtCore/QSysInfo ../../include/QtCore/QtMsgHandler ../../include/QtCore/QGlobalStatic ../../include/QtCore/QGlobalStaticDeleter ../../include/QtCore/QBool ../../include/QtCore/QTypeInfo ../../include/QtCore/QFlag ../../include/QtCore/QFlags ../../include/QtCore/QForeachContainer ../../include/QtCore/QForeachContainerBase ../../include/QtCore/Qt ../../include/QtCore/QInternal ../../include/QtCore/QCOORD ../../include/QtCore/QTranslator ../../include/QtCore/QVariant ../../include/QtCore/QVariantList ../../include/QtCore/QVariantMap ../../include/QtCore/QVariantComparisonHelper ../../include/QtCore/QMimeData ../../include/QtCore/QEventLoop ../../include/QtCore/QCoreApplication ../../include/QtCore/QtCleanUpFunction ../../include/QtCore/QModelIndex ../../include/QtCore/QPersistentModelIndex ../../include/QtCore/QModelIndexList ../../include/QtCore/QAbstractItemModel ../../include/QtCore/QAbstractTableModel ../../include/QtCore/QAbstractListModel ../../include/QtCore/QSignalMapper ../../include/QtCore/QObjectCleanupHandler ../../include/QtCore/QBasicTimer ../../include/QtCore/QSocketNotifier ../../include/QtCore/QObjectList ../../include/QtCore/QObjectData ../../include/QtCore/QObject ../../include/QtCore/QObjectUserData ../../include/QtCore/QTimer ../../include/QtCore/QMetaType ../../include/QtCore/QMetaTypeId ../../include/QtCore/QMetaTypeId2 ../../include/QtCore/QAbstractEventDispatcher ../../include/QtCore/QPointer ../../include/QtCore/QMetaMethod ../../include/QtCore/QMetaEnum ../../include/QtCore/QMetaProperty ../../include/QtCore/QMetaClassInfo ../../include/QtCore/QEvent ../../include/QtCore/QTimerEvent ../../include/QtCore/QChildEvent ../../include/QtCore/QCustomEvent ../../include/QtCore/QDynamicPropertyChangeEvent ../../include/QtCore/QGenericArgument ../../include/QtCore/QGenericReturnArgument ../../include/QtCore/QArgument ../../include/QtCore/QReturnArgument ../../include/QtCore/QMetaObject ../../include/QtCore/QPluginLoader ../../include/QtCore/QUuid ../../include/QtCore/QLibrary ../../include/QtCore/QtPlugin ../../include/QtCore/QtPluginInstanceFunction ../../include/QtCore/QFactoryInterface ../../include/QtCore/QSemaphore ../../include/QtCore/QThreadStorageData ../../include/QtCore/QThreadStorage ../../include/QtCore/QWaitCondition ../../include/QtCore/QThread ../../include/QtCore/QMutex ../../include/QtCore/QMutexLocker ../../include/QtCore/QReadWriteLock ../../include/QtCore/QReadLocker ../../include/QtCore/QWriteLocker ../../include/QtCore/QAtomic ../../include/QtCore/QAtomicPointer
--- /dev/null
+diff -urN qtopia-core-opensource-src-4.3.1-0rig/include/QtCore/headers.pri qtopia-core-opensource-src-4.3.1/include/QtCore/headers.pri
+--- qtopia-core-opensource-src-4.3.1-0rig/include/QtCore/headers.pri 2007-08-07 15:20:34.000000000 +0200
++++ qtopia-core-opensource-src-4.3.1/include/QtCore/headers.pri 2007-09-23 18:01:34.000000000 +0200
+@@ -1,2 +1,2 @@
+-SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
++SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_avr32.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
+ SYNCQT.HEADER_CLASSES = ../../include/QtCore/QDataStream ../../include/QtCore/QtDebug ../../include/QtCore/QDebug ../../include/QtCore/QNoDebug ../../include/QtCore/QTextStream ../../include/QtCore/QTextStreamFunction ../../include/QtCore/QTextStreamManipulator ../../include/QtCore/QTS ../../include/QtCore/QTextIStream ../../include/QtCore/QTextOStream ../../include/QtCore/QTemporaryFile ../../include/QtCore/QFSFileEngine ../../include/QtCore/QIODevice ../../include/QtCore/Q_PID ../../include/QtCore/QProcess ../../include/QtCore/QResource ../../include/QtCore/QDirIterator ../../include/QtCore/QBuffer ../../include/QtCore/QFileSystemWatcher ../../include/QtCore/QDir ../../include/QtCore/QUrl ../../include/QtCore/QAbstractFileEngine ../../include/QtCore/QAbstractFileEngineHandler ../../include/QtCore/QAbstractFileEngineIterator ../../include/QtCore/QFileInfo ../../include/QtCore/QFileInfoList ../../include/QtCore/QFileInfoListIterator ../../include/QtCore/QSettings ../../include/QtCore/QFile ../../include/QtCore/QBasicAtomic ../../include/QtCore/QBasicAtomicPointer ../../include/QtCore/QCache ../../include/QtCore/QLine ../../include/QtCore/QLineF ../../include/QtCore/QListData ../../include/QtCore/QList ../../include/QtCore/QListIterator ../../include/QtCore/QMutableListIterator ../../include/QtCore/QPair ../../include/QtCore/QPoint ../../include/QtCore/QPointF ../../include/QtCore/QRect ../../include/QtCore/QRectF ../../include/QtCore/QSize ../../include/QtCore/QSizeF ../../include/QtCore/QStringListIterator ../../include/QtCore/QMutableStringListIterator ../../include/QtCore/QStringList ../../include/QtCore/QStringMatcher ../../include/QtCore/QLinkedListData ../../include/QtCore/QLinkedListNode ../../include/QtCore/QLinkedList ../../include/QtCore/QLinkedListIterator ../../include/QtCore/QMutableLinkedListIterator ../../include/QtCore/QBitArray ../../include/QtCore/QBitRef ../../include/QtCore/QVectorData ../../include/QtCore/QVectorTypedData ../../include/QtCore/QVector ../../include/QtCore/QVectorIterator ../../include/QtCore/QMutableVectorIterator ../../include/QtCore/QByteArrayMatcher ../../include/QtCore/QQueue ../../include/QtCore/QByteArray ../../include/QtCore/QByteRef ../../include/QtCore/QtAlgorithms ../../include/QtCore/QVarLengthArray ../../include/QtCore/QSharedData ../../include/QtCore/QSharedDataPointer ../../include/QtCore/QExplicitlySharedDataPointer ../../include/QtCore/QCryptographicHash ../../include/QtCore/QLocale ../../include/QtCore/QSystemLocale ../../include/QtCore/QStack ../../include/QtCore/QMapData ../../include/QtCore/QMap ../../include/QtCore/QMultiMap ../../include/QtCore/QMapIterator ../../include/QtCore/QMutableMapIterator ../../include/QtCore/QSet ../../include/QtCore/QSetIterator ../../include/QtCore/QMutableSetIterator ../../include/QtCore/QDate ../../include/QtCore/QTime ../../include/QtCore/QDateTime ../../include/QtCore/QStdWString ../../include/QtCore/QString ../../include/QtCore/QLatin1String ../../include/QtCore/QCharRef ../../include/QtCore/QConstString ../../include/QtCore/QStringRef ../../include/QtCore/QtContainerFwd ../../include/QtCore/QRegExp ../../include/QtCore/QLatin1Char ../../include/QtCore/QChar ../../include/QtCore/QHashData ../../include/QtCore/QHashDummyValue ../../include/QtCore/QHashDummyNode ../../include/QtCore/QHashNode ../../include/QtCore/QHash ../../include/QtCore/QMultiHash ../../include/QtCore/QHashIterator ../../include/QtCore/QMutableHashIterator ../../include/QtCore/QTimeLine ../../include/QtCore/QTextCodecFactoryInterface ../../include/QtCore/QTextCodecPlugin ../../include/QtCore/QTextCodec ../../include/QtCore/QTextEncoder ../../include/QtCore/QTextDecoder ../../include/QtCore/QLibraryInfo ../../include/QtCore/QtEndian ../../include/QtCore/QtGlobal ../../include/QtCore/QUintForSize ../../include/QtCore/QUintForType ../../include/QtCore/QIntForSize ../../include/QtCore/QIntForType ../../include/QtCore/QNoImplicitBoolCast ../../include/QtCore/Q_INT8 ../../include/QtCore/Q_UINT8 ../../include/QtCore/Q_INT16 ../../include/QtCore/Q_UINT16 ../../include/QtCore/Q_INT32 ../../include/QtCore/Q_UINT32 ../../include/QtCore/Q_INT64 ../../include/QtCore/Q_UINT64 ../../include/QtCore/Q_LLONG ../../include/QtCore/Q_ULLONG ../../include/QtCore/Q_LONG ../../include/QtCore/Q_ULONG ../../include/QtCore/QSysInfo ../../include/QtCore/QtMsgHandler ../../include/QtCore/QGlobalStatic ../../include/QtCore/QGlobalStaticDeleter ../../include/QtCore/QBool ../../include/QtCore/QTypeInfo ../../include/QtCore/QFlag ../../include/QtCore/QFlags ../../include/QtCore/QForeachContainer ../../include/QtCore/QForeachContainerBase ../../include/QtCore/Qt ../../include/QtCore/QInternal ../../include/QtCore/QCOORD ../../include/QtCore/QTranslator ../../include/QtCore/QVariant ../../include/QtCore/QVariantList ../../include/QtCore/QVariantMap ../../include/QtCore/QVariantComparisonHelper ../../include/QtCore/QMimeData ../../include/QtCore/QEventLoop ../../include/QtCore/QCoreApplication ../../include/QtCore/QtCleanUpFunction ../../include/QtCore/QModelIndex ../../include/QtCore/QPersistentModelIndex ../../include/QtCore/QModelIndexList ../../include/QtCore/QAbstractItemModel ../../include/QtCore/QAbstractTableModel ../../include/QtCore/QAbstractListModel ../../include/QtCore/QSignalMapper ../../include/QtCore/QObjectCleanupHandler ../../include/QtCore/QBasicTimer ../../include/QtCore/QSocketNotifier ../../include/QtCore/QObjectList ../../include/QtCore/QObjectData ../../include/QtCore/QObject ../../include/QtCore/QObjectUserData ../../include/QtCore/QTimer ../../include/QtCore/QMetaType ../../include/QtCore/QMetaTypeId ../../include/QtCore/QMetaTypeId2 ../../include/QtCore/QAbstractEventDispatcher ../../include/QtCore/QPointer ../../include/QtCore/QMetaMethod ../../include/QtCore/QMetaEnum ../../include/QtCore/QMetaProperty ../../include/QtCore/QMetaClassInfo ../../include/QtCore/QEvent ../../include/QtCore/QTimerEvent ../../include/QtCore/QChildEvent ../../include/QtCore/QCustomEvent ../../include/QtCore/QDynamicPropertyChangeEvent ../../include/QtCore/QGenericArgument ../../include/QtCore/QGenericReturnArgument ../../include/QtCore/QArgument ../../include/QtCore/QReturnArgument ../../include/QtCore/QMetaObject ../../include/QtCore/QPluginLoader ../../include/QtCore/QUuid ../../include/QtCore/QLibrary ../../include/QtCore/QtPlugin ../../include/QtCore/QtPluginInstanceFunction ../../include/QtCore/QFactoryInterface ../../include/QtCore/QSemaphore ../../include/QtCore/QThreadStorageData ../../include/QtCore/QThreadStorage ../../include/QtCore/QWaitCondition ../../include/QtCore/QThread ../../include/QtCore/QMutex ../../include/QtCore/QMutexLocker ../../include/QtCore/QReadWriteLock ../../include/QtCore/QReadLocker ../../include/QtCore/QWriteLocker ../../include/QtCore/QAtomic ../../include/QtCore/QAtomicPointer
+++ /dev/null
-diff -Nupr a/include/Qt/qatomic_avr32.h b/include/Qt/qatomic_avr32.h
---- a/include/Qt/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/include/Qt/qatomic_avr32.h 2006-07-27 07:55:09.000000000 +0200
-@@ -0,0 +1 @@
-+#include "../../src/corelib/arch/qatomic_avr32.h"
-diff -Nupr a/include/QtCore/qatomic_avr32.h b/include/QtCore/qatomic_avr32.h
---- a/include/QtCore/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/include/QtCore/qatomic_avr32.h 2006-07-27 07:55:28.000000000 +0200
-@@ -0,0 +1 @@
-+#include "../../src/corelib/arch/qatomic_avr32.h"
-diff -Nupr a/src/corelib/arch/arch.pri b/src/corelib/arch/arch.pri
---- a/src/corelib/arch/arch.pri 2006-06-30 09:49:44.000000000 +0200
-+++ b/src/corelib/arch/arch.pri 2006-07-26 11:03:43.000000000 +0200
-@@ -13,6 +13,7 @@ mac:HEADERS += arch/qatomic_macosx.h \
- arch/qatomic_generic.h \
- arch/qatomic_powerpc.h \
- arch/qatomic_arm.h \
-+ arch/qatomic_avr32.h \
- arch/qatomic_i386.h \
- arch/qatomic_mips.h \
- arch/qatomic_s390.h \
-diff -Nupr a/src/corelib/arch/avr32/arch.pri b/src/corelib/arch/avr32/arch.pri
---- a/src/corelib/arch/avr32/arch.pri 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/arch.pri 2006-07-26 11:02:16.000000000 +0200
-@@ -0,0 +1,5 @@
-+#
-+# AVR32 architecture
-+#
-+SOURCES += $$QT_ARCH_CPP/qatomic.cpp \
-+ $$QT_ARCH_CPP/malloc.c
-diff -Nupr a/src/corelib/arch/avr32/malloc.c b/src/corelib/arch/avr32/malloc.c
---- a/src/corelib/arch/avr32/malloc.c 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/malloc.c 2006-07-28 10:29:44.000000000 +0200
-@@ -0,0 +1,5819 @@
-+/****************************************************************************
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** This file contains third party code which is not governed by the Qt
-+** Commercial License Agreement. Please read the license headers below
-+** for more information.
-+**
-+** Further information about Qt licensing is available at:
-+** http://www.trolltech.com/products/qt/licensing.html or by
-+** contacting info@trolltech.com.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+/* ---- config.h */
-+#define KDE_MALLOC
-+#define KDE_MALLOC_FULL
-+#define KDE_MALLOC_AVR32
-+/* ---- */
-+
-+#ifdef KDE_MALLOC
-+
-+#ifdef KDE_MALLOC_DEBUG
-+#define DEBUG
-+#endif
-+
-+#define USE_MALLOC_LOCK
-+#define INLINE __inline__
-+/*#define INLINE*/
-+#define USE_MEMCPY 0
-+#define MMAP_CLEARS 1
-+
-+/*
-+ This is a version (aka dlmalloc) of malloc/free/realloc written by
-+ Doug Lea and released to the public domain. Use, modify, and
-+ redistribute this code without permission or acknowledgment in any
-+ way you wish. Send questions, comments, complaints, performance
-+ data, etc to dl@cs.oswego.edu
-+
-+* VERSION 2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
-+
-+ Note: There may be an updated version of this malloc obtainable at
-+ ftp://gee.cs.oswego.edu/pub/misc/malloc.c
-+ Check before installing!
-+
-+* Quickstart
-+
-+ This library is all in one file to simplify the most common usage:
-+ ftp it, compile it (-O), and link it into another program. All
-+ of the compile-time options default to reasonable values for use on
-+ most unix platforms. Compile -DWIN32 for reasonable defaults on windows.
-+ You might later want to step through various compile-time and dynamic
-+ tuning options.
-+
-+ For convenience, an include file for code using this malloc is at:
-+ ftp://gee.cs.oswego.edu/pub/misc/malloc-2.7.0.h
-+ You don't really need this .h file unless you call functions not
-+ defined in your system include files. The .h file contains only the
-+ excerpts from this file needed for using this malloc on ANSI C/C++
-+ systems, so long as you haven't changed compile-time options about
-+ naming and tuning parameters. If you do, then you can create your
-+ own malloc.h that does include all settings by cutting at the point
-+ indicated below.
-+
-+* Why use this malloc?
-+
-+ This is not the fastest, most space-conserving, most portable, or
-+ most tunable malloc ever written. However it is among the fastest
-+ while also being among the most space-conserving, portable and tunable.
-+ Consistent balance across these factors results in a good general-purpose
-+ allocator for malloc-intensive programs.
-+
-+ The main properties of the algorithms are:
-+ * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
-+ with ties normally decided via FIFO (i.e. least recently used).
-+ * For small (<= 64 bytes by default) requests, it is a caching
-+ allocator, that maintains pools of quickly recycled chunks.
-+ * In between, and for combinations of large and small requests, it does
-+ the best it can trying to meet both goals at once.
-+ * For very large requests (>= 128KB by default), it relies on system
-+ memory mapping facilities, if supported.
-+
-+ For a longer but slightly out of date high-level description, see
-+ http://gee.cs.oswego.edu/dl/html/malloc.html
-+
-+ You may already by default be using a C library containing a malloc
-+ that is based on some version of this malloc (for example in
-+ linux). You might still want to use the one in this file in order to
-+ customize settings or to avoid overheads associated with library
-+ versions.
-+
-+* Contents, described in more detail in "description of public routines" below.
-+
-+ Standard (ANSI/SVID/...) functions:
-+ malloc(size_t n);
-+ calloc(size_t n_elements, size_t element_size);
-+ free(Void_t* p);
-+ realloc(Void_t* p, size_t n);
-+ memalign(size_t alignment, size_t n);
-+ valloc(size_t n);
-+ mallinfo()
-+ mallopt(int parameter_number, int parameter_value)
-+
-+ Additional functions:
-+ independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);
-+ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
-+ pvalloc(size_t n);
-+ cfree(Void_t* p);
-+ malloc_trim(size_t pad);
-+ malloc_usable_size(Void_t* p);
-+ malloc_stats();
-+
-+* Vital statistics:
-+
-+ Supported pointer representation: 4 or 8 bytes
-+ Supported size_t representation: 4 or 8 bytes
-+ Note that size_t is allowed to be 4 bytes even if pointers are 8.
-+ You can adjust this by defining INTERNAL_SIZE_T
-+
-+ Alignment: 2 * sizeof(size_t) (default)
-+ (i.e., 8 byte alignment with 4byte size_t). This suffices for
-+ nearly all current machines and C compilers. However, you can
-+ define MALLOC_ALIGNMENT to be wider than this if necessary.
-+
-+ Minimum overhead per allocated chunk: 4 or 8 bytes
-+ Each malloced chunk has a hidden word of overhead holding size
-+ and status information.
-+
-+ Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
-+ 8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
-+
-+ When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
-+ ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
-+ needed; 4 (8) for a trailing size field and 8 (16) bytes for
-+ free list pointers. Thus, the minimum allocatable size is
-+ 16/24/32 bytes.
-+
-+ Even a request for zero bytes (i.e., malloc(0)) returns a
-+ pointer to something of the minimum allocatable size.
-+
-+ The maximum overhead wastage (i.e., number of extra bytes
-+ allocated than were requested in malloc) is less than or equal
-+ to the minimum size, except for requests >= mmap_threshold that
-+ are serviced via mmap(), where the worst case wastage is 2 *
-+ sizeof(size_t) bytes plus the remainder from a system page (the
-+ minimal mmap unit); typically 4096 or 8192 bytes.
-+
-+ Maximum allocated size: 4-byte size_t: 2^32 minus about two pages
-+ 8-byte size_t: 2^64 minus about two pages
-+
-+ It is assumed that (possibly signed) size_t values suffice to
-+ represent chunk sizes. `Possibly signed' is due to the fact
-+ that `size_t' may be defined on a system as either a signed or
-+ an unsigned type. The ISO C standard says that it must be
-+ unsigned, but a few systems are known not to adhere to this.
-+ Additionally, even when size_t is unsigned, sbrk (which is by
-+ default used to obtain memory from system) accepts signed
-+ arguments, and may not be able to handle size_t-wide arguments
-+ with negative sign bit. Generally, values that would
-+ appear as negative after accounting for overhead and alignment
-+ are supported only via mmap(), which does not have this
-+ limitation.
-+
-+ Requests for sizes outside the allowed range will perform an optional
-+ failure action and then return null. (Requests may also
-+ also fail because a system is out of memory.)
-+
-+ Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined
-+
-+ When USE_MALLOC_LOCK is defined, wrappers are created to
-+ surround every public call with either a pthread mutex or
-+ a win32 spinlock (depending on WIN32). This is not
-+ especially fast, and can be a major bottleneck.
-+ It is designed only to provide minimal protection
-+ in concurrent environments, and to provide a basis for
-+ extensions. If you are using malloc in a concurrent program,
-+ you would be far better off obtaining ptmalloc, which is
-+ derived from a version of this malloc, and is well-tuned for
-+ concurrent programs. (See http://www.malloc.de)
-+
-+ Compliance: I believe it is compliant with the 1997 Single Unix Specification
-+ (See http://www.opennc.org). Also SVID/XPG, ANSI C, and probably
-+ others as well.
-+
-+* Synopsis of compile-time options:
-+
-+ People have reported using previous versions of this malloc on all
-+ versions of Unix, sometimes by tweaking some of the defines
-+ below. It has been tested most extensively on Solaris and
-+ Linux. It is also reported to work on WIN32 platforms.
-+ People also report using it in stand-alone embedded systems.
-+
-+ The implementation is in straight, hand-tuned ANSI C. It is not
-+ at all modular. (Sorry!) It uses a lot of macros. To be at all
-+ usable, this code should be compiled using an optimizing compiler
-+ (for example gcc -O3) that can simplify expressions and control
-+ paths. (FAQ: some macros import variables as arguments rather than
-+ declare locals because people reported that some debuggers
-+ otherwise get confused.)
-+
-+ OPTION DEFAULT VALUE
-+
-+ Compilation Environment options:
-+
-+ __STD_C derived from C compiler defines
-+ WIN32 NOT defined
-+ HAVE_MEMCPY defined
-+ USE_MEMCPY 1 if HAVE_MEMCPY is defined
-+ HAVE_MMAP defined as 1
-+ MMAP_CLEARS 1
-+ HAVE_MREMAP 0 unless linux defined
-+ malloc_getpagesize derived from system #includes, or 4096 if not
-+ HAVE_USR_INCLUDE_MALLOC_H NOT defined
-+ LACKS_UNISTD_H NOT defined unless WIN32
-+ LACKS_SYS_PARAM_H NOT defined unless WIN32
-+ LACKS_SYS_MMAN_H NOT defined unless WIN32
-+
-+ Changing default word sizes:
-+
-+ INTERNAL_SIZE_T size_t
-+ MALLOC_ALIGNMENT 2 * sizeof(INTERNAL_SIZE_T)
-+
-+ Configuration and functionality options:
-+
-+ USE_DL_PREFIX NOT defined
-+ USE_PUBLIC_MALLOC_WRAPPERS NOT defined
-+ USE_MALLOC_LOCK NOT defined
-+ DEBUG NOT defined
-+ REALLOC_ZERO_BYTES_FREES NOT defined
-+ MALLOC_FAILURE_ACTION errno = ENOMEM, if __STD_C defined, else no-op
-+ TRIM_FASTBINS 0
-+
-+ Options for customizing MORECORE:
-+
-+ MORECORE sbrk
-+ MORECORE_CONTIGUOUS 1
-+ MORECORE_CANNOT_TRIM NOT defined
-+ MMAP_AS_MORECORE_SIZE (1024 * 1024)
-+
-+ Tuning options that are also dynamically changeable via mallopt:
-+
-+ DEFAULT_MXFAST 64
-+ DEFAULT_TRIM_THRESHOLD 128 * 1024
-+ DEFAULT_TOP_PAD 0
-+ DEFAULT_MMAP_THRESHOLD 128 * 1024
-+ DEFAULT_MMAP_MAX 65536
-+
-+ There are several other #defined constants and macros that you
-+ probably don't want to touch unless you are extending or adapting malloc.
-+*/
-+
-+/*
-+ WIN32 sets up defaults for MS environment and compilers.
-+ Otherwise defaults are for unix.
-+*/
-+
-+/* #define WIN32 */
-+
-+#ifdef WIN32
-+
-+#define WIN32_LEAN_AND_MEAN
-+#include <windows.h>
-+
-+/* Win32 doesn't supply or need the following headers */
-+#define LACKS_UNISTD_H
-+#define LACKS_SYS_PARAM_H
-+#define LACKS_SYS_MMAN_H
-+
-+/* Use the supplied emulation of sbrk */
-+#define MORECORE sbrk
-+#define MORECORE_CONTIGUOUS 1
-+#define MORECORE_FAILURE ((void*)(-1))
-+
-+/* Use the supplied emulation of mmap and munmap */
-+#define HAVE_MMAP 1
-+#define MUNMAP_FAILURE (-1)
-+#define MMAP_CLEARS 1
-+
-+/* These values don't really matter in windows mmap emulation */
-+#define MAP_PRIVATE 1
-+#define MAP_ANONYMOUS 2
-+#define PROT_READ 1
-+#define PROT_WRITE 2
-+
-+/* Emulation functions defined at the end of this file */
-+
-+/* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */
-+#ifdef USE_MALLOC_LOCK
-+static int slwait(int *sl);
-+static int slrelease(int *sl);
-+#endif
-+
-+static long getpagesize(void);
-+static long getregionsize(void);
-+static void *sbrk(long size);
-+static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg);
-+static long munmap(void *ptr, long size);
-+
-+static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed);
-+static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user);
-+
-+#endif
-+
-+/*
-+ __STD_C should be nonzero if using ANSI-standard C compiler, a C++
-+ compiler, or a C compiler sufficiently close to ANSI to get away
-+ with it.
-+*/
-+
-+#ifndef __STD_C
-+#if defined(__STDC__) || defined(_cplusplus)
-+#define __STD_C 1
-+#else
-+#define __STD_C 0
-+#endif
-+#endif /*__STD_C*/
-+
-+
-+/*
-+ Void_t* is the pointer type that malloc should say it returns
-+*/
-+
-+#ifndef Void_t
-+#if (__STD_C || defined(WIN32))
-+#define Void_t void
-+#else
-+#define Void_t char
-+#endif
-+#endif /*Void_t*/
-+
-+#if __STD_C
-+#include <stddef.h> /* for size_t */
-+#else
-+#include <sys/types.h>
-+#endif
-+
-+#ifdef __cplusplus
-+extern "C" {
-+#endif
-+
-+/* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */
-+
-+/* #define LACKS_UNISTD_H */
-+
-+#ifndef LACKS_UNISTD_H
-+#include <unistd.h>
-+#endif
-+
-+/* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */
-+
-+/* #define LACKS_SYS_PARAM_H */
-+
-+
-+#include <stdio.h> /* needed for malloc_stats */
-+#include <errno.h> /* needed for optional MALLOC_FAILURE_ACTION */
-+
-+
-+/*
-+ Debugging:
-+
-+ Because freed chunks may be overwritten with bookkeeping fields, this
-+ malloc will often die when freed memory is overwritten by user
-+ programs. This can be very effective (albeit in an annoying way)
-+ in helping track down dangling pointers.
-+
-+ If you compile with -DDEBUG, a number of assertion checks are
-+ enabled that will catch more memory errors. You probably won't be
-+ able to make much sense of the actual assertion errors, but they
-+ should help you locate incorrectly overwritten memory. The
-+ checking is fairly extensive, and will slow down execution
-+ noticeably. Calling malloc_stats or mallinfo with DEBUG set will
-+ attempt to check every non-mmapped allocated and free chunk in the
-+ course of computing the summmaries. (By nature, mmapped regions
-+ cannot be checked very much automatically.)
-+
-+ Setting DEBUG may also be helpful if you are trying to modify
-+ this code. The assertions in the check routines spell out in more
-+ detail the assumptions and invariants underlying the algorithms.
-+
-+ Setting DEBUG does NOT provide an automated mechanism for checking
-+ that all accesses to malloced memory stay within their
-+ bounds. However, there are several add-ons and adaptations of this
-+ or other mallocs available that do this.
-+*/
-+
-+#ifdef DEBUG
-+#include <assert.h>
-+#else
-+#define assert(x) ((void)0)
-+#endif
-+
-+
-+/*
-+ INTERNAL_SIZE_T is the word-size used for internal bookkeeping
-+ of chunk sizes.
-+
-+ The default version is the same as size_t.
-+
-+ While not strictly necessary, it is best to define this as an
-+ unsigned type, even if size_t is a signed type. This may avoid some
-+ artificial size limitations on some systems.
-+
-+ On a 64-bit machine, you may be able to reduce malloc overhead by
-+ defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the
-+ expense of not being able to handle more than 2^32 of malloced
-+ space. If this limitation is acceptable, you are encouraged to set
-+ this unless you are on a platform requiring 16byte alignments. In
-+ this case the alignment requirements turn out to negate any
-+ potential advantages of decreasing size_t word size.
-+
-+ Implementors: Beware of the possible combinations of:
-+ - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,
-+ and might be the same width as int or as long
-+ - size_t might have different width and signedness as INTERNAL_SIZE_T
-+ - int and long might be 32 or 64 bits, and might be the same width
-+ To deal with this, most comparisons and difference computations
-+ among INTERNAL_SIZE_Ts should cast them to unsigned long, being
-+ aware of the fact that casting an unsigned int to a wider long does
-+ not sign-extend. (This also makes checking for negative numbers
-+ awkward.) Some of these casts result in harmless compiler warnings
-+ on some systems.
-+*/
-+
-+#ifndef INTERNAL_SIZE_T
-+#define INTERNAL_SIZE_T size_t
-+#endif
-+
-+/* The corresponding word size */
-+#define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
-+
-+
-+/*
-+ MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
-+ It must be a power of two at least 2 * SIZE_SZ, even on machines
-+ for which smaller alignments would suffice. It may be defined as
-+ larger than this though. Note however that code and data structures
-+ are optimized for the case of 8-byte alignment.
-+*/
-+
-+
-+#ifndef MALLOC_ALIGNMENT
-+#define MALLOC_ALIGNMENT (2 * SIZE_SZ)
-+#endif
-+
-+/* The corresponding bit mask value */
-+#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
-+
-+
-+
-+/*
-+ REALLOC_ZERO_BYTES_FREES should be set if a call to
-+ realloc with zero bytes should be the same as a call to free.
-+ Some people think it should. Otherwise, since this malloc
-+ returns a unique pointer for malloc(0), so does realloc(p, 0).
-+*/
-+
-+/* #define REALLOC_ZERO_BYTES_FREES */
-+
-+/*
-+ TRIM_FASTBINS controls whether free() of a very small chunk can
-+ immediately lead to trimming. Setting to true (1) can reduce memory
-+ footprint, but will almost always slow down programs that use a lot
-+ of small chunks.
-+
-+ Define this only if you are willing to give up some speed to more
-+ aggressively reduce system-level memory footprint when releasing
-+ memory in programs that use many small chunks. You can get
-+ essentially the same effect by setting MXFAST to 0, but this can
-+ lead to even greater slowdowns in programs using many small chunks.
-+ TRIM_FASTBINS is an in-between compile-time option, that disables
-+ only those chunks bordering topmost memory from being placed in
-+ fastbins.
-+*/
-+
-+#ifndef TRIM_FASTBINS
-+#define TRIM_FASTBINS 0
-+#endif
-+
-+
-+/*
-+ USE_DL_PREFIX will prefix all public routines with the string 'dl'.
-+ This is necessary when you only want to use this malloc in one part
-+ of a program, using your regular system malloc elsewhere.
-+*/
-+
-+/* #define USE_DL_PREFIX */
-+
-+
-+/*
-+ USE_MALLOC_LOCK causes wrapper functions to surround each
-+ callable routine with pthread mutex lock/unlock.
-+
-+ USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined
-+*/
-+
-+
-+/* #define USE_MALLOC_LOCK */
-+
-+
-+/*
-+ If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is
-+ actually a wrapper function that first calls MALLOC_PREACTION, then
-+ calls the internal routine, and follows it with
-+ MALLOC_POSTACTION. This is needed for locking, but you can also use
-+ this, without USE_MALLOC_LOCK, for purposes of interception,
-+ instrumentation, etc. It is a sad fact that using wrappers often
-+ noticeably degrades performance of malloc-intensive programs.
-+*/
-+
-+#ifdef USE_MALLOC_LOCK
-+#define USE_PUBLIC_MALLOC_WRAPPERS
-+#else
-+/* #define USE_PUBLIC_MALLOC_WRAPPERS */
-+#endif
-+
-+
-+/*
-+ Two-phase name translation.
-+ All of the actual routines are given mangled names.
-+ When wrappers are used, they become the public callable versions.
-+ When DL_PREFIX is used, the callable names are prefixed.
-+*/
-+
-+#ifndef USE_PUBLIC_MALLOC_WRAPPERS
-+#define cALLOc public_cALLOc
-+#define fREe public_fREe
-+#define cFREe public_cFREe
-+#define mALLOc public_mALLOc
-+#define mEMALIGn public_mEMALIGn
-+#define rEALLOc public_rEALLOc
-+#define vALLOc public_vALLOc
-+#define pVALLOc public_pVALLOc
-+#define mALLINFo public_mALLINFo
-+#define mALLOPt public_mALLOPt
-+#define mTRIm public_mTRIm
-+#define mSTATs public_mSTATs
-+#define mUSABLe public_mUSABLe
-+#define iCALLOc public_iCALLOc
-+#define iCOMALLOc public_iCOMALLOc
-+#endif
-+
-+#ifdef USE_DL_PREFIX
-+#define public_cALLOc dlcalloc
-+#define public_fREe dlfree
-+#define public_cFREe dlcfree
-+#define public_mALLOc dlmalloc
-+#define public_mEMALIGn dlmemalign
-+#define public_rEALLOc dlrealloc
-+#define public_vALLOc dlvalloc
-+#define public_pVALLOc dlpvalloc
-+#define public_mALLINFo dlmallinfo
-+#define public_mALLOPt dlmallopt
-+#define public_mTRIm dlmalloc_trim
-+#define public_mSTATs dlmalloc_stats
-+#define public_mUSABLe dlmalloc_usable_size
-+#define public_iCALLOc dlindependent_calloc
-+#define public_iCOMALLOc dlindependent_comalloc
-+#else /* USE_DL_PREFIX */
-+#define public_cALLOc calloc
-+#define public_fREe free
-+#define public_cFREe cfree
-+#define public_mALLOc malloc
-+#define public_mEMALIGn memalign
-+#define public_rEALLOc realloc
-+#define public_vALLOc valloc
-+#define public_pVALLOc pvalloc
-+#define public_mALLINFo mallinfo
-+#define public_mALLOPt mallopt
-+#define public_mTRIm malloc_trim
-+#define public_mSTATs malloc_stats
-+#define public_mUSABLe malloc_usable_size
-+#define public_iCALLOc independent_calloc
-+#define public_iCOMALLOc independent_comalloc
-+#endif /* USE_DL_PREFIX */
-+
-+
-+/*
-+ HAVE_MEMCPY should be defined if you are not otherwise using
-+ ANSI STD C, but still have memcpy and memset in your C library
-+ and want to use them in calloc and realloc. Otherwise simple
-+ macro versions are defined below.
-+
-+ USE_MEMCPY should be defined as 1 if you actually want to
-+ have memset and memcpy called. People report that the macro
-+ versions are faster than libc versions on some systems.
-+
-+ Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks
-+ (of <= 36 bytes) are manually unrolled in realloc and calloc.
-+*/
-+
-+/* If it's available it's defined in config.h. */
-+/* #define HAVE_MEMCPY */
-+
-+#ifndef USE_MEMCPY
-+#ifdef HAVE_MEMCPY
-+#define USE_MEMCPY 1
-+#else
-+#define USE_MEMCPY 0
-+#endif
-+#endif
-+
-+
-+#if (__STD_C || defined(HAVE_MEMCPY))
-+
-+#ifdef WIN32
-+/* On Win32 memset and memcpy are already declared in windows.h */
-+#else
-+#if __STD_C
-+void* memset(void*, int, size_t);
-+void* memcpy(void*, const void*, size_t);
-+#else
-+Void_t* memset();
-+Void_t* memcpy();
-+#endif
-+#endif
-+#endif
-+
-+/*
-+ MALLOC_FAILURE_ACTION is the action to take before "return 0" when
-+ malloc fails to be able to return memory, either because memory is
-+ exhausted or because of illegal arguments.
-+
-+ By default, sets errno if running on STD_C platform, else does nothing.
-+*/
-+
-+#ifndef MALLOC_FAILURE_ACTION
-+#if __STD_C
-+#define MALLOC_FAILURE_ACTION \
-+ errno = ENOMEM;
-+
-+#else
-+#define MALLOC_FAILURE_ACTION
-+#endif
-+#endif
-+
-+/*
-+ MORECORE-related declarations. By default, rely on sbrk
-+*/
-+
-+
-+#ifdef LACKS_UNISTD_H
-+#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
-+#if __STD_C
-+extern Void_t* sbrk(ptrdiff_t);
-+#else
-+extern Void_t* sbrk();
-+#endif
-+#endif
-+#endif
-+
-+/*
-+ MORECORE is the name of the routine to call to obtain more memory
-+ from the system. See below for general guidance on writing
-+ alternative MORECORE functions, as well as a version for WIN32 and a
-+ sample version for pre-OSX macos.
-+*/
-+
-+#ifndef MORECORE
-+#define MORECORE sbrk
-+#endif
-+
-+/*
-+ MORECORE_FAILURE is the value returned upon failure of MORECORE
-+ as well as mmap. Since it cannot be an otherwise valid memory address,
-+ and must reflect values of standard sys calls, you probably ought not
-+ try to redefine it.
-+*/
-+
-+#ifndef MORECORE_FAILURE
-+#define MORECORE_FAILURE (-1)
-+#endif
-+
-+/*
-+ If MORECORE_CONTIGUOUS is true, take advantage of fact that
-+ consecutive calls to MORECORE with positive arguments always return
-+ contiguous increasing addresses. This is true of unix sbrk. Even
-+ if not defined, when regions happen to be contiguous, malloc will
-+ permit allocations spanning regions obtained from different
-+ calls. But defining this when applicable enables some stronger
-+ consistency checks and space efficiencies.
-+*/
-+
-+#ifndef MORECORE_CONTIGUOUS
-+#define MORECORE_CONTIGUOUS 1
-+#endif
-+
-+/*
-+ Define MORECORE_CANNOT_TRIM if your version of MORECORE
-+ cannot release space back to the system when given negative
-+ arguments. This is generally necessary only if you are using
-+ a hand-crafted MORECORE function that cannot handle negative arguments.
-+*/
-+
-+/* #define MORECORE_CANNOT_TRIM */
-+
-+
-+/*
-+ Define HAVE_MMAP as true to optionally make malloc() use mmap() to
-+ allocate very large blocks. These will be returned to the
-+ operating system immediately after a free(). Also, if mmap
-+ is available, it is used as a backup strategy in cases where
-+ MORECORE fails to provide space from system.
-+
-+ This malloc is best tuned to work with mmap for large requests.
-+ If you do not have mmap, operations involving very large chunks (1MB
-+ or so) may be slower than you'd like.
-+*/
-+
-+#ifndef HAVE_MMAP
-+#define HAVE_MMAP 1
-+#endif
-+
-+#if HAVE_MMAP
-+/*
-+ Standard unix mmap using /dev/zero clears memory so calloc doesn't
-+ need to.
-+*/
-+
-+#ifndef MMAP_CLEARS
-+#define MMAP_CLEARS 1
-+#endif
-+
-+#else /* no mmap */
-+#ifndef MMAP_CLEARS
-+#define MMAP_CLEARS 0
-+#endif
-+#endif
-+
-+
-+/*
-+ MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if
-+ sbrk fails, and mmap is used as a backup (which is done only if
-+ HAVE_MMAP). The value must be a multiple of page size. This
-+ backup strategy generally applies only when systems have "holes" in
-+ address space, so sbrk cannot perform contiguous expansion, but
-+ there is still space available on system. On systems for which
-+ this is known to be useful (i.e. most linux kernels), this occurs
-+ only when programs allocate huge amounts of memory. Between this,
-+ and the fact that mmap regions tend to be limited, the size should
-+ be large, to avoid too many mmap calls and thus avoid running out
-+ of kernel resources.
-+*/
-+
-+#ifndef MMAP_AS_MORECORE_SIZE
-+#define MMAP_AS_MORECORE_SIZE (1024 * 1024)
-+#endif
-+
-+/*
-+ Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
-+ large blocks. This is currently only possible on Linux with
-+ kernel versions newer than 1.3.77.
-+*/
-+
-+#ifndef HAVE_MREMAP
-+#if defined(linux) || defined(__linux__) || defined(__linux)
-+#define HAVE_MREMAP 1
-+#else
-+#define HAVE_MREMAP 0
-+#endif
-+
-+#endif /* HAVE_MMAP */
-+
-+
-+/*
-+ The system page size. To the extent possible, this malloc manages
-+ memory from the system in page-size units. Note that this value is
-+ cached during initialization into a field of malloc_state. So even
-+ if malloc_getpagesize is a function, it is only called once.
-+
-+ The following mechanics for getpagesize were adapted from bsd/gnu
-+ getpagesize.h. If none of the system-probes here apply, a value of
-+ 4096 is used, which should be OK: If they don't apply, then using
-+ the actual value probably doesn't impact performance.
-+*/
-+
-+
-+#ifndef malloc_getpagesize
-+
-+#ifndef LACKS_UNISTD_H
-+# include <unistd.h>
-+#endif
-+
-+# 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 */
-+# define malloc_getpagesize getpagesize()
-+# else
-+# ifndef LACKS_SYS_PARAM_H
-+# include <sys/param.h>
-+# endif
-+# ifdef EXEC_PAGESIZE
-+# define malloc_getpagesize EXEC_PAGESIZE
-+# else
-+# ifdef NBPG
-+# ifndef CLSIZE
-+# define malloc_getpagesize NBPG
-+# else
-+# define malloc_getpagesize (NBPG * CLSIZE)
-+# endif
-+# else
-+# ifdef NBPC
-+# define malloc_getpagesize NBPC
-+# else
-+# ifdef PAGESIZE
-+# define malloc_getpagesize PAGESIZE
-+# else /* just guess */
-+# define malloc_getpagesize (4096)
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+# endif
-+#endif
-+
-+/*
-+ This version of malloc supports the standard SVID/XPG mallinfo
-+ routine that returns a struct containing usage properties and
-+ statistics. It should work on any SVID/XPG compliant system that has
-+ a /usr/include/malloc.h defining struct mallinfo. (If you'd like to
-+ install such a thing yourself, cut out the preliminary declarations
-+ as described above and below and save them in a malloc.h file. But
-+ there's no compelling reason to bother to do this.)
-+
-+ The main declaration needed is the mallinfo struct that is returned
-+ (by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a
-+ bunch of field that are not even meaningful in this version of
-+ malloc. These fields are are instead filled by mallinfo() with
-+ other numbers that might be of interest.
-+
-+ HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
-+ /usr/include/malloc.h file that includes a declaration of struct
-+ mallinfo. If so, it is included; else an SVID2/XPG2 compliant
-+ version is declared below. These must be precisely the same for
-+ mallinfo() to work. The original SVID version of this struct,
-+ defined on most systems with mallinfo, declares all fields as
-+ ints. But some others define as unsigned long. If your system
-+ defines the fields using a type of different width than listed here,
-+ you must #include your system version and #define
-+ HAVE_USR_INCLUDE_MALLOC_H.
-+*/
-+
-+/* #define HAVE_USR_INCLUDE_MALLOC_H */
-+
-+/*#ifdef HAVE_USR_INCLUDE_MALLOC_H*/
-+#if 0
-+#include "/usr/include/malloc.h"
-+#else
-+
-+/* SVID2/XPG mallinfo structure */
-+
-+struct mallinfo {
-+ int arena; /* non-mmapped space allocated from system */
-+ int ordblks; /* number of free chunks */
-+ int smblks; /* number of fastbin blocks */
-+ int hblks; /* number of mmapped regions */
-+ int hblkhd; /* space in mmapped regions */
-+ int usmblks; /* maximum total allocated space */
-+ int fsmblks; /* space available in freed fastbin blocks */
-+ int uordblks; /* total allocated space */
-+ int fordblks; /* total free space */
-+ int keepcost; /* top-most, releasable (via malloc_trim) space */
-+};
-+
-+/*
-+ SVID/XPG defines four standard parameter numbers for mallopt,
-+ normally defined in malloc.h. Only one of these (M_MXFAST) is used
-+ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
-+ so setting them has no effect. But this malloc also supports other
-+ options in mallopt described below.
-+*/
-+#endif
-+
-+
-+/* ---------- description of public routines ------------ */
-+
-+/*
-+ malloc(size_t n)
-+ Returns a pointer to a newly allocated chunk of at least n bytes, or null
-+ if no space is available. Additionally, on failure, errno is
-+ set to ENOMEM on ANSI C systems.
-+
-+ If n is zero, malloc returns a minumum-sized chunk. (The minimum
-+ size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
-+ systems.) On most systems, size_t is an unsigned type, so calls
-+ with negative arguments 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.
-+*/
-+#if __STD_C
-+Void_t* public_mALLOc(size_t);
-+#else
-+Void_t* public_mALLOc();
-+#endif
-+
-+/*
-+ free(Void_t* 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. It can have arbitrary (i.e., bad!)
-+ effects if p has already been freed.
-+
-+ Unless disabled (using mallopt), freeing very large spaces will
-+ when possible, automatically trigger operations that give
-+ back unused memory to the system, thus reducing program footprint.
-+*/
-+#if __STD_C
-+void public_fREe(Void_t*);
-+#else
-+void public_fREe();
-+#endif
-+
-+/*
-+ calloc(size_t n_elements, size_t element_size);
-+ Returns a pointer to n_elements * element_size bytes, with all locations
-+ set to zero.
-+*/
-+#if __STD_C
-+Void_t* public_cALLOc(size_t, size_t);
-+#else
-+Void_t* public_cALLOc();
-+#endif
-+
-+/*
-+ realloc(Void_t* 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
-+ if no space is available.
-+
-+ The returned pointer may or may not be the same as p. The algorithm
-+ prefers extending p when possible, otherwise it employs the
-+ equivalent of a malloc-copy-free sequence.
-+
-+ If p is null, realloc is equivalent to malloc.
-+
-+ If space is not available, realloc returns null, errno is set (if on
-+ ANSI) and p is NOT freed.
-+
-+ if n is for fewer bytes than already held by p, the newly unused
-+ space is lopped off and freed if possible. Unless the #define
-+ REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of
-+ zero (re)allocates a minimum-sized chunk.
-+
-+ Large chunks that were internally obtained via mmap will always
-+ be reallocated using malloc-copy-free sequences unless
-+ the system supports MREMAP (currently only linux).
-+
-+ The old unix realloc convention of allowing the last-free'd chunk
-+ to be used as an argument to realloc is not supported.
-+*/
-+#if __STD_C
-+Void_t* public_rEALLOc(Void_t*, size_t);
-+#else
-+Void_t* public_rEALLOc();
-+#endif
-+
-+/*
-+ 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.
-+
-+ The alignment argument should be a power of two. If the argument is
-+ not a power of two, the nearest greater power is used.
-+ 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.
-+*/
-+#if __STD_C
-+Void_t* public_mEMALIGn(size_t, size_t);
-+#else
-+Void_t* public_mEMALIGn();
-+#endif
-+
-+/*
-+ 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.
-+*/
-+#if __STD_C
-+Void_t* public_vALLOc(size_t);
-+#else
-+Void_t* public_vALLOc();
-+#endif
-+
-+
-+
-+/*
-+ 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
-+ corresponding parameter to the argument value if it can (i.e., so
-+ long as the value is meaningful), and returns 1 if successful else
-+ 0. SVID/XPG/ANSI defines four standard param numbers for mallopt,
-+ normally defined in malloc.h. Only one of these (M_MXFAST) is used
-+ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
-+ so setting them has no effect. But this malloc also supports four
-+ other options in mallopt. See below for details. Briefly, supported
-+ parameters are as follows (listed defaults are for "typical"
-+ configurations).
-+
-+ Symbol param # default allowed param values
-+ M_MXFAST 1 64 0-80 (0 disables fastbins)
-+ M_TRIM_THRESHOLD -1 128*1024 any (-1U disables trimming)
-+ M_TOP_PAD -2 0 any
-+ M_MMAP_THRESHOLD -3 128*1024 any (or 0 if no MMAP support)
-+ M_MMAP_MAX -4 65536 any (0 disables use of mmap)
-+*/
-+#if __STD_C
-+int public_mALLOPt(int, int);
-+#else
-+int public_mALLOPt();
-+#endif
-+
-+
-+/*
-+ mallinfo()
-+ Returns (by copy) a struct containing various summary statistics:
-+
-+ arena: current total non-mmapped bytes allocated from system
-+ ordblks: the number of free chunks
-+ smblks: the number of fastbin blocks (i.e., small chunks that
-+ have been freed but not use resused or consolidated)
-+ hblks: current number of mmapped regions
-+ hblkhd: total bytes held in mmapped regions
-+ usmblks: the maximum total allocated space. This will be greater
-+ than current total if trimming has occurred.
-+ fsmblks: total bytes held in fastbin blocks
-+ uordblks: current total allocated space (normal or mmapped)
-+ fordblks: total free space
-+ keepcost: the maximum number of bytes that could ideally be released
-+ back to system via malloc_trim. ("ideally" means that
-+ it ignores page restrictions etc.)
-+
-+ Because these fields are ints, but internal bookkeeping may
-+ be kept as longs, the reported values may wrap around zero and
-+ thus be inaccurate.
-+*/
-+#if __STD_C
-+struct mallinfo public_mALLINFo(void);
-+#else
-+struct mallinfo public_mALLINFo();
-+#endif
-+
-+/*
-+ independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
-+
-+ independent_calloc is similar to calloc, but instead of returning a
-+ single cleared space, it returns an array of pointers to n_elements
-+ independent elements that can hold contents of size elem_size, each
-+ of which starts out cleared, and can be independently freed,
-+ realloc'ed etc. The elements are guaranteed to be adjacently
-+ allocated (this is not guaranteed to occur with multiple callocs or
-+ mallocs), which may also improve cache locality in some
-+ applications.
-+
-+ The "chunks" argument is optional (i.e., may be null, which is
-+ probably the most typical usage). If it is null, the returned array
-+ is itself dynamically allocated and should also be freed when it is
-+ no longer needed. Otherwise, the chunks array must be of at least
-+ n_elements in length. It is filled in with the pointers to the
-+ chunks.
-+
-+ In either case, independent_calloc returns this pointer array, or
-+ null if the allocation failed. If n_elements is zero and "chunks"
-+ is null, it returns a chunk representing an array with zero elements
-+ (which should be freed if not wanted).
-+
-+ Each element must be individually freed when it is no longer
-+ needed. If you'd like to instead be able to free all at once, you
-+ should instead use regular calloc and assign pointers into this
-+ space to represent elements. (In this case though, you cannot
-+ independently free elements.)
-+
-+ independent_calloc simplifies and speeds up implementations of many
-+ kinds of pools. It may also be useful when constructing large data
-+ structures that initially have a fixed number of fixed-sized nodes,
-+ but the number is not known at compile time, and some of the nodes
-+ may later need to be freed. For example:
-+
-+ struct Node { int item; struct Node* next; };
-+
-+ struct Node* build_list() {
-+ struct Node** pool;
-+ int n = read_number_of_nodes_needed();
-+ if (n <= 0) return 0;
-+ pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
-+ if (pool == 0) die();
-+ // organize into a linked list...
-+ struct Node* first = pool[0];
-+ for (i = 0; i < n-1; ++i)
-+ pool[i]->next = pool[i+1];
-+ free(pool); // Can now free the array (or not, if it is needed later)
-+ return first;
-+ }
-+*/
-+#if __STD_C
-+Void_t** public_iCALLOc(size_t, size_t, Void_t**);
-+#else
-+Void_t** public_iCALLOc();
-+#endif
-+
-+/*
-+ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
-+
-+ independent_comalloc allocates, all at once, a set of n_elements
-+ chunks with sizes indicated in the "sizes" array. It returns
-+ an array of pointers to these elements, each of which can be
-+ independently freed, realloc'ed etc. The elements are guaranteed to
-+ be adjacently allocated (this is not guaranteed to occur with
-+ multiple callocs or mallocs), which may also improve cache locality
-+ in some applications.
-+
-+ The "chunks" argument is optional (i.e., may be null). If it is null
-+ the returned array is itself dynamically allocated and should also
-+ be freed when it is no longer needed. Otherwise, the chunks array
-+ must be of at least n_elements in length. It is filled in with the
-+ pointers to the chunks.
-+
-+ In either case, independent_comalloc returns this pointer array, or
-+ null if the allocation failed. If n_elements is zero and chunks is
-+ null, it returns a chunk representing an array with zero elements
-+ (which should be freed if not wanted).
-+
-+ Each element must be individually freed when it is no longer
-+ needed. If you'd like to instead be able to free all at once, you
-+ should instead use a single regular malloc, and assign pointers at
-+ particular offsets in the aggregate space. (In this case though, you
-+ cannot independently free elements.)
-+
-+ independent_comallac differs from independent_calloc in that each
-+ element may have a different size, and also that it does not
-+ automatically clear elements.
-+
-+ independent_comalloc can be used to speed up allocation in cases
-+ where several structs or objects must always be allocated at the
-+ same time. For example:
-+
-+ struct Head { ... }
-+ struct Foot { ... }
-+
-+ void send_message(char* msg) {
-+ int msglen = strlen(msg);
-+ size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
-+ void* chunks[3];
-+ if (independent_comalloc(3, sizes, chunks) == 0)
-+ die();
-+ struct Head* head = (struct Head*)(chunks[0]);
-+ char* body = (char*)(chunks[1]);
-+ struct Foot* foot = (struct Foot*)(chunks[2]);
-+ // ...
-+ }
-+
-+ In general though, independent_comalloc is worth using only for
-+ larger values of n_elements. For small values, you probably won't
-+ detect enough difference from series of malloc calls to bother.
-+
-+ 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.
-+*/
-+#if __STD_C
-+Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
-+#else
-+Void_t** public_iCOMALLOc();
-+#endif
-+
-+
-+/*
-+ pvalloc(size_t n);
-+ Equivalent to valloc(minimum-page-that-holds(n)), that is,
-+ round up n to nearest pagesize.
-+ */
-+#if __STD_C
-+Void_t* public_pVALLOc(size_t);
-+#else
-+Void_t* public_pVALLOc();
-+#endif
-+
-+/*
-+ cfree(Void_t* p);
-+ Equivalent to free(p).
-+
-+ cfree is needed/defined on some systems that pair it with calloc,
-+ for odd historical reasons (such as: cfree is used in example
-+ code in the first edition of K&R).
-+*/
-+#if __STD_C
-+void public_cFREe(Void_t*);
-+#else
-+void public_cFREe();
-+#endif
-+
-+/*
-+ malloc_trim(size_t pad);
-+
-+ If possible, gives memory back to the system (via negative
-+ arguments to sbrk) if there is unused memory at the `high' end of
-+ the malloc pool. You can call this after freeing large blocks of
-+ memory to potentially reduce the system-level memory requirements
-+ of a program. However, it cannot guarantee to reduce memory. Under
-+ some allocation patterns, some large free blocks of memory will be
-+ locked between two used chunks, so they cannot be given back to
-+ the system.
-+
-+ The `pad' argument to malloc_trim represents the amount of free
-+ trailing space to leave untrimmed. If this argument is zero,
-+ only the minimum amount of memory to maintain internal data
-+ structures will be left (one page or less). Non-zero arguments
-+ can be supplied to maintain enough 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.
-+ On systems that do not support "negative sbrks", it will always
-+ rreturn 0.
-+*/
-+#if __STD_C
-+int public_mTRIm(size_t);
-+#else
-+int public_mTRIm();
-+#endif
-+
-+/*
-+ malloc_usable_size(Void_t* p);
-+
-+ Returns the number of bytes you can actually use in
-+ an allocated chunk, which may be more than you requested (although
-+ often not) due to alignment and minimum size constraints.
-+ You can use this many bytes without worrying about
-+ overwriting other allocated objects. This is not a particularly great
-+ programming practice. malloc_usable_size can be more useful in
-+ debugging and assertions, for example:
-+
-+ p = malloc(n);
-+ assert(malloc_usable_size(p) >= 256);
-+
-+*/
-+#if __STD_C
-+size_t public_mUSABLe(Void_t*);
-+#else
-+size_t public_mUSABLe();
-+#endif
-+
-+/*
-+ 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
-+ current if malloc_trim and/or munmap got called), and the current
-+ number of bytes allocated via malloc (or realloc, etc) but not yet
-+ freed. Note that this is the number of bytes allocated, not the
-+ number requested. It will be larger than the number requested
-+ because of alignment and bookkeeping overhead. Because it includes
-+ alignment wastage as being in use, this figure may be greater than
-+ zero even when no user-level chunks are allocated.
-+
-+ The reported current and maximum system memory can be inaccurate if
-+ a program makes other calls to system memory allocation functions
-+ (normally sbrk) outside of malloc.
-+
-+ malloc_stats prints only the most commonly interesting statistics.
-+ More information can be obtained by calling mallinfo.
-+
-+*/
-+#if __STD_C
-+void public_mSTATs();
-+#else
-+void public_mSTATs();
-+#endif
-+
-+/* mallopt tuning options */
-+
-+/*
-+ M_MXFAST is the maximum request size used for "fastbins", special bins
-+ that hold returned chunks without consolidating their spaces. This
-+ enables future requests for chunks of the same size to be handled
-+ very quickly, but can increase fragmentation, and thus increase the
-+ overall memory footprint of a program.
-+
-+ This malloc manages fastbins very conservatively yet still
-+ efficiently, so fragmentation is rarely a problem for values less
-+ than or equal to the default. The maximum supported value of MXFAST
-+ is 80. You wouldn't want it any higher than this anyway. Fastbins
-+ are designed especially for use with many small structs, objects or
-+ strings -- the default handles structs/objects/arrays with sizes up
-+ to 8 4byte fields, or small strings representing words, tokens,
-+ etc. Using fastbins for larger objects normally worsens
-+ fragmentation without improving speed.
-+
-+ M_MXFAST is set in REQUEST size units. It is internally used in
-+ chunksize units, which adds padding and alignment. You can reduce
-+ M_MXFAST to 0 to disable all use of fastbins. This causes the malloc
-+ algorithm to be a closer approximation of fifo-best-fit in all cases,
-+ not just for larger requests, but will generally cause it to be
-+ slower.
-+*/
-+
-+
-+/* M_MXFAST is a standard SVID/XPG tuning option, usually listed in malloc.h */
-+#ifndef M_MXFAST
-+#define M_MXFAST 1
-+#endif
-+
-+#ifndef DEFAULT_MXFAST
-+#define DEFAULT_MXFAST 64
-+#endif
-+
-+
-+/*
-+ M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
-+ to keep before releasing via malloc_trim in free().
-+
-+ Automatic trimming is mainly useful in long-lived programs.
-+ Because trimming via sbrk can be slow on some systems, and can
-+ sometimes be wasteful (in cases where programs immediately
-+ afterward allocate more large chunks) the value should be high
-+ enough so that your overall system performance would improve by
-+ releasing this much memory.
-+
-+ The trim threshold and the mmap control parameters (see below)
-+ can be traded off with one another. Trimming and mmapping are
-+ two different ways of releasing unused memory back to the
-+ system. Between these two, it is often possible to keep
-+ system-level demands of a long-lived program down to a bare
-+ minimum. For example, in one test suite of sessions measuring
-+ the XF86 X server on Linux, using a trim threshold of 128K and a
-+ mmap threshold of 192K led to near-minimal long term resource
-+ consumption.
-+
-+ If you are using this malloc in a long-lived program, it should
-+ pay to experiment with these values. As a rough guide, you
-+ might set to a value close to the average size of a process
-+ (program) running on your system. Releasing this much memory
-+ would allow such a process to run in memory. Generally, it's
-+ worth it to tune for trimming rather tham memory mapping when a
-+ program undergoes phases where several large chunks are
-+ allocated and released in ways that can reuse each other's
-+ storage, perhaps mixed with phases where there are no such
-+ chunks at all. And in well-behaved long-lived programs,
-+ controlling release of large blocks via trimming versus mapping
-+ is usually faster.
-+
-+ However, in most programs, these parameters serve mainly as
-+ protection against the system-level effects of carrying around
-+ massive amounts of unneeded memory. Since frequent calls to
-+ sbrk, mmap, and munmap otherwise degrade performance, the default
-+ parameters are set to relatively high values that serve only as
-+ safeguards.
-+
-+ The trim value It must be greater than page size to have any useful
-+ effect. To disable trimming completely, you can set to
-+ (unsigned long)(-1)
-+
-+ Trim settings interact with fastbin (MXFAST) settings: Unless
-+ TRIM_FASTBINS is defined, automatic trimming never takes place upon
-+ freeing a chunk with size less than or equal to MXFAST. Trimming is
-+ instead delayed until subsequent freeing of larger chunks. However,
-+ you can still force an attempted trim by calling malloc_trim.
-+
-+ Also, trimming is not generally possible in cases where
-+ the main arena is obtained via mmap.
-+
-+ Note that the trick some people use of mallocing a huge space and
-+ then freeing it at program startup, in an attempt to reserve system
-+ memory, doesn't have the intended effect under automatic trimming,
-+ since that memory will immediately be returned to the system.
-+*/
-+
-+#define M_TRIM_THRESHOLD -1
-+
-+#ifndef DEFAULT_TRIM_THRESHOLD
-+#define DEFAULT_TRIM_THRESHOLD (128 * 1024)
-+#endif
-+
-+/*
-+ M_TOP_PAD is the amount of extra `padding' space to allocate or
-+ retain whenever sbrk is called. It is used in two ways internally:
-+
-+ * When sbrk is called to extend the top of the arena to satisfy
-+ a new malloc request, this much padding is added to the sbrk
-+ request.
-+
-+ * When malloc_trim is called automatically from free(),
-+ it is used as the `pad' argument.
-+
-+ In both cases, the actual amount of padding is rounded
-+ so that the end of the arena is always a system page boundary.
-+
-+ The main reason for using padding is to avoid calling sbrk so
-+ often. Having even a small pad greatly reduces the likelihood
-+ that nearly every malloc request during program start-up (or
-+ after trimming) will invoke sbrk, which needlessly wastes
-+ time.
-+
-+ Automatic rounding-up to page-size units is normally sufficient
-+ to avoid measurable overhead, so the default is 0. However, in
-+ systems where sbrk is relatively slow, it can pay to increase
-+ this value, at the expense of carrying around more memory than
-+ the program needs.
-+*/
-+
-+#define M_TOP_PAD -2
-+
-+#ifndef DEFAULT_TOP_PAD
-+#define DEFAULT_TOP_PAD (0)
-+#endif
-+
-+/*
-+ M_MMAP_THRESHOLD is the request size threshold for using mmap()
-+ to service a request. Requests of at least this size that cannot
-+ be allocated using already-existing space will be serviced via mmap.
-+ (If enough normal freed space already exists it is used instead.)
-+
-+ Using mmap segregates relatively large chunks of memory so that
-+ they can be individually obtained and released from the host
-+ system. A request serviced through mmap is never reused by any
-+ other request (at least not directly; the system may just so
-+ happen to remap successive requests to the same locations).
-+
-+ Segregating space in this way has the benefits that:
-+
-+ 1. Mmapped space can ALWAYS be individually released back
-+ to the system, which helps keep the system level memory
-+ demands of a long-lived program low.
-+ 2. Mapped memory can never become `locked' between
-+ other chunks, as can happen with normally allocated chunks, which
-+ means that even trimming via malloc_trim would not release them.
-+ 3. On some systems with "holes" in address spaces, mmap can obtain
-+ memory that sbrk cannot.
-+
-+ However, it has the disadvantages that:
-+
-+ 1. The space cannot be reclaimed, consolidated, and then
-+ used to service later requests, as happens with normal chunks.
-+ 2. It can lead to more wastage because of mmap page alignment
-+ requirements
-+ 3. It causes malloc performance to be more dependent on host
-+ system memory management support routines which may vary in
-+ implementation quality and may impose arbitrary
-+ limitations. Generally, servicing a request via normal
-+ malloc steps is faster than going through a system's mmap.
-+
-+ The advantages of mmap nearly always outweigh disadvantages for
-+ "large" chunks, but the value of "large" varies across systems. The
-+ default is an empirically derived value that works well in most
-+ systems.
-+*/
-+
-+#define M_MMAP_THRESHOLD -3
-+
-+#ifndef DEFAULT_MMAP_THRESHOLD
-+#define DEFAULT_MMAP_THRESHOLD (128 * 1024)
-+#endif
-+
-+/*
-+ M_MMAP_MAX is the maximum number of requests to simultaneously
-+ service using mmap. This parameter exists because
-+. Some systems have a limited number of internal tables for
-+ use by mmap, and using more than a few of them may degrade
-+ performance.
-+
-+ The default is set to a value that serves only as a safeguard.
-+ Setting to 0 disables use of mmap for servicing large requests. If
-+ HAVE_MMAP is not set, the default value is 0, and attempts to set it
-+ to non-zero values in mallopt will fail.
-+*/
-+
-+#define M_MMAP_MAX -4
-+
-+#ifndef DEFAULT_MMAP_MAX
-+#if HAVE_MMAP
-+#define DEFAULT_MMAP_MAX (65536)
-+#else
-+#define DEFAULT_MMAP_MAX (0)
-+#endif
-+#endif
-+
-+#ifdef __cplusplus
-+}; /* end of extern "C" */
-+#endif
-+
-+/*
-+ ========================================================================
-+ To make a fully customizable malloc.h header file, cut everything
-+ above this line, put into file malloc.h, edit to suit, and #include it
-+ on the next line, as well as in programs that use this malloc.
-+ ========================================================================
-+*/
-+
-+/* #include "malloc.h" */
-+
-+/* --------------------- public wrappers ---------------------- */
-+
-+#ifdef USE_PUBLIC_MALLOC_WRAPPERS
-+
-+/* Declare all routines as internal */
-+#if __STD_C
-+static Void_t* mALLOc(size_t);
-+static void fREe(Void_t*);
-+static Void_t* rEALLOc(Void_t*, size_t);
-+static Void_t* mEMALIGn(size_t, size_t);
-+static Void_t* vALLOc(size_t);
-+static Void_t* pVALLOc(size_t);
-+static Void_t* cALLOc(size_t, size_t);
-+static Void_t** iCALLOc(size_t, size_t, Void_t**);
-+static Void_t** iCOMALLOc(size_t, size_t*, Void_t**);
-+static void cFREe(Void_t*);
-+static int mTRIm(size_t);
-+static size_t mUSABLe(Void_t*);
-+static void mSTATs();
-+static int mALLOPt(int, int);
-+static struct mallinfo mALLINFo(void);
-+#else
-+static Void_t* mALLOc();
-+static void fREe();
-+static Void_t* rEALLOc();
-+static Void_t* mEMALIGn();
-+static Void_t* vALLOc();
-+static Void_t* pVALLOc();
-+static Void_t* cALLOc();
-+static Void_t** iCALLOc();
-+static Void_t** iCOMALLOc();
-+static void cFREe();
-+static int mTRIm();
-+static size_t mUSABLe();
-+static void mSTATs();
-+static int mALLOPt();
-+static struct mallinfo mALLINFo();
-+#endif
-+
-+/*
-+ MALLOC_PREACTION and MALLOC_POSTACTION should be
-+ defined to return 0 on success, and nonzero on failure.
-+ The return value of MALLOC_POSTACTION is currently ignored
-+ in wrapper functions since there is no reasonable default
-+ action to take on failure.
-+*/
-+
-+
-+#ifdef USE_MALLOC_LOCK
-+
-+#ifdef WIN32
-+
-+static int mALLOC_MUTEx;
-+#define MALLOC_PREACTION slwait(&mALLOC_MUTEx)
-+#define MALLOC_POSTACTION slrelease(&mALLOC_MUTEx)
-+
-+#else
-+
-+#if 0
-+#include <pthread.h>
-+
-+static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER;
-+
-+#define MALLOC_PREACTION pthread_mutex_lock(&mALLOC_MUTEx)
-+#define MALLOC_POSTACTION pthread_mutex_unlock(&mALLOC_MUTEx)
-+
-+#else
-+
-+#ifdef KDE_MALLOC_X86
-+#include "x86.h"
-+#elif defined(KDE_MALLOC_AVR32)
-+
-+#include <sched.h>
-+#include <time.h>
-+
-+static __inline__ int q_atomic_swp(volatile unsigned int *ptr,
-+ unsigned int newval)
-+{
-+ register int ret;
-+ asm volatile("xchg %0,%1,%2"
-+ : "=&r"(ret)
-+ : "r"(ptr), "r"(newval)
-+ : "memory", "cc");
-+ return ret;
-+}
-+
-+typedef struct {
-+ volatile unsigned int lock;
-+ int pad0_;
-+} mutex_t;
-+
-+#define MUTEX_INITIALIZER { 0, 0 }
-+
-+static __inline__ int lock(mutex_t *m) {
-+ int cnt = 0;
-+ struct timespec tm;
-+
-+ for(;;) {
-+ if (q_atomic_swp(&m->lock, 1) == 0)
-+ return 0;
-+#ifdef _POSIX_PRIORITY_SCHEDULING
-+ if(cnt < 50) {
-+ sched_yield();
-+ cnt++;
-+ } else
-+#endif
-+ {
-+ tm.tv_sec = 0;
-+ tm.tv_nsec = 2000001;
-+ nanosleep(&tm, NULL);
-+ cnt = 0;
-+ }
-+ }
-+}
-+
-+static __inline__ int unlock(mutex_t *m) {
-+ m->lock = 0;
-+ return 0;
-+}
-+
-+#else
-+#error Unknown spinlock implementation
-+#endif
-+
-+static mutex_t spinlock = MUTEX_INITIALIZER;
-+
-+#define MALLOC_PREACTION lock( &spinlock )
-+#define MALLOC_POSTACTION unlock( &spinlock )
-+
-+#endif
-+
-+#endif /* USE_MALLOC_LOCK */
-+
-+#else
-+
-+/* Substitute anything you like for these */
-+
-+#define MALLOC_PREACTION (0)
-+#define MALLOC_POSTACTION (0)
-+
-+#endif
-+
-+#if 0
-+Void_t* public_mALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+void public_fREe(Void_t* m) {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ fREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = rEALLOc(m, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mEMALIGn(alignment, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_vALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = vALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_pVALLOc(size_t bytes) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = pVALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t* public_cALLOc(size_t n, size_t elem_size) {
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = cALLOc(n, elem_size);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+
-+Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {
-+ Void_t** m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = iCALLOc(n, elem_size, chunks);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {
-+ Void_t** m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = iCOMALLOc(n, sizes, chunks);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+void public_cFREe(Void_t* m) {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ cFREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+int public_mTRIm(size_t s) {
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mTRIm(s);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+
-+size_t public_mUSABLe(Void_t* m) {
-+ size_t result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mUSABLe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+
-+void public_mSTATs() {
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ mSTATs();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+}
-+
-+struct mallinfo public_mALLINFo() {
-+ struct mallinfo m;
-+ if (MALLOC_PREACTION != 0) {
-+ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-+ return nm;
-+ }
-+ m = mALLINFo();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+}
-+
-+int public_mALLOPt(int p, int v) {
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mALLOPt(p, v);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+}
-+#endif
-+
-+#endif
-+
-+
-+
-+/* ------------- Optional versions of memcopy ---------------- */
-+
-+
-+#if USE_MEMCPY
-+
-+/*
-+ Note: memcpy is ONLY invoked with non-overlapping regions,
-+ so the (usually slower) memmove is not needed.
-+*/
-+
-+#define MALLOC_COPY(dest, src, nbytes) memcpy(dest, src, nbytes)
-+#define MALLOC_ZERO(dest, nbytes) memset(dest, 0, nbytes)
-+
-+#else /* !USE_MEMCPY */
-+
-+/* Use Duff's device for good zeroing/copying performance. */
-+
-+#define MALLOC_ZERO(charp, nbytes) \
-+do { \
-+ INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \
-+ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
-+ long mcn; \
-+ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
-+ switch (mctmp) { \
-+ case 0: for(;;) { *mzp++ = 0; \
-+ case 7: *mzp++ = 0; \
-+ case 6: *mzp++ = 0; \
-+ case 5: *mzp++ = 0; \
-+ case 4: *mzp++ = 0; \
-+ case 3: *mzp++ = 0; \
-+ case 2: *mzp++ = 0; \
-+ case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \
-+ } \
-+} while(0)
-+
-+#define MALLOC_COPY(dest,src,nbytes) \
-+do { \
-+ INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \
-+ INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \
-+ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
-+ long mcn; \
-+ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
-+ switch (mctmp) { \
-+ case 0: for(;;) { *mcdst++ = *mcsrc++; \
-+ case 7: *mcdst++ = *mcsrc++; \
-+ case 6: *mcdst++ = *mcsrc++; \
-+ case 5: *mcdst++ = *mcsrc++; \
-+ case 4: *mcdst++ = *mcsrc++; \
-+ case 3: *mcdst++ = *mcsrc++; \
-+ case 2: *mcdst++ = *mcsrc++; \
-+ case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \
-+ } \
-+} while(0)
-+
-+#endif
-+
-+/* ------------------ MMAP support ------------------ */
-+
-+
-+#if HAVE_MMAP
-+
-+#include <fcntl.h>
-+#ifndef LACKS_SYS_MMAN_H
-+#include <sys/mman.h>
-+#endif
-+
-+#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
-+#define MAP_ANONYMOUS MAP_ANON
-+#endif
-+
-+/*
-+ Nearly all versions of mmap support MAP_ANONYMOUS,
-+ so the following is unlikely to be needed, but is
-+ supplied just in case.
-+*/
-+
-+#ifndef MAP_ANONYMOUS
-+
-+static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
-+
-+#define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? \
-+ (dev_zero_fd = open("/dev/zero", O_RDWR), \
-+ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : \
-+ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0))
-+
-+#else
-+
-+#define MMAP(addr, size, prot, flags) \
-+ (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0))
-+
-+#endif
-+
-+
-+#endif /* HAVE_MMAP */
-+
-+
-+/*
-+ ----------------------- Chunk representations -----------------------
-+*/
-+
-+
-+/*
-+ This struct declaration is misleading (but accurate and necessary).
-+ It declares a "view" into memory allowing access to necessary
-+ fields at known offsets from a given base. See explanation below.
-+*/
-+
-+struct malloc_chunk {
-+
-+ INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
-+ INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
-+
-+ struct malloc_chunk* fd; /* double links -- used only if free. */
-+ struct malloc_chunk* bk;
-+};
-+
-+
-+typedef struct malloc_chunk* mchunkptr;
-+
-+/*
-+ malloc_chunk details:
-+
-+ (The following includes lightly edited explanations by Colin Plumb.)
-+
-+ Chunks of memory are maintained using a `boundary tag' method as
-+ described in e.g., Knuth or Standish. (See the paper by Paul
-+ Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
-+ survey of such techniques.) Sizes of free chunks are stored both
-+ in the front of each chunk and at the end. This makes
-+ consolidating fragmented chunks into bigger chunks very fast. The
-+ size fields also hold bits representing whether chunks are free or
-+ in use.
-+
-+ An allocated chunk looks like this:
-+
-+
-+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of previous chunk, if allocated | |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of chunk, in bytes |P|
-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | User data starts here... .
-+ . .
-+ . (malloc_usable_space() bytes) .
-+ . |
-+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of chunk |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+
-+
-+ Where "chunk" is the front of the chunk for the purpose of most of
-+ the malloc code, but "mem" is the pointer that is returned to the
-+ user. "Nextchunk" is the beginning of the next contiguous chunk.
-+
-+ Chunks always begin on even word boundaries, so the mem portion
-+ (which is returned to the user) is also on an even word boundary, and
-+ thus at least double-word aligned.
-+
-+ Free chunks are stored in circular doubly-linked lists, and look like this:
-+
-+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Size of previous chunk |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ `head:' | Size of chunk, in bytes |P|
-+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Forward pointer to next chunk in list |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Back pointer to previous chunk in list |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ | Unused space (may be 0 bytes long) .
-+ . .
-+ . |
-+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+ `foot:' | Size of chunk, in bytes |
-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-+
-+ The P (PREV_INUSE) bit, stored in the unused low-order bit of the
-+ chunk size (which is always a multiple of two words), is an in-use
-+ bit for the *previous* chunk. If that bit is *clear*, then the
-+ word before the current chunk size contains the previous chunk
-+ size, and can be used to find the front of the previous chunk.
-+ The very first chunk allocated always has this bit set,
-+ preventing access to non-existent (or non-owned) memory. If
-+ prev_inuse is set for any given chunk, then you CANNOT determine
-+ the size of the previous chunk, and might even get a memory
-+ addressing fault when trying to do so.
-+
-+ Note that the `foot' of the current chunk is actually represented
-+ as the prev_size of the NEXT chunk. This makes it easier to
-+ deal with alignments etc but can be very confusing when trying
-+ to extend or adapt this code.
-+
-+ The two exceptions to all this are
-+
-+ 1. The special chunk `top' doesn't bother using the
-+ trailing size field since there is no next contiguous chunk
-+ that would have to index off it. After initialization, `top'
-+ is forced to always exist. If it would become less than
-+ MINSIZE bytes long, it is replenished.
-+
-+ 2. Chunks allocated via mmap, which have the second-lowest-order
-+ bit (IS_MMAPPED) set in their size fields. Because they are
-+ allocated one-by-one, each must contain its own trailing size field.
-+
-+*/
-+
-+/*
-+ ---------- Size and alignment checks and conversions ----------
-+*/
-+
-+/* conversion from malloc headers to user pointers, and back */
-+
-+#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ))
-+#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
-+
-+/* The smallest possible chunk */
-+#define MIN_CHUNK_SIZE (sizeof(struct malloc_chunk))
-+
-+/* The smallest size we can malloc is an aligned minimal chunk */
-+
-+#define MINSIZE \
-+ (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
-+
-+/* Check if m has acceptable alignment */
-+
-+#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
-+
-+
-+/*
-+ Check if a request is so large that it would wrap around zero when
-+ padded and aligned. To simplify some other code, the bound is made
-+ low enough so that adding MINSIZE will also not wrap around zero.
-+*/
-+
-+#define REQUEST_OUT_OF_RANGE(req) \
-+ ((unsigned long)(req) >= \
-+ (unsigned long)(INTERNAL_SIZE_T)(-2 * MINSIZE))
-+
-+/* pad request bytes into a usable size -- internal version */
-+
-+#define request2size(req) \
-+ (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \
-+ MINSIZE : \
-+ ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
-+
-+/* Same, except also perform argument check */
-+
-+#define checked_request2size(req, sz) \
-+ if (REQUEST_OUT_OF_RANGE(req)) { \
-+ MALLOC_FAILURE_ACTION; \
-+ return 0; \
-+ } \
-+ (sz) = request2size(req);
-+
-+/*
-+ --------------- Physical chunk operations ---------------
-+*/
-+
-+
-+/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
-+#define PREV_INUSE 0x1
-+
-+/* extract inuse bit of previous chunk */
-+#define prev_inuse(p) ((p)->size & PREV_INUSE)
-+
-+
-+/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
-+#define IS_MMAPPED 0x2
-+
-+/* check for mmap()'ed chunk */
-+#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
-+
-+/*
-+ Bits to mask off when extracting size
-+
-+ Note: IS_MMAPPED is intentionally not masked off from size field in
-+ macros for which mmapped chunks should never be seen. This should
-+ cause helpful core dumps to occur if it is tried by accident by
-+ people extending or adapting this malloc.
-+*/
-+#define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
-+
-+/* Get size, ignoring use bits */
-+#define chunksize(p) ((p)->size & ~(SIZE_BITS))
-+
-+
-+/* Ptr to next physical malloc_chunk. */
-+#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
-+
-+/* Ptr to previous physical malloc_chunk */
-+#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
-+
-+/* Treat space at ptr + offset as a chunk */
-+#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
-+
-+/* extract p's inuse bit */
-+#define inuse(p)\
-+((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
-+
-+/* set/clear chunk as being inuse without otherwise disturbing */
-+#define set_inuse(p)\
-+((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
-+
-+#define clear_inuse(p)\
-+((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
-+
-+
-+/* check/set/clear inuse bits in known places */
-+#define inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
-+
-+#define set_inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
-+
-+#define clear_inuse_bit_at_offset(p, s)\
-+ (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
-+
-+
-+/* Set size at head, without disturbing its use bit */
-+#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s)))
-+
-+/* Set size/use field */
-+#define set_head(p, s) ((p)->size = (s))
-+
-+/* Set size at footer (only when chunk is not in use) */
-+#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
-+
-+
-+/*
-+ -------------------- Internal data structures --------------------
-+
-+ All internal state is held in an instance of malloc_state defined
-+ below. There are no other static variables, except in two optional
-+ cases:
-+ * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
-+ * If HAVE_MMAP is true, but mmap doesn't support
-+ MAP_ANONYMOUS, a dummy file descriptor for mmap.
-+
-+ Beware of lots of tricks that minimize the total bookkeeping space
-+ requirements. The result is a little over 1K bytes (for 4byte
-+ pointers and size_t.)
-+*/
-+
-+/*
-+ Bins
-+
-+ An array of bin headers for free chunks. Each bin is doubly
-+ linked. The bins are approximately proportionally (log) spaced.
-+ There are a lot of these bins (128). This may look excessive, but
-+ works very well in practice. Most bins hold sizes that are
-+ unusual as malloc request sizes, but are more usual for fragments
-+ and consolidated sets of chunks, which is what these bins hold, so
-+ they can be found quickly. All procedures maintain the invariant
-+ that no consolidated chunk physically borders another one, so each
-+ chunk in a list is known to be preceded and followed by either
-+ inuse chunks or the ends of memory.
-+
-+ Chunks in bins are kept in size order, with ties going to the
-+ approximately least recently used chunk. Ordering isn't needed
-+ for the small bins, which all contain the same-sized chunks, but
-+ facilitates best-fit allocation for larger chunks. These lists
-+ are just sequential. Keeping them in order almost never requires
-+ enough traversal to warrant using fancier ordered data
-+ structures.
-+
-+ Chunks of the same size are linked with the most
-+ recently freed at the front, and allocations are taken from the
-+ back. This results in LRU (FIFO) allocation order, which tends
-+ to give each chunk an equal opportunity to be consolidated with
-+ adjacent freed chunks, resulting in larger free chunks and less
-+ fragmentation.
-+
-+ To simplify use in double-linked lists, each bin header acts
-+ as a malloc_chunk. This avoids special-casing for headers.
-+ But to conserve space and improve locality, we allocate
-+ only the fd/bk pointers of bins, and then use repositioning tricks
-+ to treat these as the fields of a malloc_chunk*.
-+*/
-+
-+typedef struct malloc_chunk* mbinptr;
-+
-+/* addressing -- note that bin_at(0) does not exist */
-+#define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1)))
-+
-+/* analog of ++bin */
-+#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
-+
-+/* Reminders about list directionality within bins */
-+#define first(b) ((b)->fd)
-+#define last(b) ((b)->bk)
-+
-+/* Take a chunk off a bin list */
-+#define unlink(P, BK, FD) { \
-+ FD = P->fd; \
-+ BK = P->bk; \
-+ FD->bk = BK; \
-+ BK->fd = FD; \
-+}
-+
-+/*
-+ Indexing
-+
-+ Bins for sizes < 512 bytes contain chunks of all the same size, spaced
-+ 8 bytes apart. Larger bins are approximately logarithmically spaced:
-+
-+ 64 bins of size 8
-+ 32 bins of size 64
-+ 16 bins of size 512
-+ 8 bins of size 4096
-+ 4 bins of size 32768
-+ 2 bins of size 262144
-+ 1 bin of size what's left
-+
-+ There is actually a little bit of slop in the numbers in bin_index
-+ for the sake of speed. This makes no difference elsewhere.
-+
-+ The bins top out around 1MB because we expect to service large
-+ requests via mmap.
-+*/
-+
-+#define NBINS 128
-+#define NSMALLBINS 64
-+#define SMALLBIN_WIDTH 8
-+#define MIN_LARGE_SIZE 512
-+
-+#define in_smallbin_range(sz) \
-+ ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
-+
-+#define smallbin_index(sz) (((unsigned)(sz)) >> 3)
-+
-+#define largebin_index(sz) \
-+(((((unsigned long)(sz)) >> 6) <= 32)? 56 + (((unsigned long)(sz)) >> 6): \
-+ ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
-+ ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
-+ ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
-+ ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
-+ 126)
-+
-+#define bin_index(sz) \
-+ ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
-+
-+
-+/*
-+ Unsorted chunks
-+
-+ All remainders from chunk splits, as well as all returned chunks,
-+ are first placed in the "unsorted" bin. They are then placed
-+ in regular bins after malloc gives them ONE chance to be used before
-+ binning. So, basically, the unsorted_chunks list acts as a queue,
-+ with chunks being placed on it in free (and malloc_consolidate),
-+ and taken off (to be either used or placed in bins) in malloc.
-+*/
-+
-+/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
-+#define unsorted_chunks(M) (bin_at(M, 1))
-+
-+/*
-+ Top
-+
-+ The top-most available chunk (i.e., the one bordering the end of
-+ available memory) is treated specially. It is never included in
-+ any bin, is used only if no other chunk is available, and is
-+ released back to the system if it is very large (see
-+ M_TRIM_THRESHOLD). Because top initially
-+ points to its own bin with initial zero size, thus forcing
-+ extension on the first malloc request, we avoid having any special
-+ code in malloc to check whether it even exists yet. But we still
-+ need to do so when getting memory from system, so we make
-+ initial_top treat the bin as a legal but unusable chunk during the
-+ interval between initialization and the first call to
-+ sYSMALLOc. (This is somewhat delicate, since it relies on
-+ the 2 preceding words to be zero during this interval as well.)
-+*/
-+
-+/* Conveniently, the unsorted bin can be used as dummy top on first call */
-+#define initial_top(M) (unsorted_chunks(M))
-+
-+/*
-+ Binmap
-+
-+ To help compensate for the large number of bins, a one-level index
-+ structure is used for bin-by-bin searching. `binmap' is a
-+ bitvector recording whether bins are definitely empty so they can
-+ be skipped over during during traversals. The bits are NOT always
-+ cleared as soon as bins are empty, but instead only
-+ when they are noticed to be empty during traversal in malloc.
-+*/
-+
-+/* Conservatively use 32 bits per map word, even if on 64bit system */
-+#define BINMAPSHIFT 5
-+#define BITSPERMAP (1U << BINMAPSHIFT)
-+#define BINMAPSIZE (NBINS / BITSPERMAP)
-+
-+#define idx2block(i) ((i) >> BINMAPSHIFT)
-+#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
-+
-+#define mark_bin(m,i) ((m)->binmap[idx2block(i)] |= idx2bit(i))
-+#define unmark_bin(m,i) ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
-+#define get_binmap(m,i) ((m)->binmap[idx2block(i)] & idx2bit(i))
-+
-+/*
-+ Fastbins
-+
-+ An array of lists holding recently freed small chunks. Fastbins
-+ are not doubly linked. It is faster to single-link them, and
-+ since chunks are never removed from the middles of these lists,
-+ double linking is not necessary. Also, unlike regular bins, they
-+ are not even processed in FIFO order (they use faster LIFO) since
-+ ordering doesn't much matter in the transient contexts in which
-+ fastbins are normally used.
-+
-+ Chunks in fastbins keep their inuse bit set, so they cannot
-+ be consolidated with other free chunks. malloc_consolidate
-+ releases all chunks in fastbins and consolidates them with
-+ other free chunks.
-+*/
-+
-+typedef struct malloc_chunk* mfastbinptr;
-+
-+/* offset 2 to use otherwise unindexable first 2 bins */
-+#define fastbin_index(sz) ((((unsigned int)(sz)) >> 3) - 2)
-+
-+/* The maximum fastbin request size we support */
-+#define MAX_FAST_SIZE 80
-+
-+#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE))+1)
-+
-+/*
-+ FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
-+ that triggers automatic consolidation of possibly-surrounding
-+ fastbin chunks. This is a heuristic, so the exact value should not
-+ matter too much. It is defined at half the default trim threshold as a
-+ compromise heuristic to only attempt consolidation if it is likely
-+ to lead to trimming. However, it is not dynamically tunable, since
-+ consolidation reduces fragmentation surrounding loarge chunks even
-+ if trimming is not used.
-+*/
-+
-+#define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL)
-+
-+/*
-+ Since the lowest 2 bits in max_fast don't matter in size comparisons,
-+ they are used as flags.
-+*/
-+
-+/*
-+ FASTCHUNKS_BIT held in max_fast indicates that there are probably
-+ some fastbin chunks. It is set true on entering a chunk into any
-+ fastbin, and cleared only in malloc_consolidate.
-+
-+ The truth value is inverted so that have_fastchunks will be true
-+ upon startup (since statics are zero-filled), simplifying
-+ initialization checks.
-+*/
-+
-+#define FASTCHUNKS_BIT (1U)
-+
-+#define have_fastchunks(M) (((M)->max_fast & FASTCHUNKS_BIT) == 0)
-+#define clear_fastchunks(M) ((M)->max_fast |= FASTCHUNKS_BIT)
-+#define set_fastchunks(M) ((M)->max_fast &= ~FASTCHUNKS_BIT)
-+
-+/*
-+ NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
-+ regions. Otherwise, contiguity is exploited in merging together,
-+ when possible, results from consecutive MORECORE calls.
-+
-+ The initial value comes from MORECORE_CONTIGUOUS, but is
-+ changed dynamically if mmap is ever used as an sbrk substitute.
-+*/
-+
-+#define NONCONTIGUOUS_BIT (2U)
-+
-+#define contiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) == 0)
-+#define noncontiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) != 0)
-+#define set_noncontiguous(M) ((M)->max_fast |= NONCONTIGUOUS_BIT)
-+#define set_contiguous(M) ((M)->max_fast &= ~NONCONTIGUOUS_BIT)
-+
-+/*
-+ Set value of max_fast.
-+ Use impossibly small value if 0.
-+ Precondition: there are no existing fastbin chunks.
-+ Setting the value clears fastchunk bit but preserves noncontiguous bit.
-+*/
-+
-+#define set_max_fast(M, s) \
-+ (M)->max_fast = (((s) == 0)? SMALLBIN_WIDTH: request2size(s)) | \
-+ FASTCHUNKS_BIT | \
-+ ((M)->max_fast & NONCONTIGUOUS_BIT)
-+
-+
-+/*
-+ ----------- Internal state representation and initialization -----------
-+*/
-+
-+struct malloc_state {
-+
-+ /* The maximum chunk size to be eligible for fastbin */
-+ INTERNAL_SIZE_T max_fast; /* low 2 bits used as flags */
-+
-+ /* Fastbins */
-+ mfastbinptr fastbins[NFASTBINS];
-+
-+ /* Base of the topmost chunk -- not otherwise kept in a bin */
-+ mchunkptr top;
-+
-+ /* The remainder from the most recent split of a small request */
-+ mchunkptr last_remainder;
-+
-+ /* Normal bins packed as described above */
-+ mchunkptr bins[NBINS * 2];
-+
-+ /* Bitmap of bins */
-+ unsigned int binmap[BINMAPSIZE];
-+
-+ /* Tunable parameters */
-+ unsigned long trim_threshold;
-+ INTERNAL_SIZE_T top_pad;
-+ INTERNAL_SIZE_T mmap_threshold;
-+
-+ /* Memory map support */
-+ int n_mmaps;
-+ int n_mmaps_max;
-+ int max_n_mmaps;
-+
-+ /* Cache malloc_getpagesize */
-+ unsigned int pagesize;
-+
-+ /* Statistics */
-+ INTERNAL_SIZE_T mmapped_mem;
-+ INTERNAL_SIZE_T sbrked_mem;
-+ INTERNAL_SIZE_T max_sbrked_mem;
-+ INTERNAL_SIZE_T max_mmapped_mem;
-+ INTERNAL_SIZE_T max_total_mem;
-+};
-+
-+typedef struct malloc_state *mstate;
-+
-+/*
-+ There is exactly one instance of this struct in this malloc.
-+ If you are adapting this malloc in a way that does NOT use a static
-+ malloc_state, you MUST explicitly zero-fill it before using. This
-+ malloc relies on the property that malloc_state is initialized to
-+ all zeroes (as is true of C statics).
-+*/
-+
-+static struct malloc_state av_; /* never directly referenced */
-+
-+/*
-+ All uses of av_ are via get_malloc_state().
-+ At most one "call" to get_malloc_state is made per invocation of
-+ the public versions of malloc and free, but other routines
-+ that in turn invoke malloc and/or free may call more then once.
-+ Also, it is called in check* routines if DEBUG is set.
-+*/
-+
-+#define get_malloc_state() (&(av_))
-+
-+/*
-+ Initialize a malloc_state struct.
-+
-+ This is called only from within malloc_consolidate, which needs
-+ be called in the same contexts anyway. It is never called directly
-+ outside of malloc_consolidate because some optimizing compilers try
-+ to inline it at all call points, which turns out not to be an
-+ optimization at all. (Inlining it in malloc_consolidate is fine though.)
-+*/
-+
-+#if __STD_C
-+static void malloc_init_state(mstate av)
-+#else
-+static void malloc_init_state(av) mstate av;
-+#endif
-+{
-+ int i;
-+ mbinptr bin;
-+
-+ /* Establish circular links for normal bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ bin = bin_at(av,i);
-+ bin->fd = bin->bk = bin;
-+ }
-+
-+ av->top_pad = DEFAULT_TOP_PAD;
-+ av->n_mmaps_max = DEFAULT_MMAP_MAX;
-+ av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
-+ av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
-+
-+#if !MORECORE_CONTIGUOUS
-+ set_noncontiguous(av);
-+#endif
-+
-+ set_max_fast(av, DEFAULT_MXFAST);
-+
-+ av->top = initial_top(av);
-+ av->pagesize = malloc_getpagesize;
-+}
-+
-+/*
-+ Other internal utilities operating on mstates
-+*/
-+
-+#if __STD_C
-+static Void_t* sYSMALLOc(INTERNAL_SIZE_T, mstate);
-+static int sYSTRIm(size_t, mstate);
-+static void malloc_consolidate(mstate);
-+static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
-+#else
-+static Void_t* sYSMALLOc();
-+static int sYSTRIm();
-+static void malloc_consolidate();
-+static Void_t** iALLOc();
-+#endif
-+
-+/*
-+ Debugging support
-+
-+ These routines make a number of assertions about the states
-+ of data structures that should be true at all times. If any
-+ are not true, it's very likely that a user program has somehow
-+ trashed memory. (It's also possible that there is a coding error
-+ in malloc. In which case, please report it!)
-+*/
-+
-+#ifndef DEBUG
-+
-+#define check_chunk(P)
-+#define check_free_chunk(P)
-+#define check_inuse_chunk(P)
-+#define check_remalloced_chunk(P,N)
-+#define check_malloced_chunk(P,N)
-+#define check_malloc_state()
-+
-+#else
-+#define check_chunk(P) do_check_chunk(P)
-+#define check_free_chunk(P) do_check_free_chunk(P)
-+#define check_inuse_chunk(P) do_check_inuse_chunk(P)
-+#define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N)
-+#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
-+#define check_malloc_state() do_check_malloc_state()
-+
-+/*
-+ Properties of all chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_chunk(mchunkptr p)
-+#else
-+static void do_check_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ unsigned long sz = chunksize(p);
-+ /* min and max possible addresses assuming contiguous allocation */
-+ char* max_address = (char*)(av->top) + chunksize(av->top);
-+ char* min_address = max_address - av->sbrked_mem;
-+
-+ if (!chunk_is_mmapped(p)) {
-+
-+ /* Has legal address ... */
-+ if (p != av->top) {
-+ if (contiguous(av)) {
-+ assert(((char*)p) >= min_address);
-+ assert(((char*)p + sz) <= ((char*)(av->top)));
-+ }
-+ }
-+ else {
-+ /* top size is always at least MINSIZE */
-+ assert((unsigned long)(sz) >= MINSIZE);
-+ /* top predecessor always marked inuse */
-+ assert(prev_inuse(p));
-+ }
-+
-+ }
-+ else {
-+#if HAVE_MMAP
-+ /* address is outside main heap */
-+ if (contiguous(av) && av->top != initial_top(av)) {
-+ assert(((char*)p) < min_address || ((char*)p) > max_address);
-+ }
-+ /* chunk is page-aligned */
-+ assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
-+ /* mem is aligned */
-+ assert(aligned_OK(chunk2mem(p)));
-+#else
-+ /* force an appropriate assert violation if debug set */
-+ assert(!chunk_is_mmapped(p));
-+#endif
-+ }
-+}
-+
-+/*
-+ Properties of free chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_free_chunk(mchunkptr p)
-+#else
-+static void do_check_free_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
-+ mchunkptr next = chunk_at_offset(p, sz);
-+
-+ do_check_chunk(p);
-+
-+ /* Chunk must claim to be free ... */
-+ assert(!inuse(p));
-+ assert (!chunk_is_mmapped(p));
-+
-+ /* Unless a special marker, must have OK fields */
-+ if ((unsigned long)(sz) >= MINSIZE)
-+ {
-+ assert((sz & MALLOC_ALIGN_MASK) == 0);
-+ assert(aligned_OK(chunk2mem(p)));
-+ /* ... matching footer field */
-+ assert(next->prev_size == sz);
-+ /* ... and is fully consolidated */
-+ assert(prev_inuse(p));
-+ assert (next == av->top || inuse(next));
-+
-+ /* ... and has minimally sane links */
-+ assert(p->fd->bk == p);
-+ assert(p->bk->fd == p);
-+ }
-+ else /* markers are always of size SIZE_SZ */
-+ assert(sz == SIZE_SZ);
-+}
-+
-+/*
-+ Properties of inuse chunks
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_inuse_chunk(mchunkptr p)
-+#else
-+static void do_check_inuse_chunk(p) mchunkptr p;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ mchunkptr next;
-+ do_check_chunk(p);
-+
-+ if (chunk_is_mmapped(p))
-+ return; /* mmapped chunks have no next/prev */
-+
-+ /* Check whether it claims to be in use ... */
-+ assert(inuse(p));
-+
-+ next = next_chunk(p);
-+
-+ /* ... and is surrounded by OK chunks.
-+ Since more things can be checked with free chunks than inuse ones,
-+ if an inuse chunk borders them and debug is on, it's worth doing them.
-+ */
-+ if (!prev_inuse(p)) {
-+ /* Note that we cannot even look at prev unless it is not inuse */
-+ mchunkptr prv = prev_chunk(p);
-+ assert(next_chunk(prv) == p);
-+ do_check_free_chunk(prv);
-+ }
-+
-+ if (next == av->top) {
-+ assert(prev_inuse(next));
-+ assert(chunksize(next) >= MINSIZE);
-+ }
-+ else if (!inuse(next))
-+ do_check_free_chunk(next);
-+}
-+
-+/*
-+ Properties of chunks recycled from fastbins
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
-+#else
-+static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
-+#endif
-+{
-+ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
-+
-+ do_check_inuse_chunk(p);
-+
-+ /* Legal size ... */
-+ assert((sz & MALLOC_ALIGN_MASK) == 0);
-+ assert((unsigned long)(sz) >= MINSIZE);
-+ /* ... and alignment */
-+ assert(aligned_OK(chunk2mem(p)));
-+ /* chunk is less than MINSIZE more than request */
-+ assert((long)(sz) - (long)(s) >= 0);
-+ assert((long)(sz) - (long)(s + MINSIZE) < 0);
-+}
-+
-+/*
-+ Properties of nonrecycled chunks at the point they are malloced
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
-+#else
-+static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
-+#endif
-+{
-+ /* same as recycled case ... */
-+ do_check_remalloced_chunk(p, s);
-+
-+ /*
-+ ... plus, must obey implementation invariant that prev_inuse is
-+ always true of any allocated chunk; i.e., that each allocated
-+ chunk borders either a previously allocated and still in-use
-+ chunk, or the base of its memory arena. This is ensured
-+ by making all allocations from the the `lowest' part of any found
-+ chunk. This does not necessarily hold however for chunks
-+ recycled via fastbins.
-+ */
-+
-+ assert(prev_inuse(p));
-+}
-+
-+
-+/*
-+ Properties of malloc_state.
-+
-+ This may be useful for debugging malloc, as well as detecting user
-+ programmer errors that somehow write into malloc_state.
-+
-+ If you are extending or experimenting with this malloc, you can
-+ probably figure out how to hack this routine to print out or
-+ display chunk addresses, sizes, bins, and other instrumentation.
-+*/
-+
-+static void do_check_malloc_state()
-+{
-+ mstate av = get_malloc_state();
-+ int i;
-+ mchunkptr p;
-+ mchunkptr q;
-+ mbinptr b;
-+ unsigned int binbit;
-+ int empty;
-+ unsigned int idx;
-+ INTERNAL_SIZE_T size;
-+ unsigned long total = 0;
-+ int max_fast_bin;
-+
-+ /* internal size_t must be no wider than pointer type */
-+ assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*));
-+
-+ /* alignment is a power of 2 */
-+ assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0);
-+
-+ /* cannot run remaining checks until fully initialized */
-+ if (av->top == 0 || av->top == initial_top(av))
-+ return;
-+
-+ /* pagesize is a power of 2 */
-+ assert((av->pagesize & (av->pagesize-1)) == 0);
-+
-+ /* properties of fastbins */
-+
-+ /* max_fast is in allowed range */
-+ assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE));
-+
-+ max_fast_bin = fastbin_index(av->max_fast);
-+
-+ for (i = 0; i < NFASTBINS; ++i) {
-+ p = av->fastbins[i];
-+
-+ /* all bins past max_fast are empty */
-+ if (i > max_fast_bin)
-+ assert(p == 0);
-+
-+ while (p != 0) {
-+ /* each chunk claims to be inuse */
-+ do_check_inuse_chunk(p);
-+ total += chunksize(p);
-+ /* chunk belongs in this bin */
-+ assert(fastbin_index(chunksize(p)) == i);
-+ p = p->fd;
-+ }
-+ }
-+
-+ if (total != 0)
-+ assert(have_fastchunks(av));
-+ else if (!have_fastchunks(av))
-+ assert(total == 0);
-+
-+ /* check normal bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ b = bin_at(av,i);
-+
-+ /* binmap is accurate (except for bin 1 == unsorted_chunks) */
-+ if (i >= 2) {
-+ binbit = get_binmap(av,i);
-+ empty = last(b) == b;
-+ if (!binbit)
-+ assert(empty);
-+ else if (!empty)
-+ assert(binbit);
-+ }
-+
-+ for (p = last(b); p != b; p = p->bk) {
-+ /* each chunk claims to be free */
-+ do_check_free_chunk(p);
-+ size = chunksize(p);
-+ total += size;
-+ if (i >= 2) {
-+ /* chunk belongs in bin */
-+ idx = bin_index(size);
-+ assert(idx == i);
-+ /* lists are sorted */
-+ assert(p->bk == b ||
-+ (unsigned long)chunksize(p->bk) >= (unsigned long)chunksize(p));
-+ }
-+ /* chunk is followed by a legal chain of inuse chunks */
-+ for (q = next_chunk(p);
-+ (q != av->top && inuse(q) &&
-+ (unsigned long)(chunksize(q)) >= MINSIZE);
-+ q = next_chunk(q))
-+ do_check_inuse_chunk(q);
-+ }
-+ }
-+
-+ /* top chunk is OK */
-+ check_chunk(av->top);
-+
-+ /* sanity checks for statistics */
-+
-+ assert(total <= (unsigned long)(av->max_total_mem));
-+ assert(av->n_mmaps >= 0);
-+ assert(av->n_mmaps <= av->n_mmaps_max);
-+ assert(av->n_mmaps <= av->max_n_mmaps);
-+
-+ assert((unsigned long)(av->sbrked_mem) <=
-+ (unsigned long)(av->max_sbrked_mem));
-+
-+ assert((unsigned long)(av->mmapped_mem) <=
-+ (unsigned long)(av->max_mmapped_mem));
-+
-+ assert((unsigned long)(av->max_total_mem) >=
-+ (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
-+}
-+#endif
-+
-+
-+/* ----------- Routines dealing with system allocation -------------- */
-+
-+/*
-+ sYSTRIm is an inverse of sorts to sYSMALLOc. It gives memory back
-+ to the system (via negative arguments to sbrk) if there is unused
-+ memory at the `high' end of the malloc pool. It is called
-+ automatically by free() when top space exceeds the trim
-+ threshold. It is also called by the public malloc_trim routine. It
-+ returns 1 if it actually released any memory, else 0.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static int sYSTRIm(size_t pad, mstate av)
-+#else
-+static int sYSTRIm(pad, av) size_t pad; mstate av;
-+#endif
-+{
-+ long top_size; /* Amount of top-most memory */
-+ long extra; /* Amount to release */
-+ long released; /* Amount actually released */
-+ char* current_brk; /* address returned by pre-check sbrk call */
-+ char* new_brk; /* address returned by post-check sbrk call */
-+ size_t pagesz;
-+
-+ pagesz = av->pagesize;
-+ top_size = chunksize(av->top);
-+
-+ /* Release in pagesize units, keeping at least one page */
-+ extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
-+
-+ if (extra > 0) {
-+
-+ /*
-+ Only proceed if end of memory is where we last set it.
-+ This avoids problems if there were foreign sbrk calls.
-+ */
-+ current_brk = (char*)(MORECORE(0));
-+ if (current_brk == (char*)(av->top) + top_size) {
-+
-+ /*
-+ Attempt to release memory. We ignore MORECORE return value,
-+ and instead call again to find out where new end of memory is.
-+ This avoids problems if first call releases less than we asked,
-+ of if failure somehow altered brk value. (We could still
-+ encounter problems if it altered brk in some very bad way,
-+ but the only thing we can do is adjust anyway, which will cause
-+ some downstream failure.)
-+ */
-+
-+ MORECORE(-extra);
-+ new_brk = (char*)(MORECORE(0));
-+
-+ if (new_brk != (char*)MORECORE_FAILURE) {
-+ released = (long)(current_brk - new_brk);
-+
-+ if (released != 0) {
-+ /* Success. Adjust top. */
-+ av->sbrked_mem -= released;
-+ set_head(av->top, (top_size - released) | PREV_INUSE);
-+ check_malloc_state();
-+ return 1;
-+ }
-+ }
-+ }
-+ }
-+ return 0;
-+}
-+
-+/*
-+ ------------------------- malloc_consolidate -------------------------
-+
-+ malloc_consolidate is a specialized version of free() that tears
-+ down chunks held in fastbins. Free itself cannot be used for this
-+ purpose since, among other things, it might place chunks back onto
-+ fastbins. So, instead, we need to use a minor variant of the same
-+ code.
-+
-+ Also, because this routine needs to be called the first time through
-+ malloc anyway, it turns out to be the perfect place to trigger
-+ initialization code.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static void malloc_consolidate(mstate av)
-+#else
-+static void malloc_consolidate(av) mstate av;
-+#endif
-+{
-+ mfastbinptr* fb; /* current fastbin being consolidated */
-+ mfastbinptr* maxfb; /* last fastbin (for loop control) */
-+ mchunkptr p; /* current chunk being consolidated */
-+ mchunkptr nextp; /* next chunk to consolidate */
-+ mchunkptr unsorted_bin; /* bin header */
-+ mchunkptr first_unsorted; /* chunk to link to */
-+
-+ /* These have same use as in free() */
-+ mchunkptr nextchunk;
-+ INTERNAL_SIZE_T size;
-+ INTERNAL_SIZE_T nextsize;
-+ INTERNAL_SIZE_T prevsize;
-+ int nextinuse;
-+ mchunkptr bck;
-+ mchunkptr fwd;
-+
-+ /*
-+ If max_fast is 0, we know that av hasn't
-+ yet been initialized, in which case do so below
-+ */
-+
-+ if (av->max_fast != 0) {
-+ clear_fastchunks(av);
-+
-+ unsorted_bin = unsorted_chunks(av);
-+
-+ /*
-+ Remove each chunk from fast bin and consolidate it, placing it
-+ then in unsorted bin. Among other reasons for doing this,
-+ placing in unsorted bin avoids needing to calculate actual bins
-+ until malloc is sure that chunks aren't immediately going to be
-+ reused anyway.
-+ */
-+
-+ maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
-+ fb = &(av->fastbins[0]);
-+ do {
-+ if ( (p = *fb) != 0) {
-+ *fb = 0;
-+
-+ do {
-+ check_inuse_chunk(p);
-+ nextp = p->fd;
-+
-+ /* Slightly streamlined version of consolidation code in free() */
-+ size = p->size & ~PREV_INUSE;
-+ nextchunk = chunk_at_offset(p, size);
-+ nextsize = chunksize(nextchunk);
-+
-+ if (!prev_inuse(p)) {
-+ prevsize = p->prev_size;
-+ size += prevsize;
-+ p = chunk_at_offset(p, -((long) prevsize));
-+ unlink(p, bck, fwd);
-+ }
-+
-+ if (nextchunk != av->top) {
-+ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
-+ set_head(nextchunk, nextsize);
-+
-+ if (!nextinuse) {
-+ size += nextsize;
-+ unlink(nextchunk, bck, fwd);
-+ }
-+
-+ first_unsorted = unsorted_bin->fd;
-+ unsorted_bin->fd = p;
-+ first_unsorted->bk = p;
-+
-+ set_head(p, size | PREV_INUSE);
-+ p->bk = unsorted_bin;
-+ p->fd = first_unsorted;
-+ set_foot(p, size);
-+ }
-+
-+ else {
-+ size += nextsize;
-+ set_head(p, size | PREV_INUSE);
-+ av->top = p;
-+ }
-+
-+ } while ( (p = nextp) != 0);
-+
-+ }
-+ } while (fb++ != maxfb);
-+ }
-+ else {
-+ malloc_init_state(av);
-+ check_malloc_state();
-+ }
-+}
-+
-+/*
-+ ------------------------------ free ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+void fREe(Void_t* mem)
-+#else
-+void fREe(mem) Void_t* mem;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ mchunkptr p; /* chunk corresponding to mem */
-+ INTERNAL_SIZE_T size; /* its size */
-+ mfastbinptr* fb; /* associated fastbin */
-+ mchunkptr nextchunk; /* next contiguous chunk */
-+ INTERNAL_SIZE_T nextsize; /* its size */
-+ int nextinuse; /* true if nextchunk is used */
-+ INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
-+ mchunkptr bck; /* misc temp for linking */
-+ mchunkptr fwd; /* misc temp for linking */
-+
-+
-+ /* free(0) has no effect */
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+ size = chunksize(p);
-+
-+ check_inuse_chunk(p);
-+
-+ /*
-+ If eligible, place chunk on a fastbin so it can be found
-+ and used quickly in malloc.
-+ */
-+
-+ if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
-+
-+#if TRIM_FASTBINS
-+ /*
-+ If TRIM_FASTBINS set, don't place chunks
-+ bordering top into fastbins
-+ */
-+ && (chunk_at_offset(p, size) != av->top)
-+#endif
-+ ) {
-+
-+ set_fastchunks(av);
-+ fb = &(av->fastbins[fastbin_index(size)]);
-+ p->fd = *fb;
-+ *fb = p;
-+ }
-+
-+ /*
-+ Consolidate other non-mmapped chunks as they arrive.
-+ */
-+
-+ else if (!chunk_is_mmapped(p)) {
-+ nextchunk = chunk_at_offset(p, size);
-+ nextsize = chunksize(nextchunk);
-+
-+ /* consolidate backward */
-+ if (!prev_inuse(p)) {
-+ prevsize = p->prev_size;
-+ size += prevsize;
-+ p = chunk_at_offset(p, -((long) prevsize));
-+ unlink(p, bck, fwd);
-+ }
-+
-+ if (nextchunk != av->top) {
-+ /* get and clear inuse bit */
-+ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
-+ set_head(nextchunk, nextsize);
-+
-+ /* consolidate forward */
-+ if (!nextinuse) {
-+ unlink(nextchunk, bck, fwd);
-+ size += nextsize;
-+ }
-+
-+ /*
-+ Place the chunk in unsorted chunk list. Chunks are
-+ not placed into regular bins until after they have
-+ been given one chance to be used in malloc.
-+ */
-+
-+ bck = unsorted_chunks(av);
-+ fwd = bck->fd;
-+ p->bk = bck;
-+ p->fd = fwd;
-+ bck->fd = p;
-+ fwd->bk = p;
-+
-+ set_head(p, size | PREV_INUSE);
-+ set_foot(p, size);
-+
-+ check_free_chunk(p);
-+ }
-+
-+ /*
-+ If the chunk borders the current high end of memory,
-+ consolidate into top
-+ */
-+
-+ else {
-+ size += nextsize;
-+ set_head(p, size | PREV_INUSE);
-+ av->top = p;
-+ check_chunk(p);
-+ }
-+
-+ /*
-+ If freeing a large space, consolidate possibly-surrounding
-+ chunks. Then, if the total unused topmost memory exceeds trim
-+ threshold, ask malloc_trim to reduce top.
-+
-+ Unless max_fast is 0, we don't know if there are fastbins
-+ bordering top, so we cannot tell for sure whether threshold
-+ has been reached unless fastbins are consolidated. But we
-+ don't want to consolidate on each free. As a compromise,
-+ consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
-+ is reached.
-+ */
-+
-+ if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
-+ if (have_fastchunks(av))
-+ malloc_consolidate(av);
-+
-+#ifndef MORECORE_CANNOT_TRIM
-+ if ((unsigned long)(chunksize(av->top)) >=
-+ (unsigned long)(av->trim_threshold))
-+ sYSTRIm(av->top_pad, av);
-+#endif
-+ }
-+
-+ }
-+ /*
-+ If the chunk was allocated via mmap, release via munmap()
-+ Note that if HAVE_MMAP is false but chunk_is_mmapped is
-+ true, then user must have overwritten memory. There's nothing
-+ we can do to catch this error unless DEBUG is set, in which case
-+ check_inuse_chunk (above) will have triggered error.
-+ */
-+
-+ else {
-+#if HAVE_MMAP
-+ int ret;
-+ INTERNAL_SIZE_T offset = p->prev_size;
-+ av->n_mmaps--;
-+ av->mmapped_mem -= (size + offset);
-+ ret = munmap((char*)p - offset, size + offset);
-+ /* munmap returns non-zero on failure */
-+ assert(ret == 0);
-+#endif
-+ }
-+ }
-+}
-+
-+/*
-+ sysmalloc handles malloc cases requiring more memory from the system.
-+ On entry, it is assumed that av->top does not have enough
-+ space to service request for nb bytes, thus requiring that av->top
-+ be extended or replaced.
-+*/
-+
-+INLINE
-+#if __STD_C
-+static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
-+#else
-+static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
-+#endif
-+{
-+ mchunkptr old_top; /* incoming value of av->top */
-+ INTERNAL_SIZE_T old_size; /* its size */
-+ char* old_end; /* its end address */
-+
-+ long size; /* arg to first MORECORE or mmap call */
-+ char* brk; /* return value from MORECORE */
-+
-+ long correction; /* arg to 2nd MORECORE call */
-+ char* snd_brk; /* 2nd return val */
-+
-+ INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
-+ INTERNAL_SIZE_T end_misalign; /* partial page left at end of new space */
-+ char* aligned_brk; /* aligned offset into brk */
-+
-+ mchunkptr p; /* the allocated/returned chunk */
-+ mchunkptr remainder; /* remainder from allocation */
-+ unsigned long remainder_size; /* its size */
-+
-+ unsigned long sum; /* for updating stats */
-+
-+ size_t pagemask = av->pagesize - 1;
-+
-+
-+#if HAVE_MMAP
-+
-+ /*
-+ If have mmap, and the request size meets the mmap threshold, and
-+ the system supports mmap, and there are few enough currently
-+ allocated mmapped regions, try to directly map this request
-+ rather than expanding top.
-+ */
-+
-+ if ((unsigned long)(nb) >= (unsigned long)(av->mmap_threshold) &&
-+ (av->n_mmaps < av->n_mmaps_max)) {
-+
-+ char* mm; /* return value from mmap call*/
-+
-+ /*
-+ Round up size to nearest page. For mmapped chunks, the overhead
-+ is one SIZE_SZ unit larger than for normal chunks, because there
-+ is no following chunk whose prev_size field could be used.
-+ */
-+ size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
-+
-+ /* Don't try if size wraps around 0 */
-+ if ((unsigned long)(size) > (unsigned long)(nb)) {
-+
-+ mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
-+
-+ if (mm != (char*)(MORECORE_FAILURE)) {
-+
-+ /*
-+ The offset to the start of the mmapped region is stored
-+ in the prev_size field of the chunk. This allows us to adjust
-+ returned start address to meet alignment requirements here
-+ and in memalign(), and still be able to compute proper
-+ address argument for later munmap in free() and realloc().
-+ */
-+
-+ front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK;
-+ if (front_misalign > 0) {
-+ correction = MALLOC_ALIGNMENT - front_misalign;
-+ p = (mchunkptr)(mm + correction);
-+ p->prev_size = correction;
-+ set_head(p, (size - correction) |IS_MMAPPED);
-+ }
-+ else {
-+ p = (mchunkptr)mm;
-+ p->prev_size = 0;
-+ set_head(p, size|IS_MMAPPED);
-+ }
-+
-+ /* update statistics */
-+
-+ if (++av->n_mmaps > av->max_n_mmaps)
-+ av->max_n_mmaps = av->n_mmaps;
-+
-+ sum = av->mmapped_mem += size;
-+ if (sum > (unsigned long)(av->max_mmapped_mem))
-+ av->max_mmapped_mem = sum;
-+ sum += av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ check_chunk(p);
-+
-+ return chunk2mem(p);
-+ }
-+ }
-+ }
-+#endif
-+
-+ /* Record incoming configuration of top */
-+
-+ old_top = av->top;
-+ old_size = chunksize(old_top);
-+ old_end = (char*)(chunk_at_offset(old_top, old_size));
-+
-+ brk = snd_brk = (char*)(MORECORE_FAILURE);
-+
-+ /*
-+ If not the first time through, we require old_size to be
-+ at least MINSIZE and to have prev_inuse set.
-+ */
-+
-+ assert((old_top == initial_top(av) && old_size == 0) ||
-+ ((unsigned long) (old_size) >= MINSIZE &&
-+ prev_inuse(old_top)));
-+
-+ /* Precondition: not enough current space to satisfy nb request */
-+ assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
-+
-+ /* Precondition: all fastbins are consolidated */
-+ assert(!have_fastchunks(av));
-+
-+
-+ /* Request enough space for nb + pad + overhead */
-+
-+ size = nb + av->top_pad + MINSIZE;
-+
-+ /*
-+ If contiguous, we can subtract out existing space that we hope to
-+ combine with new space. We add it back later only if
-+ we don't actually get contiguous space.
-+ */
-+
-+ if (contiguous(av))
-+ size -= old_size;
-+
-+ /*
-+ Round to a multiple of page size.
-+ If MORECORE is not contiguous, this ensures that we only call it
-+ with whole-page arguments. And if MORECORE is contiguous and
-+ this is not first time through, this preserves page-alignment of
-+ previous calls. Otherwise, we correct to page-align below.
-+ */
-+
-+ size = (size + pagemask) & ~pagemask;
-+
-+ /*
-+ Don't try to call MORECORE if argument is so big as to appear
-+ negative. Note that since mmap takes size_t arg, it may succeed
-+ below even if we cannot call MORECORE.
-+ */
-+
-+ if (size > 0)
-+ brk = (char*)(MORECORE(size));
-+
-+ /*
-+ If have mmap, try using it as a backup when MORECORE fails or
-+ cannot be used. This is worth doing on systems that have "holes" in
-+ address space, so sbrk cannot extend to give contiguous space, but
-+ space is available elsewhere. Note that we ignore mmap max count
-+ and threshold limits, since the space will not be used as a
-+ segregated mmap region.
-+ */
-+
-+#if HAVE_MMAP
-+ if (brk == (char*)(MORECORE_FAILURE)) {
-+
-+ /* Cannot merge with old top, so add its size back in */
-+ if (contiguous(av))
-+ size = (size + old_size + pagemask) & ~pagemask;
-+
-+ /* If we are relying on mmap as backup, then use larger units */
-+ if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
-+ size = MMAP_AS_MORECORE_SIZE;
-+
-+ /* Don't try if size wraps around 0 */
-+ if ((unsigned long)(size) > (unsigned long)(nb)) {
-+
-+ brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
-+
-+ if (brk != (char*)(MORECORE_FAILURE)) {
-+
-+ /* We do not need, and cannot use, another sbrk call to find end */
-+ snd_brk = brk + size;
-+
-+ /*
-+ Record that we no longer have a contiguous sbrk region.
-+ After the first time mmap is used as backup, we do not
-+ ever rely on contiguous space since this could incorrectly
-+ bridge regions.
-+ */
-+ set_noncontiguous(av);
-+ }
-+ }
-+ }
-+#endif
-+
-+ if (brk != (char*)(MORECORE_FAILURE)) {
-+ av->sbrked_mem += size;
-+
-+ /*
-+ If MORECORE extends previous space, we can likewise extend top size.
-+ */
-+
-+ if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
-+ set_head(old_top, (size + old_size) | PREV_INUSE);
-+ }
-+
-+ /*
-+ Otherwise, make adjustments:
-+
-+ * If the first time through or noncontiguous, we need to call sbrk
-+ just to find out where the end of memory lies.
-+
-+ * We need to ensure that all returned chunks from malloc will meet
-+ MALLOC_ALIGNMENT
-+
-+ * If there was an intervening foreign sbrk, we need to adjust sbrk
-+ request size to account for fact that we will not be able to
-+ combine new space with existing space in old_top.
-+
-+ * Almost all systems internally allocate whole pages at a time, in
-+ which case we might as well use the whole last page of request.
-+ So we allocate enough more memory to hit a page boundary now,
-+ which in turn causes future contiguous calls to page-align.
-+ */
-+
-+ else {
-+ front_misalign = 0;
-+ end_misalign = 0;
-+ correction = 0;
-+ aligned_brk = brk;
-+
-+ /* handle contiguous cases */
-+ if (contiguous(av)) {
-+
-+ /* Guarantee alignment of first new chunk made from this space */
-+
-+ front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
-+ if (front_misalign > 0) {
-+
-+ /*
-+ Skip over some bytes to arrive at an aligned position.
-+ We don't need to specially mark these wasted front bytes.
-+ They will never be accessed anyway because
-+ prev_inuse of av->top (and any chunk created from its start)
-+ is always true after initialization.
-+ */
-+
-+ correction = MALLOC_ALIGNMENT - front_misalign;
-+ aligned_brk += correction;
-+ }
-+
-+ /*
-+ If this isn't adjacent to existing space, then we will not
-+ be able to merge with old_top space, so must add to 2nd request.
-+ */
-+
-+ correction += old_size;
-+
-+ /* Extend the end address to hit a page boundary */
-+ end_misalign = (INTERNAL_SIZE_T)(brk + size + correction);
-+ correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
-+
-+ assert(correction >= 0);
-+ snd_brk = (char*)(MORECORE(correction));
-+
-+ /*
-+ If can't allocate correction, try to at least find out current
-+ brk. It might be enough to proceed without failing.
-+
-+ Note that if second sbrk did NOT fail, we assume that space
-+ is contiguous with first sbrk. This is a safe assumption unless
-+ program is multithreaded but doesn't use locks and a foreign sbrk
-+ occurred between our first and second calls.
-+ */
-+
-+ if (snd_brk == (char*)(MORECORE_FAILURE)) {
-+ correction = 0;
-+ snd_brk = (char*)(MORECORE(0));
-+ }
-+ }
-+
-+ /* handle non-contiguous cases */
-+ else {
-+ /* MORECORE/mmap must correctly align */
-+ assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
-+
-+ /* Find out current end of memory */
-+ if (snd_brk == (char*)(MORECORE_FAILURE)) {
-+ snd_brk = (char*)(MORECORE(0));
-+ }
-+ }
-+
-+ /* Adjust top based on results of second sbrk */
-+ if (snd_brk != (char*)(MORECORE_FAILURE)) {
-+ av->top = (mchunkptr)aligned_brk;
-+ set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
-+ av->sbrked_mem += correction;
-+
-+ /*
-+ If not the first time through, we either have a
-+ gap due to foreign sbrk or a non-contiguous region. Insert a
-+ double fencepost at old_top to prevent consolidation with space
-+ we don't own. These fenceposts are artificial chunks that are
-+ marked as inuse and are in any case too small to use. We need
-+ two to make sizes and alignments work out.
-+ */
-+
-+ if (old_size != 0) {
-+ /*
-+ Shrink old_top to insert fenceposts, keeping size a
-+ multiple of MALLOC_ALIGNMENT. We know there is at least
-+ enough space in old_top to do this.
-+ */
-+ old_size = (old_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
-+ set_head(old_top, old_size | PREV_INUSE);
-+
-+ /*
-+ Note that the following assignments completely overwrite
-+ old_top when old_size was previously MINSIZE. This is
-+ intentional. We need the fencepost, even if old_top otherwise gets
-+ lost.
-+ */
-+ chunk_at_offset(old_top, old_size )->size =
-+ SIZE_SZ|PREV_INUSE;
-+
-+ chunk_at_offset(old_top, old_size + SIZE_SZ)->size =
-+ SIZE_SZ|PREV_INUSE;
-+
-+ /* If possible, release the rest. */
-+ if (old_size >= MINSIZE) {
-+ fREe(chunk2mem(old_top));
-+ }
-+
-+ }
-+ }
-+ }
-+
-+ /* Update statistics */
-+ sum = av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_sbrked_mem))
-+ av->max_sbrked_mem = sum;
-+
-+ sum += av->mmapped_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ check_malloc_state();
-+
-+ /* finally, do the allocation */
-+ p = av->top;
-+ size = chunksize(p);
-+
-+ /* check that one of the above allocation paths succeeded */
-+ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(p, nb);
-+ av->top = remainder;
-+ set_head(p, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ check_malloced_chunk(p, nb);
-+ return chunk2mem(p);
-+ }
-+ }
-+
-+ /* catch all failure paths */
-+ MALLOC_FAILURE_ACTION;
-+ return 0;
-+}
-+
-+
-+/*
-+ ------------------------------ malloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* mALLOc(size_t bytes)
-+#else
-+ Void_t* mALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T nb; /* normalized request size */
-+ unsigned int idx; /* associated bin index */
-+ mbinptr bin; /* associated bin */
-+ mfastbinptr* fb; /* associated fastbin */
-+
-+ mchunkptr victim; /* inspected/selected chunk */
-+ INTERNAL_SIZE_T size; /* its size */
-+ int victim_index; /* its bin index */
-+
-+ mchunkptr remainder; /* remainder from a split */
-+ unsigned long remainder_size; /* its size */
-+
-+ unsigned int block; /* bit map traverser */
-+ unsigned int bit; /* bit map traverser */
-+ unsigned int map; /* current word of binmap */
-+
-+ mchunkptr fwd; /* misc temp for linking */
-+ mchunkptr bck; /* misc temp for linking */
-+
-+ /*
-+ Convert request size to internal form by adding SIZE_SZ bytes
-+ overhead plus possibly more to obtain necessary alignment and/or
-+ to obtain a size of at least MINSIZE, the smallest allocatable
-+ size. Also, checked_request2size traps (returning 0) request sizes
-+ that are so large that they wrap around zero when padded and
-+ aligned.
-+ */
-+
-+ checked_request2size(bytes, nb);
-+
-+ /*
-+ If the size qualifies as a fastbin, first check corresponding bin.
-+ This code is safe to execute even if av is not yet initialized, so we
-+ can try it without checking, which saves some time on this fast path.
-+ */
-+
-+ if ((unsigned long)(nb) <= (unsigned long)(av->max_fast)) {
-+ fb = &(av->fastbins[(fastbin_index(nb))]);
-+ if ( (victim = *fb) != 0) {
-+ *fb = victim->fd;
-+ check_remalloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+
-+ /*
-+ If a small request, check regular bin. Since these "smallbins"
-+ hold one size each, no searching within bins is necessary.
-+ (For a large request, we need to wait until unsorted chunks are
-+ processed to find best fit. But for small ones, fits are exact
-+ anyway, so we can check now, which is faster.)
-+ */
-+
-+ if (in_smallbin_range(nb)) {
-+ idx = smallbin_index(nb);
-+ bin = bin_at(av,idx);
-+
-+ if ( (victim = last(bin)) != bin) {
-+ if (victim == 0) /* initialization check */
-+ malloc_consolidate(av);
-+ else {
-+ bck = victim->bk;
-+ set_inuse_bit_at_offset(victim, nb);
-+ bin->bk = bck;
-+ bck->fd = bin;
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ /*
-+ If this is a large request, consolidate fastbins before continuing.
-+ While it might look excessive to kill all fastbins before
-+ even seeing if there is space available, this avoids
-+ fragmentation problems normally associated with fastbins.
-+ Also, in practice, programs tend to have runs of either small or
-+ large requests, but less often mixtures, so consolidation is not
-+ invoked all that often in most programs. And the programs that
-+ it is called frequently in otherwise tend to fragment.
-+ */
-+
-+ else {
-+ idx = largebin_index(nb);
-+ if (have_fastchunks(av))
-+ malloc_consolidate(av);
-+ }
-+
-+ /*
-+ Process recently freed or remaindered chunks, taking one only if
-+ it is exact fit, or, if this a small request, the chunk is remainder from
-+ the most recent non-exact fit. Place other traversed chunks in
-+ bins. Note that this step is the only place in any routine where
-+ chunks are placed in bins.
-+
-+ The outer loop here is needed because we might not realize until
-+ near the end of malloc that we should have consolidated, so must
-+ do so and retry. This happens at most once, and only when we would
-+ otherwise need to expand memory to service a "small" request.
-+ */
-+
-+ for(;;) {
-+
-+ while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
-+ bck = victim->bk;
-+ size = chunksize(victim);
-+
-+ /*
-+ If a small request, try to use last remainder if it is the
-+ only chunk in unsorted bin. This helps promote locality for
-+ runs of consecutive small requests. This is the only
-+ exception to best-fit, and applies only when there is
-+ no exact fit for a small chunk.
-+ */
-+
-+ if (in_smallbin_range(nb) &&
-+ bck == unsorted_chunks(av) &&
-+ victim == av->last_remainder &&
-+ (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
-+
-+ /* split and reattach remainder */
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(victim, nb);
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ av->last_remainder = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* remove from unsorted list */
-+ unsorted_chunks(av)->bk = bck;
-+ bck->fd = unsorted_chunks(av);
-+
-+ /* Take now instead of binning if exact fit */
-+
-+ if (size == nb) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* place chunk in bin */
-+
-+ if (in_smallbin_range(size)) {
-+ victim_index = smallbin_index(size);
-+ bck = bin_at(av, victim_index);
-+ fwd = bck->fd;
-+ }
-+ else {
-+ victim_index = largebin_index(size);
-+ bck = bin_at(av, victim_index);
-+ fwd = bck->fd;
-+
-+ /* maintain large bins in sorted order */
-+ if (fwd != bck) {
-+ size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
-+ /* if smaller than smallest, bypass loop below */
-+ if ((unsigned long)(size) <= (unsigned long)(bck->bk->size)) {
-+ fwd = bck;
-+ bck = bck->bk;
-+ }
-+ else {
-+ while ((unsigned long)(size) < (unsigned long)(fwd->size))
-+ fwd = fwd->fd;
-+ bck = fwd->bk;
-+ }
-+ }
-+ }
-+
-+ mark_bin(av, victim_index);
-+ victim->bk = bck;
-+ victim->fd = fwd;
-+ fwd->bk = victim;
-+ bck->fd = victim;
-+ }
-+
-+ /*
-+ If a large request, scan through the chunks of current bin in
-+ sorted order to find smallest that fits. This is the only step
-+ where an unbounded number of chunks might be scanned without doing
-+ anything useful with them. However the lists tend to be short.
-+ */
-+
-+ if (!in_smallbin_range(nb)) {
-+ bin = bin_at(av, idx);
-+
-+ /* skip scan if empty or largest chunk is too small */
-+ if ((victim = last(bin)) != bin &&
-+ (unsigned long)(first(bin)->size) >= (unsigned long)(nb)) {
-+
-+ while (((unsigned long)(size = chunksize(victim)) <
-+ (unsigned long)(nb)))
-+ victim = victim->bk;
-+
-+ remainder_size = size - nb;
-+ unlink(victim, bck, fwd);
-+
-+ /* Exhaust */
-+ if (remainder_size < MINSIZE) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ /* Split */
-+ else {
-+ remainder = chunk_at_offset(victim, nb);
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ /*
-+ Search for a chunk by scanning bins, starting with next largest
-+ bin. This search is strictly by best-fit; i.e., the smallest
-+ (with ties going to approximately the least recently used) chunk
-+ that fits is selected.
-+
-+ The bitmap avoids needing to check that most blocks are nonempty.
-+ The particular case of skipping all bins during warm-up phases
-+ when no chunks have been returned yet is faster than it might look.
-+ */
-+
-+ ++idx;
-+ bin = bin_at(av,idx);
-+ block = idx2block(idx);
-+ map = av->binmap[block];
-+ bit = idx2bit(idx);
-+
-+ for (;;) {
-+
-+ /* Skip rest of block if there are no more set bits in this block. */
-+ if (bit > map || bit == 0) {
-+ do {
-+ if (++block >= BINMAPSIZE) /* out of bins */
-+ goto use_top;
-+ } while ( (map = av->binmap[block]) == 0);
-+
-+ bin = bin_at(av, (block << BINMAPSHIFT));
-+ bit = 1;
-+ }
-+
-+ /* Advance to bin with set bit. There must be one. */
-+ while ((bit & map) == 0) {
-+ bin = next_bin(bin);
-+ bit <<= 1;
-+ assert(bit != 0);
-+ }
-+
-+ /* Inspect the bin. It is likely to be non-empty */
-+ victim = last(bin);
-+
-+ /* If a false alarm (empty bin), clear the bit. */
-+ if (victim == bin) {
-+ av->binmap[block] = map &= ~bit; /* Write through */
-+ bin = next_bin(bin);
-+ bit <<= 1;
-+ }
-+
-+ else {
-+ size = chunksize(victim);
-+
-+ /* We know the first chunk in this bin is big enough to use. */
-+ assert((unsigned long)(size) >= (unsigned long)(nb));
-+
-+ remainder_size = size - nb;
-+
-+ /* unlink */
-+ bck = victim->bk;
-+ bin->bk = bck;
-+ bck->fd = bin;
-+
-+ /* Exhaust */
-+ if (remainder_size < MINSIZE) {
-+ set_inuse_bit_at_offset(victim, size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /* Split */
-+ else {
-+ remainder = chunk_at_offset(victim, nb);
-+
-+ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
-+ remainder->bk = remainder->fd = unsorted_chunks(av);
-+ /* advertise as last remainder */
-+ if (in_smallbin_range(nb))
-+ av->last_remainder = remainder;
-+
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_foot(remainder, remainder_size);
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+ }
-+ }
-+
-+ use_top:
-+ /*
-+ If large enough, split off the chunk bordering the end of memory
-+ (held in av->top). Note that this is in accord with the best-fit
-+ search rule. In effect, av->top is treated as larger (and thus
-+ less well fitting) than any other available chunk since it can
-+ be extended to be as large as necessary (up to system
-+ limitations).
-+
-+ We require that av->top always exists (i.e., has size >=
-+ MINSIZE) after initialization, so if it would otherwise be
-+ exhuasted by current request, it is replenished. (The main
-+ reason for ensuring it exists is that we may need MINSIZE space
-+ to put in fenceposts in sysmalloc.)
-+ */
-+
-+ victim = av->top;
-+ size = chunksize(victim);
-+
-+ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(victim, nb);
-+ av->top = remainder;
-+ set_head(victim, nb | PREV_INUSE);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+
-+ check_malloced_chunk(victim, nb);
-+ return chunk2mem(victim);
-+ }
-+
-+ /*
-+ If there is space available in fastbins, consolidate and retry,
-+ to possibly avoid expanding memory. This can occur only if nb is
-+ in smallbin range so we didn't consolidate upon entry.
-+ */
-+
-+ else if (have_fastchunks(av)) {
-+ assert(in_smallbin_range(nb));
-+ malloc_consolidate(av);
-+ idx = smallbin_index(nb); /* restore original bin index */
-+ }
-+
-+ /*
-+ Otherwise, relay to handle system-dependent cases
-+ */
-+ else
-+ return sYSMALLOc(nb, av);
-+ }
-+}
-+
-+/*
-+ ------------------------------ realloc ------------------------------
-+*/
-+
-+
-+INLINE
-+#if __STD_C
-+Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
-+#else
-+Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+
-+ INTERNAL_SIZE_T nb; /* padded request size */
-+
-+ mchunkptr oldp; /* chunk corresponding to oldmem */
-+ INTERNAL_SIZE_T oldsize; /* its size */
-+
-+ mchunkptr newp; /* chunk to return */
-+ INTERNAL_SIZE_T newsize; /* its size */
-+ Void_t* newmem; /* corresponding user mem */
-+
-+ mchunkptr next; /* next contiguous chunk after oldp */
-+
-+ mchunkptr remainder; /* extra space at end of newp */
-+ unsigned long remainder_size; /* its size */
-+
-+ mchunkptr bck; /* misc temp for linking */
-+ mchunkptr fwd; /* misc temp for linking */
-+
-+ unsigned long copysize; /* bytes to copy */
-+ unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
-+ INTERNAL_SIZE_T* s; /* copy source */
-+ INTERNAL_SIZE_T* d; /* copy destination */
-+
-+
-+#ifdef REALLOC_ZERO_BYTES_FREES
-+ if (bytes == 0) {
-+ fREe(oldmem);
-+ return 0;
-+ }
-+#endif
-+
-+ /* realloc of null is supposed to be same as malloc */
-+ if (oldmem == 0) return mALLOc(bytes);
-+
-+ checked_request2size(bytes, nb);
-+
-+ oldp = mem2chunk(oldmem);
-+ oldsize = chunksize(oldp);
-+
-+ check_inuse_chunk(oldp);
-+
-+ if (!chunk_is_mmapped(oldp)) {
-+
-+ if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
-+ /* already big enough; split below */
-+ newp = oldp;
-+ newsize = oldsize;
-+ }
-+
-+ else {
-+ next = chunk_at_offset(oldp, oldsize);
-+
-+ /* Try to expand forward into top */
-+ if (next == av->top &&
-+ (unsigned long)(newsize = oldsize + chunksize(next)) >=
-+ (unsigned long)(nb + MINSIZE)) {
-+ set_head_size(oldp, nb);
-+ av->top = chunk_at_offset(oldp, nb);
-+ set_head(av->top, (newsize - nb) | PREV_INUSE);
-+ return chunk2mem(oldp);
-+ }
-+
-+ /* Try to expand forward into next chunk; split off remainder below */
-+ else if (next != av->top &&
-+ !inuse(next) &&
-+ (unsigned long)(newsize = oldsize + chunksize(next)) >=
-+ (unsigned long)(nb)) {
-+ newp = oldp;
-+ unlink(next, bck, fwd);
-+ }
-+
-+ /* allocate, copy, free */
-+ else {
-+ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
-+ if (newmem == 0)
-+ return 0; /* propagate failure */
-+
-+ newp = mem2chunk(newmem);
-+ newsize = chunksize(newp);
-+
-+ /*
-+ Avoid copy if newp is next chunk after oldp.
-+ */
-+ if (newp == next) {
-+ newsize += oldsize;
-+ newp = oldp;
-+ }
-+ else {
-+ /*
-+ Unroll copy of <= 36 bytes (72 if 8byte sizes)
-+ We know that contents have an odd number of
-+ INTERNAL_SIZE_T-sized words; minimally 3.
-+ */
-+
-+ copysize = oldsize - SIZE_SZ;
-+ s = (INTERNAL_SIZE_T*)(oldmem);
-+ d = (INTERNAL_SIZE_T*)(newmem);
-+ ncopies = copysize / sizeof(INTERNAL_SIZE_T);
-+ assert(ncopies >= 3);
-+
-+ if (ncopies > 9)
-+ MALLOC_COPY(d, s, copysize);
-+
-+ else {
-+ *(d+0) = *(s+0);
-+ *(d+1) = *(s+1);
-+ *(d+2) = *(s+2);
-+ if (ncopies > 4) {
-+ *(d+3) = *(s+3);
-+ *(d+4) = *(s+4);
-+ if (ncopies > 6) {
-+ *(d+5) = *(s+5);
-+ *(d+6) = *(s+6);
-+ if (ncopies > 8) {
-+ *(d+7) = *(s+7);
-+ *(d+8) = *(s+8);
-+ }
-+ }
-+ }
-+ }
-+
-+ fREe(oldmem);
-+ check_inuse_chunk(newp);
-+ return chunk2mem(newp);
-+ }
-+ }
-+ }
-+
-+ /* If possible, free extra space in old or extended chunk */
-+
-+ assert((unsigned long)(newsize) >= (unsigned long)(nb));
-+
-+ remainder_size = newsize - nb;
-+
-+ if (remainder_size < MINSIZE) { /* not enough extra to split off */
-+ set_head_size(newp, newsize);
-+ set_inuse_bit_at_offset(newp, newsize);
-+ }
-+ else { /* split remainder */
-+ remainder = chunk_at_offset(newp, nb);
-+ set_head_size(newp, nb);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ /* Mark remainder as inuse so free() won't complain */
-+ set_inuse_bit_at_offset(remainder, remainder_size);
-+ fREe(chunk2mem(remainder));
-+ }
-+
-+ check_inuse_chunk(newp);
-+ return chunk2mem(newp);
-+ }
-+
-+ /*
-+ Handle mmap cases
-+ */
-+
-+ else {
-+#if HAVE_MMAP
-+
-+#if HAVE_MREMAP
-+ INTERNAL_SIZE_T offset = oldp->prev_size;
-+ size_t pagemask = av->pagesize - 1;
-+ char *cp;
-+ unsigned long sum;
-+
-+ /* Note the extra SIZE_SZ overhead */
-+ newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask;
-+
-+ /* don't need to remap if still within same page */
-+ if (oldsize == newsize - offset)
-+ return oldmem;
-+
-+ cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
-+
-+ if (cp != (char*)MORECORE_FAILURE) {
-+
-+ newp = (mchunkptr)(cp + offset);
-+ set_head(newp, (newsize - offset)|IS_MMAPPED);
-+
-+ assert(aligned_OK(chunk2mem(newp)));
-+ assert((newp->prev_size == offset));
-+
-+ /* update statistics */
-+ sum = av->mmapped_mem += newsize - oldsize;
-+ if (sum > (unsigned long)(av->max_mmapped_mem))
-+ av->max_mmapped_mem = sum;
-+ sum += av->sbrked_mem;
-+ if (sum > (unsigned long)(av->max_total_mem))
-+ av->max_total_mem = sum;
-+
-+ return chunk2mem(newp);
-+ }
-+#endif
-+
-+ /* Note the extra SIZE_SZ overhead. */
-+ if ((unsigned long)(oldsize) >= (unsigned long)(nb + SIZE_SZ))
-+ newmem = oldmem; /* do nothing */
-+ else {
-+ /* Must alloc, copy, free. */
-+ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
-+ if (newmem != 0) {
-+ MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
-+ fREe(oldmem);
-+ }
-+ }
-+ return newmem;
-+
-+#else
-+ /* If !HAVE_MMAP, but chunk_is_mmapped, user must have overwritten mem */
-+ check_malloc_state();
-+ MALLOC_FAILURE_ACTION;
-+ return 0;
-+#endif
-+ }
-+}
-+
-+/*
-+ ------------------------------ memalign ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* mEMALIGn(size_t alignment, size_t bytes)
-+#else
-+Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
-+#endif
-+{
-+ INTERNAL_SIZE_T nb; /* padded request size */
-+ char* m; /* memory returned by malloc call */
-+ mchunkptr p; /* corresponding chunk */
-+ char* brk; /* alignment point within p */
-+ mchunkptr newp; /* chunk to return */
-+ INTERNAL_SIZE_T newsize; /* its size */
-+ INTERNAL_SIZE_T leadsize; /* leading space before alignment point */
-+ mchunkptr remainder; /* spare room at end to split off */
-+ unsigned long remainder_size; /* its size */
-+ INTERNAL_SIZE_T size;
-+
-+ /* If need less alignment than we give anyway, just relay to malloc */
-+
-+ if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
-+
-+ /* Otherwise, ensure that it is at least a minimum chunk size */
-+
-+ if (alignment < MINSIZE) alignment = MINSIZE;
-+
-+ /* Make sure alignment is power of 2 (in case MINSIZE is not). */
-+ if ((alignment & (alignment - 1)) != 0) {
-+ size_t a = MALLOC_ALIGNMENT * 2;
-+ while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
-+ alignment = a;
-+ }
-+
-+ checked_request2size(bytes, nb);
-+
-+ /*
-+ Strategy: find a spot within that chunk that meets the alignment
-+ request, and then possibly free the leading and trailing space.
-+ */
-+
-+
-+ /* Call malloc with worst case padding to hit alignment. */
-+
-+ m = (char*)(mALLOc(nb + alignment + MINSIZE));
-+
-+ if (m == 0) return 0; /* propagate failure */
-+
-+ p = mem2chunk(m);
-+
-+ if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
-+
-+ /*
-+ Find an aligned spot inside chunk. Since we need to give back
-+ leading space in a chunk of at least MINSIZE, if the first
-+ calculation places us at a spot with less than MINSIZE leader,
-+ we can move to the next aligned spot -- we've allocated enough
-+ total room so that this is always possible.
-+ */
-+
-+ brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) &
-+ -((signed long) alignment));
-+ if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
-+ brk += alignment;
-+
-+ newp = (mchunkptr)brk;
-+ leadsize = brk - (char*)(p);
-+ newsize = chunksize(p) - leadsize;
-+
-+ /* For mmapped chunks, just adjust offset */
-+ if (chunk_is_mmapped(p)) {
-+ newp->prev_size = p->prev_size + leadsize;
-+ set_head(newp, newsize|IS_MMAPPED);
-+ return chunk2mem(newp);
-+ }
-+
-+ /* Otherwise, give back leader, use the rest */
-+ set_head(newp, newsize | PREV_INUSE);
-+ set_inuse_bit_at_offset(newp, newsize);
-+ set_head_size(p, leadsize);
-+ fREe(chunk2mem(p));
-+ p = newp;
-+
-+ assert (newsize >= nb &&
-+ (((unsigned long)(chunk2mem(p))) % alignment) == 0);
-+ }
-+
-+ /* Also give back spare room at the end */
-+ if (!chunk_is_mmapped(p)) {
-+ size = chunksize(p);
-+ if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
-+ remainder_size = size - nb;
-+ remainder = chunk_at_offset(p, nb);
-+ set_head(remainder, remainder_size | PREV_INUSE);
-+ set_head_size(p, nb);
-+ fREe(chunk2mem(remainder));
-+ }
-+ }
-+
-+ check_inuse_chunk(p);
-+ return chunk2mem(p);
-+}
-+
-+/*
-+ ------------------------------ calloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* cALLOc(size_t n_elements, size_t elem_size)
-+#else
-+Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size;
-+#endif
-+{
-+ mchunkptr p;
-+ unsigned long clearsize;
-+ unsigned long nclears;
-+ INTERNAL_SIZE_T* d;
-+
-+ Void_t* mem = mALLOc(n_elements * elem_size);
-+
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+
-+ if (!chunk_is_mmapped(p))
-+ {
-+ /*
-+ Unroll clear of <= 36 bytes (72 if 8byte sizes)
-+ We know that contents have an odd number of
-+ INTERNAL_SIZE_T-sized words; minimally 3.
-+ */
-+
-+ d = (INTERNAL_SIZE_T*)mem;
-+ clearsize = chunksize(p) - SIZE_SZ;
-+ nclears = clearsize / sizeof(INTERNAL_SIZE_T);
-+ assert(nclears >= 3);
-+
-+ if (nclears > 9)
-+ MALLOC_ZERO(d, clearsize);
-+
-+ else {
-+ *(d+0) = 0;
-+ *(d+1) = 0;
-+ *(d+2) = 0;
-+ if (nclears > 4) {
-+ *(d+3) = 0;
-+ *(d+4) = 0;
-+ if (nclears > 6) {
-+ *(d+5) = 0;
-+ *(d+6) = 0;
-+ if (nclears > 8) {
-+ *(d+7) = 0;
-+ *(d+8) = 0;
-+ }
-+ }
-+ }
-+ }
-+ }
-+#if ! MMAP_CLEARS
-+ else
-+ {
-+ d = (INTERNAL_SIZE_T*)mem;
-+ clearsize = chunksize(p) - 2 * SIZE_SZ;
-+ MALLOC_ZERO(d, clearsize);
-+ }
-+#endif
-+ }
-+ return mem;
-+}
-+
-+/*
-+ ------------------------------ cfree ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+void cFREe(Void_t *mem)
-+#else
-+void cFREe(mem) Void_t *mem;
-+#endif
-+{
-+ fREe(mem);
-+}
-+
-+/*
-+ ------------------------------ ialloc ------------------------------
-+ ialloc 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
-+*/
-+
-+
-+INLINE
-+#if __STD_C
-+static Void_t** iALLOc(size_t n_elements,
-+ size_t* sizes,
-+ int opts,
-+ Void_t* chunks[])
-+#else
-+static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ INTERNAL_SIZE_T element_size; /* chunksize of each element, if all same */
-+ INTERNAL_SIZE_T contents_size; /* total size of elements */
-+ INTERNAL_SIZE_T array_size; /* request size of pointer array */
-+ Void_t* mem; /* malloced aggregate space */
-+ mchunkptr p; /* corresponding chunk */
-+ INTERNAL_SIZE_T remainder_size; /* remaining bytes while splitting */
-+ Void_t** marray; /* either "chunks" or malloced ptr array */
-+ mchunkptr array_chunk; /* chunk for malloced ptr array */
-+ int mmx; /* to disable mmap */
-+ INTERNAL_SIZE_T size;
-+ size_t i;
-+
-+ /* Ensure initialization/consolidation */
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+
-+ /* 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_t**) mALLOc(0);
-+ marray = 0;
-+ array_size = request2size(n_elements * (sizeof(Void_t*)));
-+ }
-+
-+ /* 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]);
-+ }
-+
-+ /* subtract out alignment bytes from total to minimize overallocation */
-+ size = contents_size + array_size - MALLOC_ALIGN_MASK;
-+
-+ /*
-+ Allocate the aggregate chunk.
-+ But first disable mmap so malloc won't use it, since
-+ we would not be able to later free/realloc space internal
-+ to a segregated mmap region.
-+ */
-+ mmx = av->n_mmaps_max; /* disable mmap */
-+ av->n_mmaps_max = 0;
-+ mem = mALLOc(size);
-+ av->n_mmaps_max = mmx; /* reset mmap */
-+ if (mem == 0)
-+ return 0;
-+
-+ p = mem2chunk(mem);
-+ assert(!chunk_is_mmapped(p));
-+ remainder_size = chunksize(p);
-+
-+ if (opts & 0x2) { /* optionally clear the elements */
-+ MALLOC_ZERO(mem, remainder_size - SIZE_SZ - array_size);
-+ }
-+
-+ /* If not provided, allocate the pointer array as final part of chunk */
-+ if (marray == 0) {
-+ array_chunk = chunk_at_offset(p, contents_size);
-+ marray = (Void_t**) (chunk2mem(array_chunk));
-+ set_head(array_chunk, (remainder_size - contents_size) | PREV_INUSE);
-+ 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_head(p, size | PREV_INUSE);
-+ p = chunk_at_offset(p, size);
-+ }
-+ else { /* the final element absorbs any overallocation slop */
-+ set_head(p, remainder_size | PREV_INUSE);
-+ break;
-+ }
-+ }
-+
-+#ifdef 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(mem2chunk(marray));
-+ }
-+
-+ for (i = 0; i != n_elements; ++i)
-+ check_inuse_chunk(mem2chunk(marray[i]));
-+#endif
-+
-+ return marray;
-+}
-+
-+
-+/*
-+ ------------------------- independent_calloc -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])
-+#else
-+Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];
-+#endif
-+{
-+ size_t sz = elem_size; /* serves as 1-element array */
-+ /* opts arg of 3 means all elements are same size, and should be cleared */
-+ return iALLOc(n_elements, &sz, 3, chunks);
-+}
-+
-+/*
-+ ------------------------- independent_comalloc -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])
-+#else
-+Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];
-+#endif
-+{
-+ return iALLOc(n_elements, sizes, 0, chunks);
-+}
-+
-+
-+/*
-+ ------------------------------ valloc ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+Void_t* vALLOc(size_t bytes)
-+#else
-+Void_t* vALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ /* Ensure initialization/consolidation */
-+ mstate av = get_malloc_state();
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+ return mEMALIGn(av->pagesize, bytes);
-+}
-+
-+/*
-+ ------------------------------ pvalloc ------------------------------
-+*/
-+
-+
-+#if __STD_C
-+Void_t* pVALLOc(size_t bytes)
-+#else
-+Void_t* pVALLOc(bytes) size_t bytes;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ size_t pagesz;
-+
-+ /* Ensure initialization/consolidation */
-+ if (have_fastchunks(av)) malloc_consolidate(av);
-+ pagesz = av->pagesize;
-+ return mEMALIGn(pagesz, (bytes + pagesz - 1) & ~(pagesz - 1));
-+}
-+
-+
-+/*
-+ ------------------------------ malloc_trim ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+int mTRIm(size_t pad)
-+#else
-+int mTRIm(pad) size_t pad;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ /* Ensure initialization/consolidation */
-+ malloc_consolidate(av);
-+
-+#ifndef MORECORE_CANNOT_TRIM
-+ return sYSTRIm(pad, av);
-+#else
-+ return 0;
-+#endif
-+}
-+
-+
-+/*
-+ ------------------------- malloc_usable_size -------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+size_t mUSABLe(Void_t* mem)
-+#else
-+size_t mUSABLe(mem) Void_t* mem;
-+#endif
-+{
-+ mchunkptr p;
-+ if (mem != 0) {
-+ p = mem2chunk(mem);
-+ if (chunk_is_mmapped(p))
-+ return chunksize(p) - 2*SIZE_SZ;
-+ else if (inuse(p))
-+ return chunksize(p) - SIZE_SZ;
-+ }
-+ return 0;
-+}
-+
-+/*
-+ ------------------------------ mallinfo ------------------------------
-+*/
-+
-+struct mallinfo mALLINFo()
-+{
-+ mstate av = get_malloc_state();
-+ struct mallinfo mi;
-+ unsigned int i;
-+ mbinptr b;
-+ mchunkptr p;
-+ INTERNAL_SIZE_T avail;
-+ INTERNAL_SIZE_T fastavail;
-+ int nblocks;
-+ int nfastblocks;
-+
-+ /* Ensure initialization */
-+ if (av->top == 0) malloc_consolidate(av);
-+
-+ check_malloc_state();
-+
-+ /* Account for top */
-+ avail = chunksize(av->top);
-+ nblocks = 1; /* top always exists */
-+
-+ /* traverse fastbins */
-+ nfastblocks = 0;
-+ fastavail = 0;
-+
-+ for (i = 0; i < NFASTBINS; ++i) {
-+ for (p = av->fastbins[i]; p != 0; p = p->fd) {
-+ ++nfastblocks;
-+ fastavail += chunksize(p);
-+ }
-+ }
-+
-+ avail += fastavail;
-+
-+ /* traverse regular bins */
-+ for (i = 1; i < NBINS; ++i) {
-+ b = bin_at(av, i);
-+ for (p = last(b); p != b; p = p->bk) {
-+ ++nblocks;
-+ avail += chunksize(p);
-+ }
-+ }
-+
-+ mi.smblks = nfastblocks;
-+ mi.ordblks = nblocks;
-+ mi.fordblks = avail;
-+ mi.uordblks = av->sbrked_mem - avail;
-+ mi.arena = av->sbrked_mem;
-+ mi.hblks = av->n_mmaps;
-+ mi.hblkhd = av->mmapped_mem;
-+ mi.fsmblks = fastavail;
-+ mi.keepcost = chunksize(av->top);
-+ mi.usmblks = av->max_total_mem;
-+ return mi;
-+}
-+
-+/*
-+ ------------------------------ malloc_stats ------------------------------
-+*/
-+
-+void mSTATs()
-+{
-+ struct mallinfo mi = mALLINFo();
-+
-+#ifdef WIN32
-+ {
-+ unsigned long free, reserved, committed;
-+ vminfo (&free, &reserved, &committed);
-+ fprintf(stderr, "free bytes = %10lu\n",
-+ free);
-+ fprintf(stderr, "reserved bytes = %10lu\n",
-+ reserved);
-+ fprintf(stderr, "committed bytes = %10lu\n",
-+ committed);
-+ }
-+#endif
-+
-+
-+ fprintf(stderr, "max system bytes = %10lu\n",
-+ (unsigned long)(mi.usmblks));
-+ fprintf(stderr, "system bytes = %10lu\n",
-+ (unsigned long)(mi.arena + mi.hblkhd));
-+ fprintf(stderr, "in use bytes = %10lu\n",
-+ (unsigned long)(mi.uordblks + mi.hblkhd));
-+
-+
-+#ifdef WIN32
-+ {
-+ unsigned long kernel, user;
-+ if (cpuinfo (TRUE, &kernel, &user)) {
-+ fprintf(stderr, "kernel ms = %10lu\n",
-+ kernel);
-+ fprintf(stderr, "user ms = %10lu\n",
-+ user);
-+ }
-+ }
-+#endif
-+}
-+
-+
-+/*
-+ ------------------------------ mallopt ------------------------------
-+*/
-+
-+INLINE
-+#if __STD_C
-+int mALLOPt(int param_number, int value)
-+#else
-+int mALLOPt(param_number, value) int param_number; int value;
-+#endif
-+{
-+ mstate av = get_malloc_state();
-+ /* Ensure initialization/consolidation */
-+ malloc_consolidate(av);
-+
-+ switch(param_number) {
-+ case M_MXFAST:
-+ if (value >= 0 && value <= MAX_FAST_SIZE) {
-+ set_max_fast(av, value);
-+ return 1;
-+ }
-+ else
-+ return 0;
-+
-+ case M_TRIM_THRESHOLD:
-+ av->trim_threshold = value;
-+ return 1;
-+
-+ case M_TOP_PAD:
-+ av->top_pad = value;
-+ return 1;
-+
-+ case M_MMAP_THRESHOLD:
-+ av->mmap_threshold = value;
-+ return 1;
-+
-+ case M_MMAP_MAX:
-+#if !HAVE_MMAP
-+ if (value != 0)
-+ return 0;
-+#endif
-+ av->n_mmaps_max = value;
-+ return 1;
-+
-+ default:
-+ return 0;
-+ }
-+}
-+
-+
-+/*
-+ -------------------- Alternative MORECORE functions --------------------
-+*/
-+
-+
-+/*
-+ General Requirements for MORECORE.
-+
-+ The MORECORE function must have the following properties:
-+
-+ If MORECORE_CONTIGUOUS is false:
-+
-+ * MORECORE must allocate in multiples of pagesize. It will
-+ only be called with arguments that are multiples of pagesize.
-+
-+ * MORECORE(0) must return an address that is at least
-+ MALLOC_ALIGNMENT aligned. (Page-aligning always suffices.)
-+
-+ else (i.e. If MORECORE_CONTIGUOUS is true):
-+
-+ * Consecutive calls to MORECORE with positive arguments
-+ return increasing addresses, indicating that space has been
-+ contiguously extended.
-+
-+ * MORECORE need not allocate in multiples of pagesize.
-+ Calls to MORECORE need not have args of multiples of pagesize.
-+
-+ * MORECORE need not page-align.
-+
-+ In either case:
-+
-+ * MORECORE may allocate more memory than requested. (Or even less,
-+ but this will generally result in a malloc failure.)
-+
-+ * MORECORE must not allocate memory when given argument zero, but
-+ instead return one past the end address of memory from previous
-+ nonzero call. This malloc does NOT call MORECORE(0)
-+ until at least one call with positive arguments is made, so
-+ the initial value returned is not important.
-+
-+ * Even though consecutive calls to MORECORE need not return contiguous
-+ addresses, it must be OK for malloc'ed chunks to span multiple
-+ regions in those cases where they do happen to be contiguous.
-+
-+ * MORECORE need not handle negative arguments -- it may instead
-+ just return MORECORE_FAILURE when given negative arguments.
-+ Negative arguments are always multiples of pagesize. MORECORE
-+ must not misinterpret negative args as large positive unsigned
-+ args. You can suppress all such calls from even occurring by defining
-+ MORECORE_CANNOT_TRIM,
-+
-+ There is some variation across systems about the type of the
-+ argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
-+ actually be size_t, because sbrk supports negative args, so it is
-+ normally the signed type of the same width as size_t (sometimes
-+ declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much
-+ matter though. Internally, we use "long" as arguments, which should
-+ work across all reasonable possibilities.
-+
-+ Additionally, if MORECORE ever returns failure for a positive
-+ 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 map noncontiguous space.
-+
-+ If you'd like mmap to ALWAYS be used, you can define MORECORE to be
-+ a function that always returns MORECORE_FAILURE.
-+
-+ If you are using this malloc with something other than sbrk (or its
-+ emulation) to supply memory regions, you probably want to set
-+ MORECORE_CONTIGUOUS as false. As an example, here is a custom
-+ allocator kindly contributed for pre-OSX macOS. It uses virtually
-+ but not necessarily physically contiguous non-paged memory (locked
-+ in, present and won't get swapped out). You can use it by
-+ uncommenting this section, adding some #includes, and setting up the
-+ appropriate defines above:
-+
-+ #define MORECORE osMoreCore
-+ #define MORECORE_CONTIGUOUS 0
-+
-+ There is also a shutdown routine that should somehow be called for
-+ cleanup upon program exit.
-+
-+ #define MAX_POOL_ENTRIES 100
-+ #define MINIMUM_MORECORE_SIZE (64 * 1024)
-+ static int next_os_pool;
-+ void *our_os_pools[MAX_POOL_ENTRIES];
-+
-+ void *osMoreCore(int size)
-+ {
-+ void *ptr = 0;
-+ static void *sbrk_top = 0;
-+
-+ if (size > 0)
-+ {
-+ if (size < MINIMUM_MORECORE_SIZE)
-+ size = MINIMUM_MORECORE_SIZE;
-+ if (CurrentExecutionLevel() == kTaskLevel)
-+ ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
-+ if (ptr == 0)
-+ {
-+ return (void *) MORECORE_FAILURE;
-+ }
-+ // save ptrs so they can be freed during cleanup
-+ our_os_pools[next_os_pool] = ptr;
-+ next_os_pool++;
-+ ptr = (void *) ((((unsigned long) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
-+ sbrk_top = (char *) ptr + size;
-+ return ptr;
-+ }
-+ else if (size < 0)
-+ {
-+ // we don't currently support shrink behavior
-+ return (void *) MORECORE_FAILURE;
-+ }
-+ else
-+ {
-+ return sbrk_top;
-+ }
-+ }
-+
-+ // cleanup any allocated memory pools
-+ // called as last thing before shutting down driver
-+
-+ void osCleanupMem(void)
-+ {
-+ void **ptr;
-+
-+ for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
-+ if (*ptr)
-+ {
-+ PoolDeallocate(*ptr);
-+ *ptr = 0;
-+ }
-+ }
-+
-+*/
-+
-+
-+/*
-+ --------------------------------------------------------------
-+
-+ Emulation of sbrk for win32.
-+ Donated by J. Walter <Walter@GeNeSys-e.de>.
-+ For additional information about this code, and malloc on Win32, see
-+ http://www.genesys-e.de/jwalter/
-+*/
-+
-+
-+#ifdef WIN32
-+
-+#ifdef _DEBUG
-+/* #define TRACE */
-+#endif
-+
-+/* Support for USE_MALLOC_LOCK */
-+#ifdef USE_MALLOC_LOCK
-+
-+/* Wait for spin lock */
-+static int slwait (int *sl) {
-+ while (InterlockedCompareExchange ((void **) sl, (void *) 1, (void *) 0) != 0)
-+ Sleep (0);
-+ return 0;
-+}
-+
-+/* Release spin lock */
-+static int slrelease (int *sl) {
-+ InterlockedExchange (sl, 0);
-+ return 0;
-+}
-+
-+#ifdef NEEDED
-+/* Spin lock for emulation code */
-+static int g_sl;
-+#endif
-+
-+#endif /* USE_MALLOC_LOCK */
-+
-+/* getpagesize for windows */
-+static long getpagesize (void) {
-+ static long g_pagesize = 0;
-+ if (! g_pagesize) {
-+ SYSTEM_INFO system_info;
-+ GetSystemInfo (&system_info);
-+ g_pagesize = system_info.dwPageSize;
-+ }
-+ return g_pagesize;
-+}
-+static long getregionsize (void) {
-+ static long g_regionsize = 0;
-+ if (! g_regionsize) {
-+ SYSTEM_INFO system_info;
-+ GetSystemInfo (&system_info);
-+ g_regionsize = system_info.dwAllocationGranularity;
-+ }
-+ return g_regionsize;
-+}
-+
-+/* A region list entry */
-+typedef struct _region_list_entry {
-+ void *top_allocated;
-+ void *top_committed;
-+ void *top_reserved;
-+ long reserve_size;
-+ struct _region_list_entry *previous;
-+} region_list_entry;
-+
-+/* Allocate and link a region entry in the region list */
-+static int region_list_append (region_list_entry **last, void *base_reserved, long reserve_size) {
-+ region_list_entry *next = HeapAlloc (GetProcessHeap (), 0, sizeof (region_list_entry));
-+ if (! next)
-+ return FALSE;
-+ next->top_allocated = (char *) base_reserved;
-+ next->top_committed = (char *) base_reserved;
-+ next->top_reserved = (char *) base_reserved + reserve_size;
-+ next->reserve_size = reserve_size;
-+ next->previous = *last;
-+ *last = next;
-+ return TRUE;
-+}
-+/* Free and unlink the last region entry from the region list */
-+static int region_list_remove (region_list_entry **last) {
-+ region_list_entry *previous = (*last)->previous;
-+ if (! HeapFree (GetProcessHeap (), sizeof (region_list_entry), *last))
-+ return FALSE;
-+ *last = previous;
-+ return TRUE;
-+}
-+
-+#define CEIL(size,to) (((size)+(to)-1)&~((to)-1))
-+#define FLOOR(size,to) ((size)&~((to)-1))
-+
-+#define SBRK_SCALE 0
-+/* #define SBRK_SCALE 1 */
-+/* #define SBRK_SCALE 2 */
-+/* #define SBRK_SCALE 4 */
-+
-+/* sbrk for windows */
-+static void *sbrk (long size) {
-+ static long g_pagesize, g_my_pagesize;
-+ static long g_regionsize, g_my_regionsize;
-+ static region_list_entry *g_last;
-+ void *result = (void *) MORECORE_FAILURE;
-+#ifdef TRACE
-+ printf ("sbrk %d\n", size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize) {
-+ g_pagesize = getpagesize ();
-+ g_my_pagesize = g_pagesize << SBRK_SCALE;
-+ }
-+ if (! g_regionsize) {
-+ g_regionsize = getregionsize ();
-+ g_my_regionsize = g_regionsize << SBRK_SCALE;
-+ }
-+ if (! g_last) {
-+ if (! region_list_append (&g_last, 0, 0))
-+ goto sbrk_exit;
-+ }
-+ /* Assert invariants */
-+ assert (g_last);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
-+ g_last->top_allocated <= g_last->top_committed);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
-+ g_last->top_committed <= g_last->top_reserved &&
-+ (unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
-+ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
-+ /* Allocation requested? */
-+ if (size >= 0) {
-+ /* Allocation size is the requested size */
-+ long allocate_size = size;
-+ /* Compute the size to commit */
-+ long to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Do we reach the commit limit? */
-+ if (to_commit > 0) {
-+ /* Round size to commit */
-+ long commit_size = CEIL (to_commit, g_my_pagesize);
-+ /* Compute the size to reserve */
-+ long to_reserve = (char *) g_last->top_committed + commit_size - (char *) g_last->top_reserved;
-+ /* Do we reach the reserve limit? */
-+ if (to_reserve > 0) {
-+ /* Compute the remaining size to commit in the current region */
-+ long remaining_commit_size = (char *) g_last->top_reserved - (char *) g_last->top_committed;
-+ if (remaining_commit_size > 0) {
-+ /* Assert preconditions */
-+ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert (0 < remaining_commit_size && remaining_commit_size % g_pagesize == 0); {
-+ /* Commit this */
-+ void *base_committed = VirtualAlloc (g_last->top_committed, remaining_commit_size,
-+ MEM_COMMIT, PAGE_READWRITE);
-+ /* Check returned pointer for consistency */
-+ if (base_committed != g_last->top_committed)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", base_committed, remaining_commit_size);
-+#endif
-+ /* Adjust the regions commit top */
-+ g_last->top_committed = (char *) base_committed + remaining_commit_size;
-+ }
-+ } {
-+ /* Now we are going to search and reserve. */
-+ int contiguous = -1;
-+ int found = FALSE;
-+ MEMORY_BASIC_INFORMATION memory_info;
-+ void *base_reserved;
-+ long reserve_size;
-+ do {
-+ /* Assume contiguous memory */
-+ contiguous = TRUE;
-+ /* Round size to reserve */
-+ reserve_size = CEIL (to_reserve, g_my_regionsize);
-+ /* Start with the current region's top */
-+ memory_info.BaseAddress = g_last->top_reserved;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
-+ /* Assert postconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Query %p %d %s\n", memory_info.BaseAddress, memory_info.RegionSize,
-+ memory_info.State == MEM_FREE ? "FREE":
-+ (memory_info.State == MEM_RESERVE ? "RESERVED":
-+ (memory_info.State == MEM_COMMIT ? "COMMITTED": "?")));
-+#endif
-+ /* Region is free, well aligned and big enough: we are done */
-+ if (memory_info.State == MEM_FREE &&
-+ (unsigned) memory_info.BaseAddress % g_regionsize == 0 &&
-+ memory_info.RegionSize >= (unsigned) reserve_size) {
-+ found = TRUE;
-+ break;
-+ }
-+ /* From now on we can't get contiguous memory! */
-+ contiguous = FALSE;
-+ /* Recompute size to reserve */
-+ reserve_size = CEIL (allocate_size, g_my_regionsize);
-+ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ }
-+ /* Search failed? */
-+ if (! found)
-+ goto sbrk_exit;
-+ /* Assert preconditions */
-+ assert ((unsigned) memory_info.BaseAddress % g_regionsize == 0);
-+ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
-+ /* Try to reserve this */
-+ base_reserved = VirtualAlloc (memory_info.BaseAddress, reserve_size,
-+ MEM_RESERVE, PAGE_NOACCESS);
-+ if (! base_reserved) {
-+ int rc = GetLastError ();
-+ if (rc != ERROR_INVALID_ADDRESS)
-+ goto sbrk_exit;
-+ }
-+ /* A null pointer signals (hopefully) a race condition with another thread. */
-+ /* In this case, we try again. */
-+ } while (! base_reserved);
-+ /* Check returned pointer for consistency */
-+ if (memory_info.BaseAddress && base_reserved != memory_info.BaseAddress)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_reserved % g_regionsize == 0);
-+#ifdef TRACE
-+ printf ("Reserve %p %d\n", base_reserved, reserve_size);
-+#endif
-+ /* Did we get contiguous memory? */
-+ if (contiguous) {
-+ long start_size = (char *) g_last->top_committed - (char *) g_last->top_allocated;
-+ /* Adjust allocation size */
-+ allocate_size -= start_size;
-+ /* Adjust the regions allocation top */
-+ g_last->top_allocated = g_last->top_committed;
-+ /* Recompute the size to commit */
-+ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Round size to commit */
-+ commit_size = CEIL (to_commit, g_my_pagesize);
-+ }
-+ /* Append the new region to the list */
-+ if (! region_list_append (&g_last, base_reserved, reserve_size))
-+ goto sbrk_exit;
-+ /* Didn't we get contiguous memory? */
-+ if (! contiguous) {
-+ /* Recompute the size to commit */
-+ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
-+ /* Round size to commit */
-+ commit_size = CEIL (to_commit, g_my_pagesize);
-+ }
-+ }
-+ }
-+ /* Assert preconditions */
-+ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert (0 < commit_size && commit_size % g_pagesize == 0); {
-+ /* Commit this */
-+ void *base_committed = VirtualAlloc (g_last->top_committed, commit_size,
-+ MEM_COMMIT, PAGE_READWRITE);
-+ /* Check returned pointer for consistency */
-+ if (base_committed != g_last->top_committed)
-+ goto sbrk_exit;
-+ /* Assert postconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", base_committed, commit_size);
-+#endif
-+ /* Adjust the regions commit top */
-+ g_last->top_committed = (char *) base_committed + commit_size;
-+ }
-+ }
-+ /* Adjust the regions allocation top */
-+ g_last->top_allocated = (char *) g_last->top_allocated + allocate_size;
-+ result = (char *) g_last->top_allocated - size;
-+ /* Deallocation requested? */
-+ } else if (size < 0) {
-+ long deallocate_size = - size;
-+ /* As long as we have a region to release */
-+ while ((char *) g_last->top_allocated - deallocate_size < (char *) g_last->top_reserved - g_last->reserve_size) {
-+ /* Get the size to release */
-+ long release_size = g_last->reserve_size;
-+ /* Get the base address */
-+ void *base_reserved = (char *) g_last->top_reserved - release_size;
-+ /* Assert preconditions */
-+ assert ((unsigned) base_reserved % g_regionsize == 0);
-+ assert (0 < release_size && release_size % g_regionsize == 0); {
-+ /* Release this */
-+ int rc = VirtualFree (base_reserved, 0,
-+ MEM_RELEASE);
-+ /* Check returned code for consistency */
-+ if (! rc)
-+ goto sbrk_exit;
-+#ifdef TRACE
-+ printf ("Release %p %d\n", base_reserved, release_size);
-+#endif
-+ }
-+ /* Adjust deallocation size */
-+ deallocate_size -= (char *) g_last->top_allocated - (char *) base_reserved;
-+ /* Remove the old region from the list */
-+ if (! region_list_remove (&g_last))
-+ goto sbrk_exit;
-+ } {
-+ /* Compute the size to decommit */
-+ long to_decommit = (char *) g_last->top_committed - ((char *) g_last->top_allocated - deallocate_size);
-+ if (to_decommit >= g_my_pagesize) {
-+ /* Compute the size to decommit */
-+ long decommit_size = FLOOR (to_decommit, g_my_pagesize);
-+ /* Compute the base address */
-+ void *base_committed = (char *) g_last->top_committed - decommit_size;
-+ /* Assert preconditions */
-+ assert ((unsigned) base_committed % g_pagesize == 0);
-+ assert (0 < decommit_size && decommit_size % g_pagesize == 0); {
-+ /* Decommit this */
-+ int rc = VirtualFree ((char *) base_committed, decommit_size,
-+ MEM_DECOMMIT);
-+ /* Check returned code for consistency */
-+ if (! rc)
-+ goto sbrk_exit;
-+#ifdef TRACE
-+ printf ("Decommit %p %d\n", base_committed, decommit_size);
-+#endif
-+ }
-+ /* Adjust deallocation size and regions commit and allocate top */
-+ deallocate_size -= (char *) g_last->top_allocated - (char *) base_committed;
-+ g_last->top_committed = base_committed;
-+ g_last->top_allocated = base_committed;
-+ }
-+ }
-+ /* Adjust regions allocate top */
-+ g_last->top_allocated = (char *) g_last->top_allocated - deallocate_size;
-+ /* Check for underflow */
-+ if ((char *) g_last->top_reserved - g_last->reserve_size > (char *) g_last->top_allocated ||
-+ g_last->top_allocated > g_last->top_committed) {
-+ /* Adjust regions allocate top */
-+ g_last->top_allocated = (char *) g_last->top_reserved - g_last->reserve_size;
-+ goto sbrk_exit;
-+ }
-+ result = g_last->top_allocated;
-+ }
-+ /* Assert invariants */
-+ assert (g_last);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
-+ g_last->top_allocated <= g_last->top_committed);
-+ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
-+ g_last->top_committed <= g_last->top_reserved &&
-+ (unsigned) g_last->top_committed % g_pagesize == 0);
-+ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
-+ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
-+
-+sbrk_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return result;
-+}
-+
-+/* mmap for windows */
-+static void *mmap (void *ptr, long size, long prot, long type, long handle, long arg) {
-+ static long g_pagesize;
-+ static long g_regionsize;
-+#ifdef TRACE
-+ printf ("mmap %d\n", size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize)
-+ g_pagesize = getpagesize ();
-+ if (! g_regionsize)
-+ g_regionsize = getregionsize ();
-+ /* Assert preconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+ assert (size % g_pagesize == 0);
-+ /* Allocate this */
-+ ptr = VirtualAlloc (ptr, size,
-+ MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE);
-+ if (! ptr) {
-+ ptr = (void *) MORECORE_FAILURE;
-+ goto mmap_exit;
-+ }
-+ /* Assert postconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+#ifdef TRACE
-+ printf ("Commit %p %d\n", ptr, size);
-+#endif
-+mmap_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return ptr;
-+}
-+
-+/* munmap for windows */
-+static long munmap (void *ptr, long size) {
-+ static long g_pagesize;
-+ static long g_regionsize;
-+ int rc = MUNMAP_FAILURE;
-+#ifdef TRACE
-+ printf ("munmap %p %d\n", ptr, size);
-+#endif
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Wait for spin lock */
-+ slwait (&g_sl);
-+#endif
-+ /* First time initialization */
-+ if (! g_pagesize)
-+ g_pagesize = getpagesize ();
-+ if (! g_regionsize)
-+ g_regionsize = getregionsize ();
-+ /* Assert preconditions */
-+ assert ((unsigned) ptr % g_regionsize == 0);
-+ assert (size % g_pagesize == 0);
-+ /* Free this */
-+ if (! VirtualFree (ptr, 0,
-+ MEM_RELEASE))
-+ goto munmap_exit;
-+ rc = 0;
-+#ifdef TRACE
-+ printf ("Release %p %d\n", ptr, size);
-+#endif
-+munmap_exit:
-+#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
-+ /* Release spin lock */
-+ slrelease (&g_sl);
-+#endif
-+ return rc;
-+}
-+
-+static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed) {
-+ MEMORY_BASIC_INFORMATION memory_info;
-+ memory_info.BaseAddress = 0;
-+ *free = *reserved = *committed = 0;
-+ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
-+ switch (memory_info.State) {
-+ case MEM_FREE:
-+ *free += memory_info.RegionSize;
-+ break;
-+ case MEM_RESERVE:
-+ *reserved += memory_info.RegionSize;
-+ break;
-+ case MEM_COMMIT:
-+ *committed += memory_info.RegionSize;
-+ break;
-+ }
-+ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
-+ }
-+}
-+
-+static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user) {
-+ if (whole) {
-+ __int64 creation64, exit64, kernel64, user64;
-+ int rc = GetProcessTimes (GetCurrentProcess (),
-+ (FILETIME *) &creation64,
-+ (FILETIME *) &exit64,
-+ (FILETIME *) &kernel64,
-+ (FILETIME *) &user64);
-+ if (! rc) {
-+ *kernel = 0;
-+ *user = 0;
-+ return FALSE;
-+ }
-+ *kernel = (unsigned long) (kernel64 / 10000);
-+ *user = (unsigned long) (user64 / 10000);
-+ return TRUE;
-+ } else {
-+ __int64 creation64, exit64, kernel64, user64;
-+ int rc = GetThreadTimes (GetCurrentThread (),
-+ (FILETIME *) &creation64,
-+ (FILETIME *) &exit64,
-+ (FILETIME *) &kernel64,
-+ (FILETIME *) &user64);
-+ if (! rc) {
-+ *kernel = 0;
-+ *user = 0;
-+ return FALSE;
-+ }
-+ *kernel = (unsigned long) (kernel64 / 10000);
-+ *user = (unsigned long) (user64 / 10000);
-+ return TRUE;
-+ }
-+}
-+
-+#endif /* WIN32 */
-+
-+/* ------------------------------------------------------------
-+History:
-+
-+ V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
-+ * Introduce independent_comalloc and independent_calloc.
-+ Thanks to Michael Pachos for motivation and help.
-+ * Make optional .h file available
-+ * Allow > 2GB requests on 32bit systems.
-+ * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>.
-+ Thanks also to Andreas Mueller <a.mueller at paradatec.de>,
-+ and Anonymous.
-+ * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for
-+ helping test this.)
-+ * memalign: check alignment arg
-+ * realloc: don't try to shift chunks backwards, since this
-+ leads to more fragmentation in some programs and doesn't
-+ seem to help in any others.
-+ * Collect all cases in malloc requiring system memory into sYSMALLOc
-+ * Use mmap as backup to sbrk
-+ * Place all internal state in malloc_state
-+ * Introduce fastbins (although similar to 2.5.1)
-+ * Many minor tunings and cosmetic improvements
-+ * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK
-+ * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS
-+ Thanks to Tony E. Bennett <tbennett@nvidia.com> and others.
-+ * Include errno.h to support default failure action.
-+
-+ V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee)
-+ * return null for negative arguments
-+ * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com>
-+ * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h'
-+ (e.g. WIN32 platforms)
-+ * Cleanup header file inclusion for WIN32 platforms
-+ * Cleanup code to avoid Microsoft Visual C++ compiler complaints
-+ * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing
-+ memory allocation routines
-+ * Set 'malloc_getpagesize' for WIN32 platforms (needs more work)
-+ * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to
-+ usage of 'assert' in non-WIN32 code
-+ * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to
-+ avoid infinite loop
-+ * Always call 'fREe()' rather than 'free()'
-+
-+ V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee)
-+ * Fixed ordering problem with boundary-stamping
-+
-+ V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
-+ * Added pvalloc, as recommended by H.J. Liu
-+ * Added 64bit pointer support mainly from Wolfram Gloger
-+ * Added anonymously donated WIN32 sbrk emulation
-+ * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
-+ * malloc_extend_top: fix mask error that caused wastage after
-+ foreign sbrks
-+ * Add linux mremap support code from HJ Liu
-+
-+ V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
-+ * Integrated most documentation with the code.
-+ * Add support for mmap, with help from
-+ Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
-+ * Use last_remainder in more cases.
-+ * Pack bins using idea from colin@nyx10.cs.du.edu
-+ * Use ordered bins instead of best-fit threshold
-+ * Eliminate block-local decls to simplify tracing and debugging.
-+ * Support another case of realloc via move into top
-+ * Fix error occurring when initial sbrk_base not word-aligned.
-+ * Rely on page size for units instead of SBRK_UNIT to
-+ avoid surprises about sbrk alignment conventions.
-+ * Add mallinfo, mallopt. Thanks to Raymond Nijssen
-+ (raymond@es.ele.tue.nl) for the suggestion.
-+ * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
-+ * More precautions for cases where other routines call sbrk,
-+ courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
-+ * Added macros etc., allowing use in linux libc from
-+ H.J. Lu (hjl@gnu.ai.mit.edu)
-+ * Inverted this history list
-+
-+ V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
-+ * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
-+ * Removed all preallocation code since under current scheme
-+ the work required to undo bad preallocations exceeds
-+ the work saved in good cases for most test programs.
-+ * No longer use return list or unconsolidated bins since
-+ no scheme using them consistently outperforms those that don't
-+ given above changes.
-+ * Use best fit for very large chunks to prevent some worst-cases.
-+ * Added some support for debugging
-+
-+ V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
-+ * Removed footers when chunks are in use. Thanks to
-+ Paul Wilson (wilson@cs.texas.edu) for the suggestion.
-+
-+ V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
-+ * Added malloc_trim, with help from Wolfram Gloger
-+ (wmglo@Dent.MED.Uni-Muenchen.DE).
-+
-+ V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
-+
-+ V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
-+ * realloc: try to expand in both directions
-+ * malloc: swap order of clean-bin strategy;
-+ * realloc: only conditionally expand backwards
-+ * Try not to scavenge used bins
-+ * Use bin counts as a guide to preallocation
-+ * Occasionally bin return list chunks in first scan
-+ * Add a few optimizations from colin@nyx10.cs.du.edu
-+
-+ V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
-+ * faster bin computation & slightly different binning
-+ * merged all consolidations to one part of malloc proper
-+ (eliminating old malloc_find_space & malloc_clean_bin)
-+ * Scan 2 returns chunks (not just 1)
-+ * Propagate failure in realloc if malloc returns 0
-+ * Add stuff to allow compilation on non-ANSI compilers
-+ from kpv@research.att.com
-+
-+ V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
-+ * removed potential for odd address access in prev_chunk
-+ * removed dependency on getpagesize.h
-+ * misc cosmetics and a bit more internal documentation
-+ * anticosmetics: mangled names in macros to evade debugger strangeness
-+ * tested on sparc, hp-700, dec-mips, rs6000
-+ with gcc & native cc (hp, dec only) allowing
-+ Detlefs & Zorn comparison study (in SIGPLAN Notices.)
-+
-+ Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
-+ * Based loosely on libg++-1.2X malloc. (It retains some of the overall
-+ structure of old version, but most details differ.)
-+
-+*/
-+
-+#ifdef USE_PUBLIC_MALLOC_WRAPPERS
-+
-+#ifndef KDE_MALLOC_FULL
-+
-+#ifdef KDE_MALLOC_GLIBC
-+#include "glibc.h"
-+#else
-+/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/
-+#error Unknown libc
-+#endif
-+
-+/* 0 - uninitialized
-+ 1 - this malloc
-+ 2 - standard libc malloc*/
-+extern char* getenv(const char*);
-+static int malloc_type = 0;
-+static void init_malloc_type(void)
-+ {
-+ const char* const env = getenv( "KDE_MALLOC" );
-+ if( env == NULL )
-+ malloc_type = 1;
-+ else if( env[ 0 ] == '0' || env[ 0 ] == 'n' || env[ 0 ] == 'N' )
-+ malloc_type = 2;
-+ else
-+ malloc_type = 1;
-+ }
-+
-+#endif
-+
-+Void_t* public_mALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_malloc( bytes );
-+ init_malloc_type();
-+ return public_mALLOc( bytes );
-+#endif
-+}
-+
-+void public_fREe(Void_t* m) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ fREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+#ifndef KDE_MALLOC_FULL
-+ return;
-+ }
-+ if( malloc_type == 2 )
-+ {
-+ libc_free( m );
-+ return;
-+ }
-+ init_malloc_type();
-+ public_fREe( m );
-+#endif
-+}
-+
-+Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = rEALLOc(m, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_realloc( m, bytes );
-+ init_malloc_type();
-+ return public_rEALLOc( m, bytes );
-+#endif
-+}
-+
-+Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = mEMALIGn(alignment, bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_memalign( alignment, bytes );
-+ init_malloc_type();
-+ return public_mEMALIGn( alignment, bytes );
-+#endif
-+}
-+
-+Void_t* public_vALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = vALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_valloc( bytes );
-+ init_malloc_type();
-+ return public_vALLOc( bytes );
-+#endif
-+}
-+
-+Void_t* public_pVALLOc(size_t bytes) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = pVALLOc(bytes);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_pvalloc( bytes );
-+ init_malloc_type();
-+ return public_pVALLOc( bytes );
-+#endif
-+}
-+
-+Void_t* public_cALLOc(size_t n, size_t elem_size) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ Void_t* m;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ m = cALLOc(n, elem_size);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_calloc( n, elem_size );
-+ init_malloc_type();
-+ return public_cALLOc( n, elem_size );
-+#endif
-+}
-+
-+void public_cFREe(Void_t* m) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ if (MALLOC_PREACTION != 0) {
-+ return;
-+ }
-+ cFREe(m);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+#ifndef KDE_MALLOC_FULL
-+ return;
-+ }
-+ if( malloc_type == 2 )
-+ {
-+ libc_cfree( m );
-+ return;
-+ }
-+ init_malloc_type();
-+ public_cFREe( m );
-+#endif
-+}
-+
-+struct mallinfo public_mALLINFo() {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ struct mallinfo m;
-+ if (MALLOC_PREACTION != 0) {
-+ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-+ return nm;
-+ }
-+ m = mALLINFo();
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return m;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_mallinfo();
-+ init_malloc_type();
-+ return public_mALLINFo();
-+#endif
-+}
-+
-+int public_mALLOPt(int p, int v) {
-+#ifndef KDE_MALLOC_FULL
-+ if( malloc_type == 1 )
-+ {
-+#endif
-+ int result;
-+ if (MALLOC_PREACTION != 0) {
-+ return 0;
-+ }
-+ result = mALLOPt(p, v);
-+ if (MALLOC_POSTACTION != 0) {
-+ }
-+ return result;
-+#ifndef KDE_MALLOC_FULL
-+ }
-+ if( malloc_type == 2 )
-+ return libc_mallopt( p, v );
-+ init_malloc_type();
-+ return public_mALLOPt( p, v );
-+#endif
-+}
-+#endif
-+
-+int
-+posix_memalign (void **memptr, size_t alignment, size_t size)
-+{
-+ void *mem;
-+
-+ /* Test whether the SIZE argument is valid. It must be a power of
-+ two multiple of sizeof (void *). */
-+ if (size % sizeof (void *) != 0 || (size & (size - 1)) != 0)
-+ return EINVAL;
-+
-+ mem = memalign (alignment, size);
-+
-+ if (mem != NULL) {
-+ *memptr = mem;
-+ return 0;
-+ }
-+
-+ return ENOMEM;
-+}
-+
-+#else
-+/* Some linkers (Solaris 2.6) don't like empty archives, but for
-+ easier Makefile's we want to link against libklmalloc.la every time,
-+ so simply make it non-empty. */
-+void kde_malloc_dummy_function ()
-+{
-+ return;
-+}
-+#endif
-diff -Nupr a/src/corelib/arch/avr32/qatomic.cpp b/src/corelib/arch/avr32/qatomic.cpp
---- a/src/corelib/arch/avr32/qatomic.cpp 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/avr32/qatomic.cpp 2006-07-26 11:02:43.000000000 +0200
-@@ -0,0 +1,24 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#include "QtCore/qatomic_avr32.h"
-+
-+Q_CORE_EXPORT long q_atomic_lock = 0;
-diff -Nupr a/src/corelib/arch/qatomic_arch.h b/src/corelib/arch/qatomic_arch.h
---- a/src/corelib/arch/qatomic_arch.h 2006-06-30 09:49:44.000000000 +0200
-+++ b/src/corelib/arch/qatomic_arch.h 2006-07-27 12:42:58.000000000 +0200
-@@ -47,6 +47,8 @@ QT_BEGIN_HEADER
- # include "QtCore/qatomic_alpha.h"
- #elif defined(QT_ARCH_ARM)
- # include "QtCore/qatomic_arm.h"
-+#elif defined(QT_ARCH_AVR32)
-+# include "QtCore/qatomic_avr32.h"
- #elif defined(QT_ARCH_BOUNDSCHECKER)
- # include "QtCore/qatomic_boundschecker.h"
- #elif defined(QT_ARCH_GENERIC)
-diff -Nupr a/src/corelib/arch/qatomic_avr32.h b/src/corelib/arch/qatomic_avr32.h
---- a/src/corelib/arch/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/src/corelib/arch/qatomic_avr32.h 2006-07-28 10:30:08.000000000 +0200
-@@ -0,0 +1,132 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the QtCore module of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#ifndef AVR32_QATOMIC_H
-+#define AVR32_QATOMIC_H
-+
-+#include <QtCore/qglobal.h>
-+
-+QT_BEGIN_HEADER
-+
-+extern Q_CORE_EXPORT long q_atomic_lock;
-+
-+inline long q_atomic_swp(volatile long *ptr, long newval)
-+{
-+ register int ret;
-+ asm volatile("xchg %0,%1,%2"
-+ : "=&r"(ret)
-+ : "r"(ptr), "r"(newval)
-+ : "memory", "cc");
-+ return ret;
-+}
-+
-+inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
-+{
-+ int ret = 0;
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0);
-+ if (*ptr == expected) {
-+ *ptr = newval;
-+ ret = 1;
-+ }
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return ret;
-+}
-+
-+inline int q_atomic_test_and_set_acquire_int(volatile int *ptr, int expected, int newval)
-+{
-+ return q_atomic_test_and_set_int(ptr, expected, newval);
-+}
-+
-+inline int q_atomic_test_and_set_release_int(volatile int *ptr, int expected, int newval)
-+{
-+ return q_atomic_test_and_set_int(ptr, expected, newval);
-+}
-+
-+inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
-+{
-+ int ret = 0;
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ if (*reinterpret_cast<void * volatile *>(ptr) == expected) {
-+ *reinterpret_cast<void * volatile *>(ptr) = newval;
-+ ret = 1;
-+ }
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return ret;
-+}
-+
-+inline int q_atomic_increment(volatile int *ptr)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = originalValue + 1;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue != -1;
-+}
-+
-+inline int q_atomic_decrement(volatile int *ptr)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = originalValue - 1;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue != 1;
-+}
-+
-+inline int q_atomic_set_int(volatile int *ptr, int newval)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr = newval;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue;
-+}
-+
-+inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ void *originalValue = *reinterpret_cast<void * volatile *>(ptr);
-+ *reinterpret_cast<void * volatile *>(ptr) = newval;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue;
-+}
-+
-+inline int q_atomic_fetch_and_add_int(volatile int *ptr, int value)
-+{
-+ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
-+ int originalValue = *ptr;
-+ *ptr += value;
-+ q_atomic_swp(&q_atomic_lock, 0);
-+ return originalValue;
-+}
-+
-+inline int q_atomic_fetch_and_add_acquire_int(volatile int *ptr, int value)
-+{
-+ return q_atomic_fetch_and_add_int(ptr, value);
-+}
-+
-+inline int q_atomic_fetch_and_add_release_int(volatile int *ptr, int value)
-+{
-+ return q_atomic_fetch_and_add_int(ptr, value);
-+}
-+
-+QT_END_HEADER
-+
-+#endif // AVR32_QATOMIC_H
-diff -Nupr a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
---- a/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-06-30 09:49:45.000000000 +0200
-+++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-07-27 13:24:27.000000000 +0200
-@@ -87,6 +87,10 @@
- # define __NR_inotify_init 316
- # define __NR_inotify_add_watch 317
- # define __NR_inotify_rm_watch 318
-+#elif defined (__avr32__)
-+# define __NR_inotify_init 240
-+# define __NR_inotify_add_watch 241
-+# define __NR_inotify_rm_watch 242
- #elif defined (__SH4__)
- # define __NR_inotify_init 290
- # define __NR_inotify_add_watch 291
-diff -uprN a/mkspecs/qws/linux-avr32-g++/qmake.conf b/mkspecs/qws/linux-avr32-g++/qmake.conf
---- a/mkspecs/qws/linux-avr32-g++/qmake.conf 1970-01-01 01:00:00.000000000 +0100
-+++ b/mkspecs/qws/linux-avr32-g++/qmake.conf 2006-08-01 08:47:12.000000000 +0200
-@@ -0,0 +1,85 @@
-+#
-+# qmake configuration for linux-g++ using the avr32-linux-g++ crosscompiler
-+#
-+
-+MAKEFILE_GENERATOR = UNIX
-+TEMPLATE = app
-+CONFIG += qt warn_on release link_prl
-+QT += core gui network
-+QMAKE_INCREMENTAL_STYLE = sublib
-+
-+QMAKE_CC = avr32-linux-gcc
-+QMAKE_LEX = flex
-+QMAKE_LEXFLAGS =
-+QMAKE_YACC = yacc
-+QMAKE_YACCFLAGS = -d
-+QMAKE_CFLAGS = -pipe
-+QMAKE_CFLAGS_WARN_ON = -Wall -W
-+QMAKE_CFLAGS_WARN_OFF =
-+QMAKE_CFLAGS_RELEASE = -O2
-+QMAKE_CFLAGS_DEBUG = -g -O2
-+QMAKE_CFLAGS_SHLIB = -fPIC
-+QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
-+QMAKE_CFLAGS_THREAD = -D_REENTRANT
-+QMAKE_CFLAGS_HIDESYMS = -fvisibility=hidden
-+
-+QMAKE_CXX = avr32-linux-g++
-+QMAKE_CXXFLAGS = $$QMAKE_CFLAGS -fno-exceptions
-+QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
-+QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
-+QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
-+QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
-+QMAKE_CXXFLAGS_SHLIB = $$QMAKE_CFLAGS_SHLIB
-+QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
-+QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD
-+QMAKE_CXXFLAGS_HIDESYMS = $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden
-+
-+QMAKE_INCDIR =
-+QMAKE_LIBDIR =
-+QMAKE_INCDIR_X11 =
-+QMAKE_LIBDIR_X11 =
-+QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
-+QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
-+QMAKE_INCDIR_OPENGL =
-+QMAKE_LIBDIR_OPENGL =
-+QMAKE_INCDIR_QTOPIA = $(QPEDIR)/include
-+QMAKE_LIBDIR_QTOPIA = $(QPEDIR)/lib
-+
-+QMAKE_LINK = avr32-linux-g++
-+QMAKE_LINK_SHLIB = avr32-linux-g++
-+QMAKE_LFLAGS =
-+QMAKE_LFLAGS_RELEASE =
-+QMAKE_LFLAGS_DEBUG =
-+QMAKE_LFLAGS_SHLIB = -shared
-+QMAKE_LFLAGS_PLUGIN = $$QMAKE_LFLAGS_SHLIB
-+QMAKE_LFLAGS_SONAME = -Wl,-soname,
-+QMAKE_LFLAGS_THREAD =
-+QMAKE_RPATH = -Wl,-rpath,
-+
-+QMAKE_LIBS =
-+QMAKE_LIBS_DYNLOAD = -ldl
-+QMAKE_LIBS_X11 =
-+QMAKE_LIBS_X11SM =
-+QMAKE_LIBS_QT = -lqte
-+QMAKE_LIBS_QT_THREAD = -lqte-mt
-+QMAKE_LIBS_QT_OPENGL = -lqgl
-+QMAKE_LIBS_QTOPIA = -lqpe -lqtopia
-+QMAKE_LIBS_THREAD = -lpthread
-+
-+QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
-+QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
-+
-+QMAKE_AR = avr32-linux-ar cqs
-+QMAKE_RANLIB = avr32-linux-ranlib
-+
-+QMAKE_TAR = tar -cf
-+QMAKE_GZIP = gzip -9f
-+
-+QMAKE_COPY = cp -f
-+QMAKE_MOVE = mv -f
-+QMAKE_DEL_FILE = rm -f
-+QMAKE_DEL_DIR = rmdir
-+QMAKE_STRIP = avr32-linux-strip
-+QMAKE_CHK_DIR_EXISTS = test -d
-+QMAKE_MKDIR = mkdir -p
-+load(qt_config)
-diff -uprN a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h
---- a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 1970-01-01 01:00:00.000000000 +0100
-+++ b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 2006-07-26 09:16:52.000000000 +0200
-@@ -0,0 +1,22 @@
-+/****************************************************************************
-+**
-+** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
-+**
-+** This file is part of the qmake spec of the Qt Toolkit.
-+**
-+** Licensees holding valid Qt Preview licenses may use this file in
-+** accordance with the Qt Preview License Agreement provided with the
-+** Software.
-+**
-+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
-+** information about Qt Commercial License Agreements.
-+**
-+** Contact info@trolltech.com if any conditions of this licensing are
-+** not clear to you.
-+**
-+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-+**
-+****************************************************************************/
-+
-+#include "../../linux-g++/qplatformdefs.h"
---- a/include/QtCore/headers.pri 2007-08-02 15:03:31.000000000 +0200
-+++ b/include/QtCore/headers.pri 2007-08-02 15:03:44.000000000 +0200
-@@ -1,2 +1,2 @@
--SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
-+SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_avr32.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
- SYNCQT.HEADER_CLASSES = ../../include/QtCore/QDataStream ../../include/QtCore/QtDebug ../../include/QtCore/QDebug ../../include/QtCore/QNoDebug ../../include/QtCore/QTextStream ../../include/QtCore/QTextStreamFunction ../../include/QtCore/QTextStreamManipulator ../../include/QtCore/QTS ../../include/QtCore/QTextIStream ../../include/QtCore/QTextOStream ../../include/QtCore/QTemporaryFile ../../include/QtCore/QFSFileEngine ../../include/QtCore/QIODevice ../../include/QtCore/Q_PID ../../include/QtCore/QProcess ../../include/QtCore/QResource ../../include/QtCore/QDirIterator ../../include/QtCore/QBuffer ../../include/QtCore/QFileSystemWatcher ../../include/QtCore/QDir ../../include/QtCore/QUrl ../../include/QtCore/QAbstractFileEngine ../../include/QtCore/QAbstractFileEngineHandler ../../include/QtCore/QAbstractFileEngineIterator ../../include/QtCore/QFileInfo ../../include/QtCore/QFileInfoList ../../include/QtCore/QFileInfoListIterator ../../include/QtCore/QSettings ../../include/QtCore/QFile ../../include/QtCore/QBasicAtomic ../../include/QtCore/QBasicAtomicPointer ../../include/QtCore/QCache ../../include/QtCore/QLine ../../include/QtCore/QLineF ../../include/QtCore/QListData ../../include/QtCore/QList ../../include/QtCore/QListIterator ../../include/QtCore/QMutableListIterator ../../include/QtCore/QPair ../../include/QtCore/QPoint ../../include/QtCore/QPointF ../../include/QtCore/QRect ../../include/QtCore/QRectF ../../include/QtCore/QSize ../../include/QtCore/QSizeF ../../include/QtCore/QStringListIterator ../../include/QtCore/QMutableStringListIterator ../../include/QtCore/QStringList ../../include/QtCore/QStringMatcher ../../include/QtCore/QLinkedListData ../../include/QtCore/QLinkedListNode ../../include/QtCore/QLinkedList ../../include/QtCore/QLinkedListIterator ../../include/QtCore/QMutableLinkedListIterator ../../include/QtCore/QBitArray ../../include/QtCore/QBitRef ../../include/QtCore/QVectorData ../../include/QtCore/QVectorTypedData ../../include/QtCore/QVector ../../include/QtCore/QVectorIterator ../../include/QtCore/QMutableVectorIterator ../../include/QtCore/QByteArrayMatcher ../../include/QtCore/QQueue ../../include/QtCore/QByteArray ../../include/QtCore/QByteRef ../../include/QtCore/QtAlgorithms ../../include/QtCore/QVarLengthArray ../../include/QtCore/QSharedData ../../include/QtCore/QSharedDataPointer ../../include/QtCore/QExplicitlySharedDataPointer ../../include/QtCore/QCryptographicHash ../../include/QtCore/QLocale ../../include/QtCore/QSystemLocale ../../include/QtCore/QStack ../../include/QtCore/QMapData ../../include/QtCore/QMap ../../include/QtCore/QMultiMap ../../include/QtCore/QMapIterator ../../include/QtCore/QMutableMapIterator ../../include/QtCore/QSet ../../include/QtCore/QSetIterator ../../include/QtCore/QMutableSetIterator ../../include/QtCore/QDate ../../include/QtCore/QTime ../../include/QtCore/QDateTime ../../include/QtCore/QStdWString ../../include/QtCore/QString ../../include/QtCore/QLatin1String ../../include/QtCore/QCharRef ../../include/QtCore/QConstString ../../include/QtCore/QStringRef ../../include/QtCore/QtContainerFwd ../../include/QtCore/QRegExp ../../include/QtCore/QLatin1Char ../../include/QtCore/QChar ../../include/QtCore/QHashData ../../include/QtCore/QHashDummyValue ../../include/QtCore/QHashDummyNode ../../include/QtCore/QHashNode ../../include/QtCore/QHash ../../include/QtCore/QMultiHash ../../include/QtCore/QHashIterator ../../include/QtCore/QMutableHashIterator ../../include/QtCore/QTimeLine ../../include/QtCore/QTextCodecFactoryInterface ../../include/QtCore/QTextCodecPlugin ../../include/QtCore/QTextCodec ../../include/QtCore/QTextEncoder ../../include/QtCore/QTextDecoder ../../include/QtCore/QLibraryInfo ../../include/QtCore/QtEndian ../../include/QtCore/QtGlobal ../../include/QtCore/QUintForSize ../../include/QtCore/QUintForType ../../include/QtCore/QIntForSize ../../include/QtCore/QIntForType ../../include/QtCore/QNoImplicitBoolCast ../../include/QtCore/Q_INT8 ../../include/QtCore/Q_UINT8 ../../include/QtCore/Q_INT16 ../../include/QtCore/Q_UINT16 ../../include/QtCore/Q_INT32 ../../include/QtCore/Q_UINT32 ../../include/QtCore/Q_INT64 ../../include/QtCore/Q_UINT64 ../../include/QtCore/Q_LLONG ../../include/QtCore/Q_ULLONG ../../include/QtCore/Q_LONG ../../include/QtCore/Q_ULONG ../../include/QtCore/QSysInfo ../../include/QtCore/QtMsgHandler ../../include/QtCore/QGlobalStatic ../../include/QtCore/QGlobalStaticDeleter ../../include/QtCore/QBool ../../include/QtCore/QTypeInfo ../../include/QtCore/QFlag ../../include/QtCore/QFlags ../../include/QtCore/QForeachContainer ../../include/QtCore/QForeachContainerBase ../../include/QtCore/Qt ../../include/QtCore/QInternal ../../include/QtCore/QCOORD ../../include/QtCore/QTranslator ../../include/QtCore/QVariant ../../include/QtCore/QVariantList ../../include/QtCore/QVariantMap ../../include/QtCore/QVariantComparisonHelper ../../include/QtCore/QMimeData ../../include/QtCore/QEventLoop ../../include/QtCore/QCoreApplication ../../include/QtCore/QtCleanUpFunction ../../include/QtCore/QModelIndex ../../include/QtCore/QPersistentModelIndex ../../include/QtCore/QModelIndexList ../../include/QtCore/QAbstractItemModel ../../include/QtCore/QAbstractTableModel ../../include/QtCore/QAbstractListModel ../../include/QtCore/QSignalMapper ../../include/QtCore/QObjectCleanupHandler ../../include/QtCore/QBasicTimer ../../include/QtCore/QSocketNotifier ../../include/QtCore/QObjectList ../../include/QtCore/QObjectData ../../include/QtCore/QObject ../../include/QtCore/QObjectUserData ../../include/QtCore/QTimer ../../include/QtCore/QMetaType ../../include/QtCore/QMetaTypeId ../../include/QtCore/QMetaTypeId2 ../../include/QtCore/QAbstractEventDispatcher ../../include/QtCore/QPointer ../../include/QtCore/QMetaMethod ../../include/QtCore/QMetaEnum ../../include/QtCore/QMetaProperty ../../include/QtCore/QMetaClassInfo ../../include/QtCore/QEvent ../../include/QtCore/QTimerEvent ../../include/QtCore/QChildEvent ../../include/QtCore/QCustomEvent ../../include/QtCore/QDynamicPropertyChangeEvent ../../include/QtCore/QGenericArgument ../../include/QtCore/QGenericReturnArgument ../../include/QtCore/QArgument ../../include/QtCore/QReturnArgument ../../include/QtCore/QMetaObject ../../include/QtCore/QPluginLoader ../../include/QtCore/QUuid ../../include/QtCore/QLibrary ../../include/QtCore/QtPlugin ../../include/QtCore/QtPluginInstanceFunction ../../include/QtCore/QFactoryInterface ../../include/QtCore/QSemaphore ../../include/QtCore/QThreadStorageData ../../include/QtCore/QThreadStorage ../../include/QtCore/QWaitCondition ../../include/QtCore/QThread ../../include/QtCore/QMutex ../../include/QtCore/QMutexLocker ../../include/QtCore/QReadWriteLock ../../include/QtCore/QReadLocker ../../include/QtCore/QWriteLocker ../../include/QtCore/QAtomic ../../include/QtCore/QAtomicPointer
--- /dev/null
+diff -Nupr a/include/Qt/qatomic_avr32.h b/include/Qt/qatomic_avr32.h
+--- a/include/Qt/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/include/Qt/qatomic_avr32.h 2006-07-27 07:55:09.000000000 +0200
+@@ -0,0 +1 @@
++#include "../../src/corelib/arch/qatomic_avr32.h"
+diff -Nupr a/include/QtCore/qatomic_avr32.h b/include/QtCore/qatomic_avr32.h
+--- a/include/QtCore/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/include/QtCore/qatomic_avr32.h 2006-07-27 07:55:28.000000000 +0200
+@@ -0,0 +1 @@
++#include "../../src/corelib/arch/qatomic_avr32.h"
+diff -Nupr a/src/corelib/arch/arch.pri b/src/corelib/arch/arch.pri
+--- a/src/corelib/arch/arch.pri 2006-06-30 09:49:44.000000000 +0200
++++ b/src/corelib/arch/arch.pri 2006-07-26 11:03:43.000000000 +0200
+@@ -13,6 +13,7 @@ mac:HEADERS += arch/qatomic_macosx.h \
+ arch/qatomic_generic.h \
+ arch/qatomic_powerpc.h \
+ arch/qatomic_arm.h \
++ arch/qatomic_avr32.h \
+ arch/qatomic_i386.h \
+ arch/qatomic_mips.h \
+ arch/qatomic_s390.h \
+diff -Nupr a/src/corelib/arch/avr32/arch.pri b/src/corelib/arch/avr32/arch.pri
+--- a/src/corelib/arch/avr32/arch.pri 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/arch.pri 2006-07-26 11:02:16.000000000 +0200
+@@ -0,0 +1,5 @@
++#
++# AVR32 architecture
++#
++SOURCES += $$QT_ARCH_CPP/qatomic.cpp \
++ $$QT_ARCH_CPP/malloc.c
+diff -Nupr a/src/corelib/arch/avr32/malloc.c b/src/corelib/arch/avr32/malloc.c
+--- a/src/corelib/arch/avr32/malloc.c 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/malloc.c 2006-07-28 10:29:44.000000000 +0200
+@@ -0,0 +1,5819 @@
++/****************************************************************************
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** This file contains third party code which is not governed by the Qt
++** Commercial License Agreement. Please read the license headers below
++** for more information.
++**
++** Further information about Qt licensing is available at:
++** http://www.trolltech.com/products/qt/licensing.html or by
++** contacting info@trolltech.com.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++/* ---- config.h */
++#define KDE_MALLOC
++#define KDE_MALLOC_FULL
++#define KDE_MALLOC_AVR32
++/* ---- */
++
++#ifdef KDE_MALLOC
++
++#ifdef KDE_MALLOC_DEBUG
++#define DEBUG
++#endif
++
++#define USE_MALLOC_LOCK
++#define INLINE __inline__
++/*#define INLINE*/
++#define USE_MEMCPY 0
++#define MMAP_CLEARS 1
++
++/*
++ This is a version (aka dlmalloc) of malloc/free/realloc written by
++ Doug Lea and released to the public domain. Use, modify, and
++ redistribute this code without permission or acknowledgment in any
++ way you wish. Send questions, comments, complaints, performance
++ data, etc to dl@cs.oswego.edu
++
++* VERSION 2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
++
++ Note: There may be an updated version of this malloc obtainable at
++ ftp://gee.cs.oswego.edu/pub/misc/malloc.c
++ Check before installing!
++
++* Quickstart
++
++ This library is all in one file to simplify the most common usage:
++ ftp it, compile it (-O), and link it into another program. All
++ of the compile-time options default to reasonable values for use on
++ most unix platforms. Compile -DWIN32 for reasonable defaults on windows.
++ You might later want to step through various compile-time and dynamic
++ tuning options.
++
++ For convenience, an include file for code using this malloc is at:
++ ftp://gee.cs.oswego.edu/pub/misc/malloc-2.7.0.h
++ You don't really need this .h file unless you call functions not
++ defined in your system include files. The .h file contains only the
++ excerpts from this file needed for using this malloc on ANSI C/C++
++ systems, so long as you haven't changed compile-time options about
++ naming and tuning parameters. If you do, then you can create your
++ own malloc.h that does include all settings by cutting at the point
++ indicated below.
++
++* Why use this malloc?
++
++ This is not the fastest, most space-conserving, most portable, or
++ most tunable malloc ever written. However it is among the fastest
++ while also being among the most space-conserving, portable and tunable.
++ Consistent balance across these factors results in a good general-purpose
++ allocator for malloc-intensive programs.
++
++ The main properties of the algorithms are:
++ * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
++ with ties normally decided via FIFO (i.e. least recently used).
++ * For small (<= 64 bytes by default) requests, it is a caching
++ allocator, that maintains pools of quickly recycled chunks.
++ * In between, and for combinations of large and small requests, it does
++ the best it can trying to meet both goals at once.
++ * For very large requests (>= 128KB by default), it relies on system
++ memory mapping facilities, if supported.
++
++ For a longer but slightly out of date high-level description, see
++ http://gee.cs.oswego.edu/dl/html/malloc.html
++
++ You may already by default be using a C library containing a malloc
++ that is based on some version of this malloc (for example in
++ linux). You might still want to use the one in this file in order to
++ customize settings or to avoid overheads associated with library
++ versions.
++
++* Contents, described in more detail in "description of public routines" below.
++
++ Standard (ANSI/SVID/...) functions:
++ malloc(size_t n);
++ calloc(size_t n_elements, size_t element_size);
++ free(Void_t* p);
++ realloc(Void_t* p, size_t n);
++ memalign(size_t alignment, size_t n);
++ valloc(size_t n);
++ mallinfo()
++ mallopt(int parameter_number, int parameter_value)
++
++ Additional functions:
++ independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);
++ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
++ pvalloc(size_t n);
++ cfree(Void_t* p);
++ malloc_trim(size_t pad);
++ malloc_usable_size(Void_t* p);
++ malloc_stats();
++
++* Vital statistics:
++
++ Supported pointer representation: 4 or 8 bytes
++ Supported size_t representation: 4 or 8 bytes
++ Note that size_t is allowed to be 4 bytes even if pointers are 8.
++ You can adjust this by defining INTERNAL_SIZE_T
++
++ Alignment: 2 * sizeof(size_t) (default)
++ (i.e., 8 byte alignment with 4byte size_t). This suffices for
++ nearly all current machines and C compilers. However, you can
++ define MALLOC_ALIGNMENT to be wider than this if necessary.
++
++ Minimum overhead per allocated chunk: 4 or 8 bytes
++ Each malloced chunk has a hidden word of overhead holding size
++ and status information.
++
++ Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead)
++ 8-byte ptrs: 24/32 bytes (including, 4/8 overhead)
++
++ When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
++ ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
++ needed; 4 (8) for a trailing size field and 8 (16) bytes for
++ free list pointers. Thus, the minimum allocatable size is
++ 16/24/32 bytes.
++
++ Even a request for zero bytes (i.e., malloc(0)) returns a
++ pointer to something of the minimum allocatable size.
++
++ The maximum overhead wastage (i.e., number of extra bytes
++ allocated than were requested in malloc) is less than or equal
++ to the minimum size, except for requests >= mmap_threshold that
++ are serviced via mmap(), where the worst case wastage is 2 *
++ sizeof(size_t) bytes plus the remainder from a system page (the
++ minimal mmap unit); typically 4096 or 8192 bytes.
++
++ Maximum allocated size: 4-byte size_t: 2^32 minus about two pages
++ 8-byte size_t: 2^64 minus about two pages
++
++ It is assumed that (possibly signed) size_t values suffice to
++ represent chunk sizes. `Possibly signed' is due to the fact
++ that `size_t' may be defined on a system as either a signed or
++ an unsigned type. The ISO C standard says that it must be
++ unsigned, but a few systems are known not to adhere to this.
++ Additionally, even when size_t is unsigned, sbrk (which is by
++ default used to obtain memory from system) accepts signed
++ arguments, and may not be able to handle size_t-wide arguments
++ with negative sign bit. Generally, values that would
++ appear as negative after accounting for overhead and alignment
++ are supported only via mmap(), which does not have this
++ limitation.
++
++ Requests for sizes outside the allowed range will perform an optional
++ failure action and then return null. (Requests may also
++ also fail because a system is out of memory.)
++
++ Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined
++
++ When USE_MALLOC_LOCK is defined, wrappers are created to
++ surround every public call with either a pthread mutex or
++ a win32 spinlock (depending on WIN32). This is not
++ especially fast, and can be a major bottleneck.
++ It is designed only to provide minimal protection
++ in concurrent environments, and to provide a basis for
++ extensions. If you are using malloc in a concurrent program,
++ you would be far better off obtaining ptmalloc, which is
++ derived from a version of this malloc, and is well-tuned for
++ concurrent programs. (See http://www.malloc.de)
++
++ Compliance: I believe it is compliant with the 1997 Single Unix Specification
++ (See http://www.opennc.org). Also SVID/XPG, ANSI C, and probably
++ others as well.
++
++* Synopsis of compile-time options:
++
++ People have reported using previous versions of this malloc on all
++ versions of Unix, sometimes by tweaking some of the defines
++ below. It has been tested most extensively on Solaris and
++ Linux. It is also reported to work on WIN32 platforms.
++ People also report using it in stand-alone embedded systems.
++
++ The implementation is in straight, hand-tuned ANSI C. It is not
++ at all modular. (Sorry!) It uses a lot of macros. To be at all
++ usable, this code should be compiled using an optimizing compiler
++ (for example gcc -O3) that can simplify expressions and control
++ paths. (FAQ: some macros import variables as arguments rather than
++ declare locals because people reported that some debuggers
++ otherwise get confused.)
++
++ OPTION DEFAULT VALUE
++
++ Compilation Environment options:
++
++ __STD_C derived from C compiler defines
++ WIN32 NOT defined
++ HAVE_MEMCPY defined
++ USE_MEMCPY 1 if HAVE_MEMCPY is defined
++ HAVE_MMAP defined as 1
++ MMAP_CLEARS 1
++ HAVE_MREMAP 0 unless linux defined
++ malloc_getpagesize derived from system #includes, or 4096 if not
++ HAVE_USR_INCLUDE_MALLOC_H NOT defined
++ LACKS_UNISTD_H NOT defined unless WIN32
++ LACKS_SYS_PARAM_H NOT defined unless WIN32
++ LACKS_SYS_MMAN_H NOT defined unless WIN32
++
++ Changing default word sizes:
++
++ INTERNAL_SIZE_T size_t
++ MALLOC_ALIGNMENT 2 * sizeof(INTERNAL_SIZE_T)
++
++ Configuration and functionality options:
++
++ USE_DL_PREFIX NOT defined
++ USE_PUBLIC_MALLOC_WRAPPERS NOT defined
++ USE_MALLOC_LOCK NOT defined
++ DEBUG NOT defined
++ REALLOC_ZERO_BYTES_FREES NOT defined
++ MALLOC_FAILURE_ACTION errno = ENOMEM, if __STD_C defined, else no-op
++ TRIM_FASTBINS 0
++
++ Options for customizing MORECORE:
++
++ MORECORE sbrk
++ MORECORE_CONTIGUOUS 1
++ MORECORE_CANNOT_TRIM NOT defined
++ MMAP_AS_MORECORE_SIZE (1024 * 1024)
++
++ Tuning options that are also dynamically changeable via mallopt:
++
++ DEFAULT_MXFAST 64
++ DEFAULT_TRIM_THRESHOLD 128 * 1024
++ DEFAULT_TOP_PAD 0
++ DEFAULT_MMAP_THRESHOLD 128 * 1024
++ DEFAULT_MMAP_MAX 65536
++
++ There are several other #defined constants and macros that you
++ probably don't want to touch unless you are extending or adapting malloc.
++*/
++
++/*
++ WIN32 sets up defaults for MS environment and compilers.
++ Otherwise defaults are for unix.
++*/
++
++/* #define WIN32 */
++
++#ifdef WIN32
++
++#define WIN32_LEAN_AND_MEAN
++#include <windows.h>
++
++/* Win32 doesn't supply or need the following headers */
++#define LACKS_UNISTD_H
++#define LACKS_SYS_PARAM_H
++#define LACKS_SYS_MMAN_H
++
++/* Use the supplied emulation of sbrk */
++#define MORECORE sbrk
++#define MORECORE_CONTIGUOUS 1
++#define MORECORE_FAILURE ((void*)(-1))
++
++/* Use the supplied emulation of mmap and munmap */
++#define HAVE_MMAP 1
++#define MUNMAP_FAILURE (-1)
++#define MMAP_CLEARS 1
++
++/* These values don't really matter in windows mmap emulation */
++#define MAP_PRIVATE 1
++#define MAP_ANONYMOUS 2
++#define PROT_READ 1
++#define PROT_WRITE 2
++
++/* Emulation functions defined at the end of this file */
++
++/* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */
++#ifdef USE_MALLOC_LOCK
++static int slwait(int *sl);
++static int slrelease(int *sl);
++#endif
++
++static long getpagesize(void);
++static long getregionsize(void);
++static void *sbrk(long size);
++static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg);
++static long munmap(void *ptr, long size);
++
++static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed);
++static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user);
++
++#endif
++
++/*
++ __STD_C should be nonzero if using ANSI-standard C compiler, a C++
++ compiler, or a C compiler sufficiently close to ANSI to get away
++ with it.
++*/
++
++#ifndef __STD_C
++#if defined(__STDC__) || defined(_cplusplus)
++#define __STD_C 1
++#else
++#define __STD_C 0
++#endif
++#endif /*__STD_C*/
++
++
++/*
++ Void_t* is the pointer type that malloc should say it returns
++*/
++
++#ifndef Void_t
++#if (__STD_C || defined(WIN32))
++#define Void_t void
++#else
++#define Void_t char
++#endif
++#endif /*Void_t*/
++
++#if __STD_C
++#include <stddef.h> /* for size_t */
++#else
++#include <sys/types.h>
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */
++
++/* #define LACKS_UNISTD_H */
++
++#ifndef LACKS_UNISTD_H
++#include <unistd.h>
++#endif
++
++/* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */
++
++/* #define LACKS_SYS_PARAM_H */
++
++
++#include <stdio.h> /* needed for malloc_stats */
++#include <errno.h> /* needed for optional MALLOC_FAILURE_ACTION */
++
++
++/*
++ Debugging:
++
++ Because freed chunks may be overwritten with bookkeeping fields, this
++ malloc will often die when freed memory is overwritten by user
++ programs. This can be very effective (albeit in an annoying way)
++ in helping track down dangling pointers.
++
++ If you compile with -DDEBUG, a number of assertion checks are
++ enabled that will catch more memory errors. You probably won't be
++ able to make much sense of the actual assertion errors, but they
++ should help you locate incorrectly overwritten memory. The
++ checking is fairly extensive, and will slow down execution
++ noticeably. Calling malloc_stats or mallinfo with DEBUG set will
++ attempt to check every non-mmapped allocated and free chunk in the
++ course of computing the summmaries. (By nature, mmapped regions
++ cannot be checked very much automatically.)
++
++ Setting DEBUG may also be helpful if you are trying to modify
++ this code. The assertions in the check routines spell out in more
++ detail the assumptions and invariants underlying the algorithms.
++
++ Setting DEBUG does NOT provide an automated mechanism for checking
++ that all accesses to malloced memory stay within their
++ bounds. However, there are several add-ons and adaptations of this
++ or other mallocs available that do this.
++*/
++
++#ifdef DEBUG
++#include <assert.h>
++#else
++#define assert(x) ((void)0)
++#endif
++
++
++/*
++ INTERNAL_SIZE_T is the word-size used for internal bookkeeping
++ of chunk sizes.
++
++ The default version is the same as size_t.
++
++ While not strictly necessary, it is best to define this as an
++ unsigned type, even if size_t is a signed type. This may avoid some
++ artificial size limitations on some systems.
++
++ On a 64-bit machine, you may be able to reduce malloc overhead by
++ defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the
++ expense of not being able to handle more than 2^32 of malloced
++ space. If this limitation is acceptable, you are encouraged to set
++ this unless you are on a platform requiring 16byte alignments. In
++ this case the alignment requirements turn out to negate any
++ potential advantages of decreasing size_t word size.
++
++ Implementors: Beware of the possible combinations of:
++ - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,
++ and might be the same width as int or as long
++ - size_t might have different width and signedness as INTERNAL_SIZE_T
++ - int and long might be 32 or 64 bits, and might be the same width
++ To deal with this, most comparisons and difference computations
++ among INTERNAL_SIZE_Ts should cast them to unsigned long, being
++ aware of the fact that casting an unsigned int to a wider long does
++ not sign-extend. (This also makes checking for negative numbers
++ awkward.) Some of these casts result in harmless compiler warnings
++ on some systems.
++*/
++
++#ifndef INTERNAL_SIZE_T
++#define INTERNAL_SIZE_T size_t
++#endif
++
++/* The corresponding word size */
++#define SIZE_SZ (sizeof(INTERNAL_SIZE_T))
++
++
++/*
++ MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
++ It must be a power of two at least 2 * SIZE_SZ, even on machines
++ for which smaller alignments would suffice. It may be defined as
++ larger than this though. Note however that code and data structures
++ are optimized for the case of 8-byte alignment.
++*/
++
++
++#ifndef MALLOC_ALIGNMENT
++#define MALLOC_ALIGNMENT (2 * SIZE_SZ)
++#endif
++
++/* The corresponding bit mask value */
++#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)
++
++
++
++/*
++ REALLOC_ZERO_BYTES_FREES should be set if a call to
++ realloc with zero bytes should be the same as a call to free.
++ Some people think it should. Otherwise, since this malloc
++ returns a unique pointer for malloc(0), so does realloc(p, 0).
++*/
++
++/* #define REALLOC_ZERO_BYTES_FREES */
++
++/*
++ TRIM_FASTBINS controls whether free() of a very small chunk can
++ immediately lead to trimming. Setting to true (1) can reduce memory
++ footprint, but will almost always slow down programs that use a lot
++ of small chunks.
++
++ Define this only if you are willing to give up some speed to more
++ aggressively reduce system-level memory footprint when releasing
++ memory in programs that use many small chunks. You can get
++ essentially the same effect by setting MXFAST to 0, but this can
++ lead to even greater slowdowns in programs using many small chunks.
++ TRIM_FASTBINS is an in-between compile-time option, that disables
++ only those chunks bordering topmost memory from being placed in
++ fastbins.
++*/
++
++#ifndef TRIM_FASTBINS
++#define TRIM_FASTBINS 0
++#endif
++
++
++/*
++ USE_DL_PREFIX will prefix all public routines with the string 'dl'.
++ This is necessary when you only want to use this malloc in one part
++ of a program, using your regular system malloc elsewhere.
++*/
++
++/* #define USE_DL_PREFIX */
++
++
++/*
++ USE_MALLOC_LOCK causes wrapper functions to surround each
++ callable routine with pthread mutex lock/unlock.
++
++ USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined
++*/
++
++
++/* #define USE_MALLOC_LOCK */
++
++
++/*
++ If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is
++ actually a wrapper function that first calls MALLOC_PREACTION, then
++ calls the internal routine, and follows it with
++ MALLOC_POSTACTION. This is needed for locking, but you can also use
++ this, without USE_MALLOC_LOCK, for purposes of interception,
++ instrumentation, etc. It is a sad fact that using wrappers often
++ noticeably degrades performance of malloc-intensive programs.
++*/
++
++#ifdef USE_MALLOC_LOCK
++#define USE_PUBLIC_MALLOC_WRAPPERS
++#else
++/* #define USE_PUBLIC_MALLOC_WRAPPERS */
++#endif
++
++
++/*
++ Two-phase name translation.
++ All of the actual routines are given mangled names.
++ When wrappers are used, they become the public callable versions.
++ When DL_PREFIX is used, the callable names are prefixed.
++*/
++
++#ifndef USE_PUBLIC_MALLOC_WRAPPERS
++#define cALLOc public_cALLOc
++#define fREe public_fREe
++#define cFREe public_cFREe
++#define mALLOc public_mALLOc
++#define mEMALIGn public_mEMALIGn
++#define rEALLOc public_rEALLOc
++#define vALLOc public_vALLOc
++#define pVALLOc public_pVALLOc
++#define mALLINFo public_mALLINFo
++#define mALLOPt public_mALLOPt
++#define mTRIm public_mTRIm
++#define mSTATs public_mSTATs
++#define mUSABLe public_mUSABLe
++#define iCALLOc public_iCALLOc
++#define iCOMALLOc public_iCOMALLOc
++#endif
++
++#ifdef USE_DL_PREFIX
++#define public_cALLOc dlcalloc
++#define public_fREe dlfree
++#define public_cFREe dlcfree
++#define public_mALLOc dlmalloc
++#define public_mEMALIGn dlmemalign
++#define public_rEALLOc dlrealloc
++#define public_vALLOc dlvalloc
++#define public_pVALLOc dlpvalloc
++#define public_mALLINFo dlmallinfo
++#define public_mALLOPt dlmallopt
++#define public_mTRIm dlmalloc_trim
++#define public_mSTATs dlmalloc_stats
++#define public_mUSABLe dlmalloc_usable_size
++#define public_iCALLOc dlindependent_calloc
++#define public_iCOMALLOc dlindependent_comalloc
++#else /* USE_DL_PREFIX */
++#define public_cALLOc calloc
++#define public_fREe free
++#define public_cFREe cfree
++#define public_mALLOc malloc
++#define public_mEMALIGn memalign
++#define public_rEALLOc realloc
++#define public_vALLOc valloc
++#define public_pVALLOc pvalloc
++#define public_mALLINFo mallinfo
++#define public_mALLOPt mallopt
++#define public_mTRIm malloc_trim
++#define public_mSTATs malloc_stats
++#define public_mUSABLe malloc_usable_size
++#define public_iCALLOc independent_calloc
++#define public_iCOMALLOc independent_comalloc
++#endif /* USE_DL_PREFIX */
++
++
++/*
++ HAVE_MEMCPY should be defined if you are not otherwise using
++ ANSI STD C, but still have memcpy and memset in your C library
++ and want to use them in calloc and realloc. Otherwise simple
++ macro versions are defined below.
++
++ USE_MEMCPY should be defined as 1 if you actually want to
++ have memset and memcpy called. People report that the macro
++ versions are faster than libc versions on some systems.
++
++ Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks
++ (of <= 36 bytes) are manually unrolled in realloc and calloc.
++*/
++
++/* If it's available it's defined in config.h. */
++/* #define HAVE_MEMCPY */
++
++#ifndef USE_MEMCPY
++#ifdef HAVE_MEMCPY
++#define USE_MEMCPY 1
++#else
++#define USE_MEMCPY 0
++#endif
++#endif
++
++
++#if (__STD_C || defined(HAVE_MEMCPY))
++
++#ifdef WIN32
++/* On Win32 memset and memcpy are already declared in windows.h */
++#else
++#if __STD_C
++void* memset(void*, int, size_t);
++void* memcpy(void*, const void*, size_t);
++#else
++Void_t* memset();
++Void_t* memcpy();
++#endif
++#endif
++#endif
++
++/*
++ MALLOC_FAILURE_ACTION is the action to take before "return 0" when
++ malloc fails to be able to return memory, either because memory is
++ exhausted or because of illegal arguments.
++
++ By default, sets errno if running on STD_C platform, else does nothing.
++*/
++
++#ifndef MALLOC_FAILURE_ACTION
++#if __STD_C
++#define MALLOC_FAILURE_ACTION \
++ errno = ENOMEM;
++
++#else
++#define MALLOC_FAILURE_ACTION
++#endif
++#endif
++
++/*
++ MORECORE-related declarations. By default, rely on sbrk
++*/
++
++
++#ifdef LACKS_UNISTD_H
++#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
++#if __STD_C
++extern Void_t* sbrk(ptrdiff_t);
++#else
++extern Void_t* sbrk();
++#endif
++#endif
++#endif
++
++/*
++ MORECORE is the name of the routine to call to obtain more memory
++ from the system. See below for general guidance on writing
++ alternative MORECORE functions, as well as a version for WIN32 and a
++ sample version for pre-OSX macos.
++*/
++
++#ifndef MORECORE
++#define MORECORE sbrk
++#endif
++
++/*
++ MORECORE_FAILURE is the value returned upon failure of MORECORE
++ as well as mmap. Since it cannot be an otherwise valid memory address,
++ and must reflect values of standard sys calls, you probably ought not
++ try to redefine it.
++*/
++
++#ifndef MORECORE_FAILURE
++#define MORECORE_FAILURE (-1)
++#endif
++
++/*
++ If MORECORE_CONTIGUOUS is true, take advantage of fact that
++ consecutive calls to MORECORE with positive arguments always return
++ contiguous increasing addresses. This is true of unix sbrk. Even
++ if not defined, when regions happen to be contiguous, malloc will
++ permit allocations spanning regions obtained from different
++ calls. But defining this when applicable enables some stronger
++ consistency checks and space efficiencies.
++*/
++
++#ifndef MORECORE_CONTIGUOUS
++#define MORECORE_CONTIGUOUS 1
++#endif
++
++/*
++ Define MORECORE_CANNOT_TRIM if your version of MORECORE
++ cannot release space back to the system when given negative
++ arguments. This is generally necessary only if you are using
++ a hand-crafted MORECORE function that cannot handle negative arguments.
++*/
++
++/* #define MORECORE_CANNOT_TRIM */
++
++
++/*
++ Define HAVE_MMAP as true to optionally make malloc() use mmap() to
++ allocate very large blocks. These will be returned to the
++ operating system immediately after a free(). Also, if mmap
++ is available, it is used as a backup strategy in cases where
++ MORECORE fails to provide space from system.
++
++ This malloc is best tuned to work with mmap for large requests.
++ If you do not have mmap, operations involving very large chunks (1MB
++ or so) may be slower than you'd like.
++*/
++
++#ifndef HAVE_MMAP
++#define HAVE_MMAP 1
++#endif
++
++#if HAVE_MMAP
++/*
++ Standard unix mmap using /dev/zero clears memory so calloc doesn't
++ need to.
++*/
++
++#ifndef MMAP_CLEARS
++#define MMAP_CLEARS 1
++#endif
++
++#else /* no mmap */
++#ifndef MMAP_CLEARS
++#define MMAP_CLEARS 0
++#endif
++#endif
++
++
++/*
++ MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if
++ sbrk fails, and mmap is used as a backup (which is done only if
++ HAVE_MMAP). The value must be a multiple of page size. This
++ backup strategy generally applies only when systems have "holes" in
++ address space, so sbrk cannot perform contiguous expansion, but
++ there is still space available on system. On systems for which
++ this is known to be useful (i.e. most linux kernels), this occurs
++ only when programs allocate huge amounts of memory. Between this,
++ and the fact that mmap regions tend to be limited, the size should
++ be large, to avoid too many mmap calls and thus avoid running out
++ of kernel resources.
++*/
++
++#ifndef MMAP_AS_MORECORE_SIZE
++#define MMAP_AS_MORECORE_SIZE (1024 * 1024)
++#endif
++
++/*
++ Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
++ large blocks. This is currently only possible on Linux with
++ kernel versions newer than 1.3.77.
++*/
++
++#ifndef HAVE_MREMAP
++#if defined(linux) || defined(__linux__) || defined(__linux)
++#define HAVE_MREMAP 1
++#else
++#define HAVE_MREMAP 0
++#endif
++
++#endif /* HAVE_MMAP */
++
++
++/*
++ The system page size. To the extent possible, this malloc manages
++ memory from the system in page-size units. Note that this value is
++ cached during initialization into a field of malloc_state. So even
++ if malloc_getpagesize is a function, it is only called once.
++
++ The following mechanics for getpagesize were adapted from bsd/gnu
++ getpagesize.h. If none of the system-probes here apply, a value of
++ 4096 is used, which should be OK: If they don't apply, then using
++ the actual value probably doesn't impact performance.
++*/
++
++
++#ifndef malloc_getpagesize
++
++#ifndef LACKS_UNISTD_H
++# include <unistd.h>
++#endif
++
++# 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 */
++# define malloc_getpagesize getpagesize()
++# else
++# ifndef LACKS_SYS_PARAM_H
++# include <sys/param.h>
++# endif
++# ifdef EXEC_PAGESIZE
++# define malloc_getpagesize EXEC_PAGESIZE
++# else
++# ifdef NBPG
++# ifndef CLSIZE
++# define malloc_getpagesize NBPG
++# else
++# define malloc_getpagesize (NBPG * CLSIZE)
++# endif
++# else
++# ifdef NBPC
++# define malloc_getpagesize NBPC
++# else
++# ifdef PAGESIZE
++# define malloc_getpagesize PAGESIZE
++# else /* just guess */
++# define malloc_getpagesize (4096)
++# endif
++# endif
++# endif
++# endif
++# endif
++# endif
++# endif
++#endif
++
++/*
++ This version of malloc supports the standard SVID/XPG mallinfo
++ routine that returns a struct containing usage properties and
++ statistics. It should work on any SVID/XPG compliant system that has
++ a /usr/include/malloc.h defining struct mallinfo. (If you'd like to
++ install such a thing yourself, cut out the preliminary declarations
++ as described above and below and save them in a malloc.h file. But
++ there's no compelling reason to bother to do this.)
++
++ The main declaration needed is the mallinfo struct that is returned
++ (by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a
++ bunch of field that are not even meaningful in this version of
++ malloc. These fields are are instead filled by mallinfo() with
++ other numbers that might be of interest.
++
++ HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
++ /usr/include/malloc.h file that includes a declaration of struct
++ mallinfo. If so, it is included; else an SVID2/XPG2 compliant
++ version is declared below. These must be precisely the same for
++ mallinfo() to work. The original SVID version of this struct,
++ defined on most systems with mallinfo, declares all fields as
++ ints. But some others define as unsigned long. If your system
++ defines the fields using a type of different width than listed here,
++ you must #include your system version and #define
++ HAVE_USR_INCLUDE_MALLOC_H.
++*/
++
++/* #define HAVE_USR_INCLUDE_MALLOC_H */
++
++/*#ifdef HAVE_USR_INCLUDE_MALLOC_H*/
++#if 0
++#include "/usr/include/malloc.h"
++#else
++
++/* SVID2/XPG mallinfo structure */
++
++struct mallinfo {
++ int arena; /* non-mmapped space allocated from system */
++ int ordblks; /* number of free chunks */
++ int smblks; /* number of fastbin blocks */
++ int hblks; /* number of mmapped regions */
++ int hblkhd; /* space in mmapped regions */
++ int usmblks; /* maximum total allocated space */
++ int fsmblks; /* space available in freed fastbin blocks */
++ int uordblks; /* total allocated space */
++ int fordblks; /* total free space */
++ int keepcost; /* top-most, releasable (via malloc_trim) space */
++};
++
++/*
++ SVID/XPG defines four standard parameter numbers for mallopt,
++ normally defined in malloc.h. Only one of these (M_MXFAST) is used
++ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
++ so setting them has no effect. But this malloc also supports other
++ options in mallopt described below.
++*/
++#endif
++
++
++/* ---------- description of public routines ------------ */
++
++/*
++ malloc(size_t n)
++ Returns a pointer to a newly allocated chunk of at least n bytes, or null
++ if no space is available. Additionally, on failure, errno is
++ set to ENOMEM on ANSI C systems.
++
++ If n is zero, malloc returns a minumum-sized chunk. (The minimum
++ size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
++ systems.) On most systems, size_t is an unsigned type, so calls
++ with negative arguments 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.
++*/
++#if __STD_C
++Void_t* public_mALLOc(size_t);
++#else
++Void_t* public_mALLOc();
++#endif
++
++/*
++ free(Void_t* 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. It can have arbitrary (i.e., bad!)
++ effects if p has already been freed.
++
++ Unless disabled (using mallopt), freeing very large spaces will
++ when possible, automatically trigger operations that give
++ back unused memory to the system, thus reducing program footprint.
++*/
++#if __STD_C
++void public_fREe(Void_t*);
++#else
++void public_fREe();
++#endif
++
++/*
++ calloc(size_t n_elements, size_t element_size);
++ Returns a pointer to n_elements * element_size bytes, with all locations
++ set to zero.
++*/
++#if __STD_C
++Void_t* public_cALLOc(size_t, size_t);
++#else
++Void_t* public_cALLOc();
++#endif
++
++/*
++ realloc(Void_t* 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
++ if no space is available.
++
++ The returned pointer may or may not be the same as p. The algorithm
++ prefers extending p when possible, otherwise it employs the
++ equivalent of a malloc-copy-free sequence.
++
++ If p is null, realloc is equivalent to malloc.
++
++ If space is not available, realloc returns null, errno is set (if on
++ ANSI) and p is NOT freed.
++
++ if n is for fewer bytes than already held by p, the newly unused
++ space is lopped off and freed if possible. Unless the #define
++ REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of
++ zero (re)allocates a minimum-sized chunk.
++
++ Large chunks that were internally obtained via mmap will always
++ be reallocated using malloc-copy-free sequences unless
++ the system supports MREMAP (currently only linux).
++
++ The old unix realloc convention of allowing the last-free'd chunk
++ to be used as an argument to realloc is not supported.
++*/
++#if __STD_C
++Void_t* public_rEALLOc(Void_t*, size_t);
++#else
++Void_t* public_rEALLOc();
++#endif
++
++/*
++ 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.
++
++ The alignment argument should be a power of two. If the argument is
++ not a power of two, the nearest greater power is used.
++ 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.
++*/
++#if __STD_C
++Void_t* public_mEMALIGn(size_t, size_t);
++#else
++Void_t* public_mEMALIGn();
++#endif
++
++/*
++ 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.
++*/
++#if __STD_C
++Void_t* public_vALLOc(size_t);
++#else
++Void_t* public_vALLOc();
++#endif
++
++
++
++/*
++ 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
++ corresponding parameter to the argument value if it can (i.e., so
++ long as the value is meaningful), and returns 1 if successful else
++ 0. SVID/XPG/ANSI defines four standard param numbers for mallopt,
++ normally defined in malloc.h. Only one of these (M_MXFAST) is used
++ in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
++ so setting them has no effect. But this malloc also supports four
++ other options in mallopt. See below for details. Briefly, supported
++ parameters are as follows (listed defaults are for "typical"
++ configurations).
++
++ Symbol param # default allowed param values
++ M_MXFAST 1 64 0-80 (0 disables fastbins)
++ M_TRIM_THRESHOLD -1 128*1024 any (-1U disables trimming)
++ M_TOP_PAD -2 0 any
++ M_MMAP_THRESHOLD -3 128*1024 any (or 0 if no MMAP support)
++ M_MMAP_MAX -4 65536 any (0 disables use of mmap)
++*/
++#if __STD_C
++int public_mALLOPt(int, int);
++#else
++int public_mALLOPt();
++#endif
++
++
++/*
++ mallinfo()
++ Returns (by copy) a struct containing various summary statistics:
++
++ arena: current total non-mmapped bytes allocated from system
++ ordblks: the number of free chunks
++ smblks: the number of fastbin blocks (i.e., small chunks that
++ have been freed but not use resused or consolidated)
++ hblks: current number of mmapped regions
++ hblkhd: total bytes held in mmapped regions
++ usmblks: the maximum total allocated space. This will be greater
++ than current total if trimming has occurred.
++ fsmblks: total bytes held in fastbin blocks
++ uordblks: current total allocated space (normal or mmapped)
++ fordblks: total free space
++ keepcost: the maximum number of bytes that could ideally be released
++ back to system via malloc_trim. ("ideally" means that
++ it ignores page restrictions etc.)
++
++ Because these fields are ints, but internal bookkeeping may
++ be kept as longs, the reported values may wrap around zero and
++ thus be inaccurate.
++*/
++#if __STD_C
++struct mallinfo public_mALLINFo(void);
++#else
++struct mallinfo public_mALLINFo();
++#endif
++
++/*
++ independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
++
++ independent_calloc is similar to calloc, but instead of returning a
++ single cleared space, it returns an array of pointers to n_elements
++ independent elements that can hold contents of size elem_size, each
++ of which starts out cleared, and can be independently freed,
++ realloc'ed etc. The elements are guaranteed to be adjacently
++ allocated (this is not guaranteed to occur with multiple callocs or
++ mallocs), which may also improve cache locality in some
++ applications.
++
++ The "chunks" argument is optional (i.e., may be null, which is
++ probably the most typical usage). If it is null, the returned array
++ is itself dynamically allocated and should also be freed when it is
++ no longer needed. Otherwise, the chunks array must be of at least
++ n_elements in length. It is filled in with the pointers to the
++ chunks.
++
++ In either case, independent_calloc returns this pointer array, or
++ null if the allocation failed. If n_elements is zero and "chunks"
++ is null, it returns a chunk representing an array with zero elements
++ (which should be freed if not wanted).
++
++ Each element must be individually freed when it is no longer
++ needed. If you'd like to instead be able to free all at once, you
++ should instead use regular calloc and assign pointers into this
++ space to represent elements. (In this case though, you cannot
++ independently free elements.)
++
++ independent_calloc simplifies and speeds up implementations of many
++ kinds of pools. It may also be useful when constructing large data
++ structures that initially have a fixed number of fixed-sized nodes,
++ but the number is not known at compile time, and some of the nodes
++ may later need to be freed. For example:
++
++ struct Node { int item; struct Node* next; };
++
++ struct Node* build_list() {
++ struct Node** pool;
++ int n = read_number_of_nodes_needed();
++ if (n <= 0) return 0;
++ pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
++ if (pool == 0) die();
++ // organize into a linked list...
++ struct Node* first = pool[0];
++ for (i = 0; i < n-1; ++i)
++ pool[i]->next = pool[i+1];
++ free(pool); // Can now free the array (or not, if it is needed later)
++ return first;
++ }
++*/
++#if __STD_C
++Void_t** public_iCALLOc(size_t, size_t, Void_t**);
++#else
++Void_t** public_iCALLOc();
++#endif
++
++/*
++ independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
++
++ independent_comalloc allocates, all at once, a set of n_elements
++ chunks with sizes indicated in the "sizes" array. It returns
++ an array of pointers to these elements, each of which can be
++ independently freed, realloc'ed etc. The elements are guaranteed to
++ be adjacently allocated (this is not guaranteed to occur with
++ multiple callocs or mallocs), which may also improve cache locality
++ in some applications.
++
++ The "chunks" argument is optional (i.e., may be null). If it is null
++ the returned array is itself dynamically allocated and should also
++ be freed when it is no longer needed. Otherwise, the chunks array
++ must be of at least n_elements in length. It is filled in with the
++ pointers to the chunks.
++
++ In either case, independent_comalloc returns this pointer array, or
++ null if the allocation failed. If n_elements is zero and chunks is
++ null, it returns a chunk representing an array with zero elements
++ (which should be freed if not wanted).
++
++ Each element must be individually freed when it is no longer
++ needed. If you'd like to instead be able to free all at once, you
++ should instead use a single regular malloc, and assign pointers at
++ particular offsets in the aggregate space. (In this case though, you
++ cannot independently free elements.)
++
++ independent_comallac differs from independent_calloc in that each
++ element may have a different size, and also that it does not
++ automatically clear elements.
++
++ independent_comalloc can be used to speed up allocation in cases
++ where several structs or objects must always be allocated at the
++ same time. For example:
++
++ struct Head { ... }
++ struct Foot { ... }
++
++ void send_message(char* msg) {
++ int msglen = strlen(msg);
++ size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
++ void* chunks[3];
++ if (independent_comalloc(3, sizes, chunks) == 0)
++ die();
++ struct Head* head = (struct Head*)(chunks[0]);
++ char* body = (char*)(chunks[1]);
++ struct Foot* foot = (struct Foot*)(chunks[2]);
++ // ...
++ }
++
++ In general though, independent_comalloc is worth using only for
++ larger values of n_elements. For small values, you probably won't
++ detect enough difference from series of malloc calls to bother.
++
++ 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.
++*/
++#if __STD_C
++Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
++#else
++Void_t** public_iCOMALLOc();
++#endif
++
++
++/*
++ pvalloc(size_t n);
++ Equivalent to valloc(minimum-page-that-holds(n)), that is,
++ round up n to nearest pagesize.
++ */
++#if __STD_C
++Void_t* public_pVALLOc(size_t);
++#else
++Void_t* public_pVALLOc();
++#endif
++
++/*
++ cfree(Void_t* p);
++ Equivalent to free(p).
++
++ cfree is needed/defined on some systems that pair it with calloc,
++ for odd historical reasons (such as: cfree is used in example
++ code in the first edition of K&R).
++*/
++#if __STD_C
++void public_cFREe(Void_t*);
++#else
++void public_cFREe();
++#endif
++
++/*
++ malloc_trim(size_t pad);
++
++ If possible, gives memory back to the system (via negative
++ arguments to sbrk) if there is unused memory at the `high' end of
++ the malloc pool. You can call this after freeing large blocks of
++ memory to potentially reduce the system-level memory requirements
++ of a program. However, it cannot guarantee to reduce memory. Under
++ some allocation patterns, some large free blocks of memory will be
++ locked between two used chunks, so they cannot be given back to
++ the system.
++
++ The `pad' argument to malloc_trim represents the amount of free
++ trailing space to leave untrimmed. If this argument is zero,
++ only the minimum amount of memory to maintain internal data
++ structures will be left (one page or less). Non-zero arguments
++ can be supplied to maintain enough 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.
++ On systems that do not support "negative sbrks", it will always
++ rreturn 0.
++*/
++#if __STD_C
++int public_mTRIm(size_t);
++#else
++int public_mTRIm();
++#endif
++
++/*
++ malloc_usable_size(Void_t* p);
++
++ Returns the number of bytes you can actually use in
++ an allocated chunk, which may be more than you requested (although
++ often not) due to alignment and minimum size constraints.
++ You can use this many bytes without worrying about
++ overwriting other allocated objects. This is not a particularly great
++ programming practice. malloc_usable_size can be more useful in
++ debugging and assertions, for example:
++
++ p = malloc(n);
++ assert(malloc_usable_size(p) >= 256);
++
++*/
++#if __STD_C
++size_t public_mUSABLe(Void_t*);
++#else
++size_t public_mUSABLe();
++#endif
++
++/*
++ 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
++ current if malloc_trim and/or munmap got called), and the current
++ number of bytes allocated via malloc (or realloc, etc) but not yet
++ freed. Note that this is the number of bytes allocated, not the
++ number requested. It will be larger than the number requested
++ because of alignment and bookkeeping overhead. Because it includes
++ alignment wastage as being in use, this figure may be greater than
++ zero even when no user-level chunks are allocated.
++
++ The reported current and maximum system memory can be inaccurate if
++ a program makes other calls to system memory allocation functions
++ (normally sbrk) outside of malloc.
++
++ malloc_stats prints only the most commonly interesting statistics.
++ More information can be obtained by calling mallinfo.
++
++*/
++#if __STD_C
++void public_mSTATs();
++#else
++void public_mSTATs();
++#endif
++
++/* mallopt tuning options */
++
++/*
++ M_MXFAST is the maximum request size used for "fastbins", special bins
++ that hold returned chunks without consolidating their spaces. This
++ enables future requests for chunks of the same size to be handled
++ very quickly, but can increase fragmentation, and thus increase the
++ overall memory footprint of a program.
++
++ This malloc manages fastbins very conservatively yet still
++ efficiently, so fragmentation is rarely a problem for values less
++ than or equal to the default. The maximum supported value of MXFAST
++ is 80. You wouldn't want it any higher than this anyway. Fastbins
++ are designed especially for use with many small structs, objects or
++ strings -- the default handles structs/objects/arrays with sizes up
++ to 8 4byte fields, or small strings representing words, tokens,
++ etc. Using fastbins for larger objects normally worsens
++ fragmentation without improving speed.
++
++ M_MXFAST is set in REQUEST size units. It is internally used in
++ chunksize units, which adds padding and alignment. You can reduce
++ M_MXFAST to 0 to disable all use of fastbins. This causes the malloc
++ algorithm to be a closer approximation of fifo-best-fit in all cases,
++ not just for larger requests, but will generally cause it to be
++ slower.
++*/
++
++
++/* M_MXFAST is a standard SVID/XPG tuning option, usually listed in malloc.h */
++#ifndef M_MXFAST
++#define M_MXFAST 1
++#endif
++
++#ifndef DEFAULT_MXFAST
++#define DEFAULT_MXFAST 64
++#endif
++
++
++/*
++ M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
++ to keep before releasing via malloc_trim in free().
++
++ Automatic trimming is mainly useful in long-lived programs.
++ Because trimming via sbrk can be slow on some systems, and can
++ sometimes be wasteful (in cases where programs immediately
++ afterward allocate more large chunks) the value should be high
++ enough so that your overall system performance would improve by
++ releasing this much memory.
++
++ The trim threshold and the mmap control parameters (see below)
++ can be traded off with one another. Trimming and mmapping are
++ two different ways of releasing unused memory back to the
++ system. Between these two, it is often possible to keep
++ system-level demands of a long-lived program down to a bare
++ minimum. For example, in one test suite of sessions measuring
++ the XF86 X server on Linux, using a trim threshold of 128K and a
++ mmap threshold of 192K led to near-minimal long term resource
++ consumption.
++
++ If you are using this malloc in a long-lived program, it should
++ pay to experiment with these values. As a rough guide, you
++ might set to a value close to the average size of a process
++ (program) running on your system. Releasing this much memory
++ would allow such a process to run in memory. Generally, it's
++ worth it to tune for trimming rather tham memory mapping when a
++ program undergoes phases where several large chunks are
++ allocated and released in ways that can reuse each other's
++ storage, perhaps mixed with phases where there are no such
++ chunks at all. And in well-behaved long-lived programs,
++ controlling release of large blocks via trimming versus mapping
++ is usually faster.
++
++ However, in most programs, these parameters serve mainly as
++ protection against the system-level effects of carrying around
++ massive amounts of unneeded memory. Since frequent calls to
++ sbrk, mmap, and munmap otherwise degrade performance, the default
++ parameters are set to relatively high values that serve only as
++ safeguards.
++
++ The trim value It must be greater than page size to have any useful
++ effect. To disable trimming completely, you can set to
++ (unsigned long)(-1)
++
++ Trim settings interact with fastbin (MXFAST) settings: Unless
++ TRIM_FASTBINS is defined, automatic trimming never takes place upon
++ freeing a chunk with size less than or equal to MXFAST. Trimming is
++ instead delayed until subsequent freeing of larger chunks. However,
++ you can still force an attempted trim by calling malloc_trim.
++
++ Also, trimming is not generally possible in cases where
++ the main arena is obtained via mmap.
++
++ Note that the trick some people use of mallocing a huge space and
++ then freeing it at program startup, in an attempt to reserve system
++ memory, doesn't have the intended effect under automatic trimming,
++ since that memory will immediately be returned to the system.
++*/
++
++#define M_TRIM_THRESHOLD -1
++
++#ifndef DEFAULT_TRIM_THRESHOLD
++#define DEFAULT_TRIM_THRESHOLD (128 * 1024)
++#endif
++
++/*
++ M_TOP_PAD is the amount of extra `padding' space to allocate or
++ retain whenever sbrk is called. It is used in two ways internally:
++
++ * When sbrk is called to extend the top of the arena to satisfy
++ a new malloc request, this much padding is added to the sbrk
++ request.
++
++ * When malloc_trim is called automatically from free(),
++ it is used as the `pad' argument.
++
++ In both cases, the actual amount of padding is rounded
++ so that the end of the arena is always a system page boundary.
++
++ The main reason for using padding is to avoid calling sbrk so
++ often. Having even a small pad greatly reduces the likelihood
++ that nearly every malloc request during program start-up (or
++ after trimming) will invoke sbrk, which needlessly wastes
++ time.
++
++ Automatic rounding-up to page-size units is normally sufficient
++ to avoid measurable overhead, so the default is 0. However, in
++ systems where sbrk is relatively slow, it can pay to increase
++ this value, at the expense of carrying around more memory than
++ the program needs.
++*/
++
++#define M_TOP_PAD -2
++
++#ifndef DEFAULT_TOP_PAD
++#define DEFAULT_TOP_PAD (0)
++#endif
++
++/*
++ M_MMAP_THRESHOLD is the request size threshold for using mmap()
++ to service a request. Requests of at least this size that cannot
++ be allocated using already-existing space will be serviced via mmap.
++ (If enough normal freed space already exists it is used instead.)
++
++ Using mmap segregates relatively large chunks of memory so that
++ they can be individually obtained and released from the host
++ system. A request serviced through mmap is never reused by any
++ other request (at least not directly; the system may just so
++ happen to remap successive requests to the same locations).
++
++ Segregating space in this way has the benefits that:
++
++ 1. Mmapped space can ALWAYS be individually released back
++ to the system, which helps keep the system level memory
++ demands of a long-lived program low.
++ 2. Mapped memory can never become `locked' between
++ other chunks, as can happen with normally allocated chunks, which
++ means that even trimming via malloc_trim would not release them.
++ 3. On some systems with "holes" in address spaces, mmap can obtain
++ memory that sbrk cannot.
++
++ However, it has the disadvantages that:
++
++ 1. The space cannot be reclaimed, consolidated, and then
++ used to service later requests, as happens with normal chunks.
++ 2. It can lead to more wastage because of mmap page alignment
++ requirements
++ 3. It causes malloc performance to be more dependent on host
++ system memory management support routines which may vary in
++ implementation quality and may impose arbitrary
++ limitations. Generally, servicing a request via normal
++ malloc steps is faster than going through a system's mmap.
++
++ The advantages of mmap nearly always outweigh disadvantages for
++ "large" chunks, but the value of "large" varies across systems. The
++ default is an empirically derived value that works well in most
++ systems.
++*/
++
++#define M_MMAP_THRESHOLD -3
++
++#ifndef DEFAULT_MMAP_THRESHOLD
++#define DEFAULT_MMAP_THRESHOLD (128 * 1024)
++#endif
++
++/*
++ M_MMAP_MAX is the maximum number of requests to simultaneously
++ service using mmap. This parameter exists because
++. Some systems have a limited number of internal tables for
++ use by mmap, and using more than a few of them may degrade
++ performance.
++
++ The default is set to a value that serves only as a safeguard.
++ Setting to 0 disables use of mmap for servicing large requests. If
++ HAVE_MMAP is not set, the default value is 0, and attempts to set it
++ to non-zero values in mallopt will fail.
++*/
++
++#define M_MMAP_MAX -4
++
++#ifndef DEFAULT_MMAP_MAX
++#if HAVE_MMAP
++#define DEFAULT_MMAP_MAX (65536)
++#else
++#define DEFAULT_MMAP_MAX (0)
++#endif
++#endif
++
++#ifdef __cplusplus
++}; /* end of extern "C" */
++#endif
++
++/*
++ ========================================================================
++ To make a fully customizable malloc.h header file, cut everything
++ above this line, put into file malloc.h, edit to suit, and #include it
++ on the next line, as well as in programs that use this malloc.
++ ========================================================================
++*/
++
++/* #include "malloc.h" */
++
++/* --------------------- public wrappers ---------------------- */
++
++#ifdef USE_PUBLIC_MALLOC_WRAPPERS
++
++/* Declare all routines as internal */
++#if __STD_C
++static Void_t* mALLOc(size_t);
++static void fREe(Void_t*);
++static Void_t* rEALLOc(Void_t*, size_t);
++static Void_t* mEMALIGn(size_t, size_t);
++static Void_t* vALLOc(size_t);
++static Void_t* pVALLOc(size_t);
++static Void_t* cALLOc(size_t, size_t);
++static Void_t** iCALLOc(size_t, size_t, Void_t**);
++static Void_t** iCOMALLOc(size_t, size_t*, Void_t**);
++static void cFREe(Void_t*);
++static int mTRIm(size_t);
++static size_t mUSABLe(Void_t*);
++static void mSTATs();
++static int mALLOPt(int, int);
++static struct mallinfo mALLINFo(void);
++#else
++static Void_t* mALLOc();
++static void fREe();
++static Void_t* rEALLOc();
++static Void_t* mEMALIGn();
++static Void_t* vALLOc();
++static Void_t* pVALLOc();
++static Void_t* cALLOc();
++static Void_t** iCALLOc();
++static Void_t** iCOMALLOc();
++static void cFREe();
++static int mTRIm();
++static size_t mUSABLe();
++static void mSTATs();
++static int mALLOPt();
++static struct mallinfo mALLINFo();
++#endif
++
++/*
++ MALLOC_PREACTION and MALLOC_POSTACTION should be
++ defined to return 0 on success, and nonzero on failure.
++ The return value of MALLOC_POSTACTION is currently ignored
++ in wrapper functions since there is no reasonable default
++ action to take on failure.
++*/
++
++
++#ifdef USE_MALLOC_LOCK
++
++#ifdef WIN32
++
++static int mALLOC_MUTEx;
++#define MALLOC_PREACTION slwait(&mALLOC_MUTEx)
++#define MALLOC_POSTACTION slrelease(&mALLOC_MUTEx)
++
++#else
++
++#if 0
++#include <pthread.h>
++
++static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER;
++
++#define MALLOC_PREACTION pthread_mutex_lock(&mALLOC_MUTEx)
++#define MALLOC_POSTACTION pthread_mutex_unlock(&mALLOC_MUTEx)
++
++#else
++
++#ifdef KDE_MALLOC_X86
++#include "x86.h"
++#elif defined(KDE_MALLOC_AVR32)
++
++#include <sched.h>
++#include <time.h>
++
++static __inline__ int q_atomic_swp(volatile unsigned int *ptr,
++ unsigned int newval)
++{
++ register int ret;
++ asm volatile("xchg %0,%1,%2"
++ : "=&r"(ret)
++ : "r"(ptr), "r"(newval)
++ : "memory", "cc");
++ return ret;
++}
++
++typedef struct {
++ volatile unsigned int lock;
++ int pad0_;
++} mutex_t;
++
++#define MUTEX_INITIALIZER { 0, 0 }
++
++static __inline__ int lock(mutex_t *m) {
++ int cnt = 0;
++ struct timespec tm;
++
++ for(;;) {
++ if (q_atomic_swp(&m->lock, 1) == 0)
++ return 0;
++#ifdef _POSIX_PRIORITY_SCHEDULING
++ if(cnt < 50) {
++ sched_yield();
++ cnt++;
++ } else
++#endif
++ {
++ tm.tv_sec = 0;
++ tm.tv_nsec = 2000001;
++ nanosleep(&tm, NULL);
++ cnt = 0;
++ }
++ }
++}
++
++static __inline__ int unlock(mutex_t *m) {
++ m->lock = 0;
++ return 0;
++}
++
++#else
++#error Unknown spinlock implementation
++#endif
++
++static mutex_t spinlock = MUTEX_INITIALIZER;
++
++#define MALLOC_PREACTION lock( &spinlock )
++#define MALLOC_POSTACTION unlock( &spinlock )
++
++#endif
++
++#endif /* USE_MALLOC_LOCK */
++
++#else
++
++/* Substitute anything you like for these */
++
++#define MALLOC_PREACTION (0)
++#define MALLOC_POSTACTION (0)
++
++#endif
++
++#if 0
++Void_t* public_mALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++void public_fREe(Void_t* m) {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ fREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = rEALLOc(m, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mEMALIGn(alignment, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_vALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = vALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_pVALLOc(size_t bytes) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = pVALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t* public_cALLOc(size_t n, size_t elem_size) {
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = cALLOc(n, elem_size);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++
++Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {
++ Void_t** m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = iCALLOc(n, elem_size, chunks);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {
++ Void_t** m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = iCOMALLOc(n, sizes, chunks);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++void public_cFREe(Void_t* m) {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ cFREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++int public_mTRIm(size_t s) {
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mTRIm(s);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++
++size_t public_mUSABLe(Void_t* m) {
++ size_t result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mUSABLe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++
++void public_mSTATs() {
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ mSTATs();
++ if (MALLOC_POSTACTION != 0) {
++ }
++}
++
++struct mallinfo public_mALLINFo() {
++ struct mallinfo m;
++ if (MALLOC_PREACTION != 0) {
++ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
++ return nm;
++ }
++ m = mALLINFo();
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++}
++
++int public_mALLOPt(int p, int v) {
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mALLOPt(p, v);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++}
++#endif
++
++#endif
++
++
++
++/* ------------- Optional versions of memcopy ---------------- */
++
++
++#if USE_MEMCPY
++
++/*
++ Note: memcpy is ONLY invoked with non-overlapping regions,
++ so the (usually slower) memmove is not needed.
++*/
++
++#define MALLOC_COPY(dest, src, nbytes) memcpy(dest, src, nbytes)
++#define MALLOC_ZERO(dest, nbytes) memset(dest, 0, nbytes)
++
++#else /* !USE_MEMCPY */
++
++/* Use Duff's device for good zeroing/copying performance. */
++
++#define MALLOC_ZERO(charp, nbytes) \
++do { \
++ INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \
++ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
++ long mcn; \
++ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
++ switch (mctmp) { \
++ case 0: for(;;) { *mzp++ = 0; \
++ case 7: *mzp++ = 0; \
++ case 6: *mzp++ = 0; \
++ case 5: *mzp++ = 0; \
++ case 4: *mzp++ = 0; \
++ case 3: *mzp++ = 0; \
++ case 2: *mzp++ = 0; \
++ case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \
++ } \
++} while(0)
++
++#define MALLOC_COPY(dest,src,nbytes) \
++do { \
++ INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \
++ INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \
++ unsigned long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T); \
++ long mcn; \
++ if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \
++ switch (mctmp) { \
++ case 0: for(;;) { *mcdst++ = *mcsrc++; \
++ case 7: *mcdst++ = *mcsrc++; \
++ case 6: *mcdst++ = *mcsrc++; \
++ case 5: *mcdst++ = *mcsrc++; \
++ case 4: *mcdst++ = *mcsrc++; \
++ case 3: *mcdst++ = *mcsrc++; \
++ case 2: *mcdst++ = *mcsrc++; \
++ case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \
++ } \
++} while(0)
++
++#endif
++
++/* ------------------ MMAP support ------------------ */
++
++
++#if HAVE_MMAP
++
++#include <fcntl.h>
++#ifndef LACKS_SYS_MMAN_H
++#include <sys/mman.h>
++#endif
++
++#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
++#define MAP_ANONYMOUS MAP_ANON
++#endif
++
++/*
++ Nearly all versions of mmap support MAP_ANONYMOUS,
++ so the following is unlikely to be needed, but is
++ supplied just in case.
++*/
++
++#ifndef MAP_ANONYMOUS
++
++static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
++
++#define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? \
++ (dev_zero_fd = open("/dev/zero", O_RDWR), \
++ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : \
++ mmap((addr), (size), (prot), (flags), dev_zero_fd, 0))
++
++#else
++
++#define MMAP(addr, size, prot, flags) \
++ (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0))
++
++#endif
++
++
++#endif /* HAVE_MMAP */
++
++
++/*
++ ----------------------- Chunk representations -----------------------
++*/
++
++
++/*
++ This struct declaration is misleading (but accurate and necessary).
++ It declares a "view" into memory allowing access to necessary
++ fields at known offsets from a given base. See explanation below.
++*/
++
++struct malloc_chunk {
++
++ INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
++ INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
++
++ struct malloc_chunk* fd; /* double links -- used only if free. */
++ struct malloc_chunk* bk;
++};
++
++
++typedef struct malloc_chunk* mchunkptr;
++
++/*
++ malloc_chunk details:
++
++ (The following includes lightly edited explanations by Colin Plumb.)
++
++ Chunks of memory are maintained using a `boundary tag' method as
++ described in e.g., Knuth or Standish. (See the paper by Paul
++ Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
++ survey of such techniques.) Sizes of free chunks are stored both
++ in the front of each chunk and at the end. This makes
++ consolidating fragmented chunks into bigger chunks very fast. The
++ size fields also hold bits representing whether chunks are free or
++ in use.
++
++ An allocated chunk looks like this:
++
++
++ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of previous chunk, if allocated | |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of chunk, in bytes |P|
++ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | User data starts here... .
++ . .
++ . (malloc_usable_space() bytes) .
++ . |
++nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of chunk |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++
++
++ Where "chunk" is the front of the chunk for the purpose of most of
++ the malloc code, but "mem" is the pointer that is returned to the
++ user. "Nextchunk" is the beginning of the next contiguous chunk.
++
++ Chunks always begin on even word boundaries, so the mem portion
++ (which is returned to the user) is also on an even word boundary, and
++ thus at least double-word aligned.
++
++ Free chunks are stored in circular doubly-linked lists, and look like this:
++
++ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Size of previous chunk |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ `head:' | Size of chunk, in bytes |P|
++ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Forward pointer to next chunk in list |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Back pointer to previous chunk in list |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ | Unused space (may be 0 bytes long) .
++ . .
++ . |
++nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++ `foot:' | Size of chunk, in bytes |
++ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
++
++ The P (PREV_INUSE) bit, stored in the unused low-order bit of the
++ chunk size (which is always a multiple of two words), is an in-use
++ bit for the *previous* chunk. If that bit is *clear*, then the
++ word before the current chunk size contains the previous chunk
++ size, and can be used to find the front of the previous chunk.
++ The very first chunk allocated always has this bit set,
++ preventing access to non-existent (or non-owned) memory. If
++ prev_inuse is set for any given chunk, then you CANNOT determine
++ the size of the previous chunk, and might even get a memory
++ addressing fault when trying to do so.
++
++ Note that the `foot' of the current chunk is actually represented
++ as the prev_size of the NEXT chunk. This makes it easier to
++ deal with alignments etc but can be very confusing when trying
++ to extend or adapt this code.
++
++ The two exceptions to all this are
++
++ 1. The special chunk `top' doesn't bother using the
++ trailing size field since there is no next contiguous chunk
++ that would have to index off it. After initialization, `top'
++ is forced to always exist. If it would become less than
++ MINSIZE bytes long, it is replenished.
++
++ 2. Chunks allocated via mmap, which have the second-lowest-order
++ bit (IS_MMAPPED) set in their size fields. Because they are
++ allocated one-by-one, each must contain its own trailing size field.
++
++*/
++
++/*
++ ---------- Size and alignment checks and conversions ----------
++*/
++
++/* conversion from malloc headers to user pointers, and back */
++
++#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ))
++#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
++
++/* The smallest possible chunk */
++#define MIN_CHUNK_SIZE (sizeof(struct malloc_chunk))
++
++/* The smallest size we can malloc is an aligned minimal chunk */
++
++#define MINSIZE \
++ (unsigned long)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
++
++/* Check if m has acceptable alignment */
++
++#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0)
++
++
++/*
++ Check if a request is so large that it would wrap around zero when
++ padded and aligned. To simplify some other code, the bound is made
++ low enough so that adding MINSIZE will also not wrap around zero.
++*/
++
++#define REQUEST_OUT_OF_RANGE(req) \
++ ((unsigned long)(req) >= \
++ (unsigned long)(INTERNAL_SIZE_T)(-2 * MINSIZE))
++
++/* pad request bytes into a usable size -- internal version */
++
++#define request2size(req) \
++ (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE) ? \
++ MINSIZE : \
++ ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
++
++/* Same, except also perform argument check */
++
++#define checked_request2size(req, sz) \
++ if (REQUEST_OUT_OF_RANGE(req)) { \
++ MALLOC_FAILURE_ACTION; \
++ return 0; \
++ } \
++ (sz) = request2size(req);
++
++/*
++ --------------- Physical chunk operations ---------------
++*/
++
++
++/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
++#define PREV_INUSE 0x1
++
++/* extract inuse bit of previous chunk */
++#define prev_inuse(p) ((p)->size & PREV_INUSE)
++
++
++/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
++#define IS_MMAPPED 0x2
++
++/* check for mmap()'ed chunk */
++#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
++
++/*
++ Bits to mask off when extracting size
++
++ Note: IS_MMAPPED is intentionally not masked off from size field in
++ macros for which mmapped chunks should never be seen. This should
++ cause helpful core dumps to occur if it is tried by accident by
++ people extending or adapting this malloc.
++*/
++#define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
++
++/* Get size, ignoring use bits */
++#define chunksize(p) ((p)->size & ~(SIZE_BITS))
++
++
++/* Ptr to next physical malloc_chunk. */
++#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
++
++/* Ptr to previous physical malloc_chunk */
++#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
++
++/* Treat space at ptr + offset as a chunk */
++#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
++
++/* extract p's inuse bit */
++#define inuse(p)\
++((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
++
++/* set/clear chunk as being inuse without otherwise disturbing */
++#define set_inuse(p)\
++((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
++
++#define clear_inuse(p)\
++((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
++
++
++/* check/set/clear inuse bits in known places */
++#define inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
++
++#define set_inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
++
++#define clear_inuse_bit_at_offset(p, s)\
++ (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
++
++
++/* Set size at head, without disturbing its use bit */
++#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s)))
++
++/* Set size/use field */
++#define set_head(p, s) ((p)->size = (s))
++
++/* Set size at footer (only when chunk is not in use) */
++#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
++
++
++/*
++ -------------------- Internal data structures --------------------
++
++ All internal state is held in an instance of malloc_state defined
++ below. There are no other static variables, except in two optional
++ cases:
++ * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
++ * If HAVE_MMAP is true, but mmap doesn't support
++ MAP_ANONYMOUS, a dummy file descriptor for mmap.
++
++ Beware of lots of tricks that minimize the total bookkeeping space
++ requirements. The result is a little over 1K bytes (for 4byte
++ pointers and size_t.)
++*/
++
++/*
++ Bins
++
++ An array of bin headers for free chunks. Each bin is doubly
++ linked. The bins are approximately proportionally (log) spaced.
++ There are a lot of these bins (128). This may look excessive, but
++ works very well in practice. Most bins hold sizes that are
++ unusual as malloc request sizes, but are more usual for fragments
++ and consolidated sets of chunks, which is what these bins hold, so
++ they can be found quickly. All procedures maintain the invariant
++ that no consolidated chunk physically borders another one, so each
++ chunk in a list is known to be preceded and followed by either
++ inuse chunks or the ends of memory.
++
++ Chunks in bins are kept in size order, with ties going to the
++ approximately least recently used chunk. Ordering isn't needed
++ for the small bins, which all contain the same-sized chunks, but
++ facilitates best-fit allocation for larger chunks. These lists
++ are just sequential. Keeping them in order almost never requires
++ enough traversal to warrant using fancier ordered data
++ structures.
++
++ Chunks of the same size are linked with the most
++ recently freed at the front, and allocations are taken from the
++ back. This results in LRU (FIFO) allocation order, which tends
++ to give each chunk an equal opportunity to be consolidated with
++ adjacent freed chunks, resulting in larger free chunks and less
++ fragmentation.
++
++ To simplify use in double-linked lists, each bin header acts
++ as a malloc_chunk. This avoids special-casing for headers.
++ But to conserve space and improve locality, we allocate
++ only the fd/bk pointers of bins, and then use repositioning tricks
++ to treat these as the fields of a malloc_chunk*.
++*/
++
++typedef struct malloc_chunk* mbinptr;
++
++/* addressing -- note that bin_at(0) does not exist */
++#define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1)))
++
++/* analog of ++bin */
++#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
++
++/* Reminders about list directionality within bins */
++#define first(b) ((b)->fd)
++#define last(b) ((b)->bk)
++
++/* Take a chunk off a bin list */
++#define unlink(P, BK, FD) { \
++ FD = P->fd; \
++ BK = P->bk; \
++ FD->bk = BK; \
++ BK->fd = FD; \
++}
++
++/*
++ Indexing
++
++ Bins for sizes < 512 bytes contain chunks of all the same size, spaced
++ 8 bytes apart. Larger bins are approximately logarithmically spaced:
++
++ 64 bins of size 8
++ 32 bins of size 64
++ 16 bins of size 512
++ 8 bins of size 4096
++ 4 bins of size 32768
++ 2 bins of size 262144
++ 1 bin of size what's left
++
++ There is actually a little bit of slop in the numbers in bin_index
++ for the sake of speed. This makes no difference elsewhere.
++
++ The bins top out around 1MB because we expect to service large
++ requests via mmap.
++*/
++
++#define NBINS 128
++#define NSMALLBINS 64
++#define SMALLBIN_WIDTH 8
++#define MIN_LARGE_SIZE 512
++
++#define in_smallbin_range(sz) \
++ ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
++
++#define smallbin_index(sz) (((unsigned)(sz)) >> 3)
++
++#define largebin_index(sz) \
++(((((unsigned long)(sz)) >> 6) <= 32)? 56 + (((unsigned long)(sz)) >> 6): \
++ ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
++ ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
++ ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
++ ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
++ 126)
++
++#define bin_index(sz) \
++ ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
++
++
++/*
++ Unsorted chunks
++
++ All remainders from chunk splits, as well as all returned chunks,
++ are first placed in the "unsorted" bin. They are then placed
++ in regular bins after malloc gives them ONE chance to be used before
++ binning. So, basically, the unsorted_chunks list acts as a queue,
++ with chunks being placed on it in free (and malloc_consolidate),
++ and taken off (to be either used or placed in bins) in malloc.
++*/
++
++/* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
++#define unsorted_chunks(M) (bin_at(M, 1))
++
++/*
++ Top
++
++ The top-most available chunk (i.e., the one bordering the end of
++ available memory) is treated specially. It is never included in
++ any bin, is used only if no other chunk is available, and is
++ released back to the system if it is very large (see
++ M_TRIM_THRESHOLD). Because top initially
++ points to its own bin with initial zero size, thus forcing
++ extension on the first malloc request, we avoid having any special
++ code in malloc to check whether it even exists yet. But we still
++ need to do so when getting memory from system, so we make
++ initial_top treat the bin as a legal but unusable chunk during the
++ interval between initialization and the first call to
++ sYSMALLOc. (This is somewhat delicate, since it relies on
++ the 2 preceding words to be zero during this interval as well.)
++*/
++
++/* Conveniently, the unsorted bin can be used as dummy top on first call */
++#define initial_top(M) (unsorted_chunks(M))
++
++/*
++ Binmap
++
++ To help compensate for the large number of bins, a one-level index
++ structure is used for bin-by-bin searching. `binmap' is a
++ bitvector recording whether bins are definitely empty so they can
++ be skipped over during during traversals. The bits are NOT always
++ cleared as soon as bins are empty, but instead only
++ when they are noticed to be empty during traversal in malloc.
++*/
++
++/* Conservatively use 32 bits per map word, even if on 64bit system */
++#define BINMAPSHIFT 5
++#define BITSPERMAP (1U << BINMAPSHIFT)
++#define BINMAPSIZE (NBINS / BITSPERMAP)
++
++#define idx2block(i) ((i) >> BINMAPSHIFT)
++#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
++
++#define mark_bin(m,i) ((m)->binmap[idx2block(i)] |= idx2bit(i))
++#define unmark_bin(m,i) ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
++#define get_binmap(m,i) ((m)->binmap[idx2block(i)] & idx2bit(i))
++
++/*
++ Fastbins
++
++ An array of lists holding recently freed small chunks. Fastbins
++ are not doubly linked. It is faster to single-link them, and
++ since chunks are never removed from the middles of these lists,
++ double linking is not necessary. Also, unlike regular bins, they
++ are not even processed in FIFO order (they use faster LIFO) since
++ ordering doesn't much matter in the transient contexts in which
++ fastbins are normally used.
++
++ Chunks in fastbins keep their inuse bit set, so they cannot
++ be consolidated with other free chunks. malloc_consolidate
++ releases all chunks in fastbins and consolidates them with
++ other free chunks.
++*/
++
++typedef struct malloc_chunk* mfastbinptr;
++
++/* offset 2 to use otherwise unindexable first 2 bins */
++#define fastbin_index(sz) ((((unsigned int)(sz)) >> 3) - 2)
++
++/* The maximum fastbin request size we support */
++#define MAX_FAST_SIZE 80
++
++#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE))+1)
++
++/*
++ FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
++ that triggers automatic consolidation of possibly-surrounding
++ fastbin chunks. This is a heuristic, so the exact value should not
++ matter too much. It is defined at half the default trim threshold as a
++ compromise heuristic to only attempt consolidation if it is likely
++ to lead to trimming. However, it is not dynamically tunable, since
++ consolidation reduces fragmentation surrounding loarge chunks even
++ if trimming is not used.
++*/
++
++#define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL)
++
++/*
++ Since the lowest 2 bits in max_fast don't matter in size comparisons,
++ they are used as flags.
++*/
++
++/*
++ FASTCHUNKS_BIT held in max_fast indicates that there are probably
++ some fastbin chunks. It is set true on entering a chunk into any
++ fastbin, and cleared only in malloc_consolidate.
++
++ The truth value is inverted so that have_fastchunks will be true
++ upon startup (since statics are zero-filled), simplifying
++ initialization checks.
++*/
++
++#define FASTCHUNKS_BIT (1U)
++
++#define have_fastchunks(M) (((M)->max_fast & FASTCHUNKS_BIT) == 0)
++#define clear_fastchunks(M) ((M)->max_fast |= FASTCHUNKS_BIT)
++#define set_fastchunks(M) ((M)->max_fast &= ~FASTCHUNKS_BIT)
++
++/*
++ NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
++ regions. Otherwise, contiguity is exploited in merging together,
++ when possible, results from consecutive MORECORE calls.
++
++ The initial value comes from MORECORE_CONTIGUOUS, but is
++ changed dynamically if mmap is ever used as an sbrk substitute.
++*/
++
++#define NONCONTIGUOUS_BIT (2U)
++
++#define contiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) == 0)
++#define noncontiguous(M) (((M)->max_fast & NONCONTIGUOUS_BIT) != 0)
++#define set_noncontiguous(M) ((M)->max_fast |= NONCONTIGUOUS_BIT)
++#define set_contiguous(M) ((M)->max_fast &= ~NONCONTIGUOUS_BIT)
++
++/*
++ Set value of max_fast.
++ Use impossibly small value if 0.
++ Precondition: there are no existing fastbin chunks.
++ Setting the value clears fastchunk bit but preserves noncontiguous bit.
++*/
++
++#define set_max_fast(M, s) \
++ (M)->max_fast = (((s) == 0)? SMALLBIN_WIDTH: request2size(s)) | \
++ FASTCHUNKS_BIT | \
++ ((M)->max_fast & NONCONTIGUOUS_BIT)
++
++
++/*
++ ----------- Internal state representation and initialization -----------
++*/
++
++struct malloc_state {
++
++ /* The maximum chunk size to be eligible for fastbin */
++ INTERNAL_SIZE_T max_fast; /* low 2 bits used as flags */
++
++ /* Fastbins */
++ mfastbinptr fastbins[NFASTBINS];
++
++ /* Base of the topmost chunk -- not otherwise kept in a bin */
++ mchunkptr top;
++
++ /* The remainder from the most recent split of a small request */
++ mchunkptr last_remainder;
++
++ /* Normal bins packed as described above */
++ mchunkptr bins[NBINS * 2];
++
++ /* Bitmap of bins */
++ unsigned int binmap[BINMAPSIZE];
++
++ /* Tunable parameters */
++ unsigned long trim_threshold;
++ INTERNAL_SIZE_T top_pad;
++ INTERNAL_SIZE_T mmap_threshold;
++
++ /* Memory map support */
++ int n_mmaps;
++ int n_mmaps_max;
++ int max_n_mmaps;
++
++ /* Cache malloc_getpagesize */
++ unsigned int pagesize;
++
++ /* Statistics */
++ INTERNAL_SIZE_T mmapped_mem;
++ INTERNAL_SIZE_T sbrked_mem;
++ INTERNAL_SIZE_T max_sbrked_mem;
++ INTERNAL_SIZE_T max_mmapped_mem;
++ INTERNAL_SIZE_T max_total_mem;
++};
++
++typedef struct malloc_state *mstate;
++
++/*
++ There is exactly one instance of this struct in this malloc.
++ If you are adapting this malloc in a way that does NOT use a static
++ malloc_state, you MUST explicitly zero-fill it before using. This
++ malloc relies on the property that malloc_state is initialized to
++ all zeroes (as is true of C statics).
++*/
++
++static struct malloc_state av_; /* never directly referenced */
++
++/*
++ All uses of av_ are via get_malloc_state().
++ At most one "call" to get_malloc_state is made per invocation of
++ the public versions of malloc and free, but other routines
++ that in turn invoke malloc and/or free may call more then once.
++ Also, it is called in check* routines if DEBUG is set.
++*/
++
++#define get_malloc_state() (&(av_))
++
++/*
++ Initialize a malloc_state struct.
++
++ This is called only from within malloc_consolidate, which needs
++ be called in the same contexts anyway. It is never called directly
++ outside of malloc_consolidate because some optimizing compilers try
++ to inline it at all call points, which turns out not to be an
++ optimization at all. (Inlining it in malloc_consolidate is fine though.)
++*/
++
++#if __STD_C
++static void malloc_init_state(mstate av)
++#else
++static void malloc_init_state(av) mstate av;
++#endif
++{
++ int i;
++ mbinptr bin;
++
++ /* Establish circular links for normal bins */
++ for (i = 1; i < NBINS; ++i) {
++ bin = bin_at(av,i);
++ bin->fd = bin->bk = bin;
++ }
++
++ av->top_pad = DEFAULT_TOP_PAD;
++ av->n_mmaps_max = DEFAULT_MMAP_MAX;
++ av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
++ av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
++
++#if !MORECORE_CONTIGUOUS
++ set_noncontiguous(av);
++#endif
++
++ set_max_fast(av, DEFAULT_MXFAST);
++
++ av->top = initial_top(av);
++ av->pagesize = malloc_getpagesize;
++}
++
++/*
++ Other internal utilities operating on mstates
++*/
++
++#if __STD_C
++static Void_t* sYSMALLOc(INTERNAL_SIZE_T, mstate);
++static int sYSTRIm(size_t, mstate);
++static void malloc_consolidate(mstate);
++static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
++#else
++static Void_t* sYSMALLOc();
++static int sYSTRIm();
++static void malloc_consolidate();
++static Void_t** iALLOc();
++#endif
++
++/*
++ Debugging support
++
++ These routines make a number of assertions about the states
++ of data structures that should be true at all times. If any
++ are not true, it's very likely that a user program has somehow
++ trashed memory. (It's also possible that there is a coding error
++ in malloc. In which case, please report it!)
++*/
++
++#ifndef DEBUG
++
++#define check_chunk(P)
++#define check_free_chunk(P)
++#define check_inuse_chunk(P)
++#define check_remalloced_chunk(P,N)
++#define check_malloced_chunk(P,N)
++#define check_malloc_state()
++
++#else
++#define check_chunk(P) do_check_chunk(P)
++#define check_free_chunk(P) do_check_free_chunk(P)
++#define check_inuse_chunk(P) do_check_inuse_chunk(P)
++#define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N)
++#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
++#define check_malloc_state() do_check_malloc_state()
++
++/*
++ Properties of all chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_chunk(mchunkptr p)
++#else
++static void do_check_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++ unsigned long sz = chunksize(p);
++ /* min and max possible addresses assuming contiguous allocation */
++ char* max_address = (char*)(av->top) + chunksize(av->top);
++ char* min_address = max_address - av->sbrked_mem;
++
++ if (!chunk_is_mmapped(p)) {
++
++ /* Has legal address ... */
++ if (p != av->top) {
++ if (contiguous(av)) {
++ assert(((char*)p) >= min_address);
++ assert(((char*)p + sz) <= ((char*)(av->top)));
++ }
++ }
++ else {
++ /* top size is always at least MINSIZE */
++ assert((unsigned long)(sz) >= MINSIZE);
++ /* top predecessor always marked inuse */
++ assert(prev_inuse(p));
++ }
++
++ }
++ else {
++#if HAVE_MMAP
++ /* address is outside main heap */
++ if (contiguous(av) && av->top != initial_top(av)) {
++ assert(((char*)p) < min_address || ((char*)p) > max_address);
++ }
++ /* chunk is page-aligned */
++ assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
++ /* mem is aligned */
++ assert(aligned_OK(chunk2mem(p)));
++#else
++ /* force an appropriate assert violation if debug set */
++ assert(!chunk_is_mmapped(p));
++#endif
++ }
++}
++
++/*
++ Properties of free chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_free_chunk(mchunkptr p)
++#else
++static void do_check_free_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
++ mchunkptr next = chunk_at_offset(p, sz);
++
++ do_check_chunk(p);
++
++ /* Chunk must claim to be free ... */
++ assert(!inuse(p));
++ assert (!chunk_is_mmapped(p));
++
++ /* Unless a special marker, must have OK fields */
++ if ((unsigned long)(sz) >= MINSIZE)
++ {
++ assert((sz & MALLOC_ALIGN_MASK) == 0);
++ assert(aligned_OK(chunk2mem(p)));
++ /* ... matching footer field */
++ assert(next->prev_size == sz);
++ /* ... and is fully consolidated */
++ assert(prev_inuse(p));
++ assert (next == av->top || inuse(next));
++
++ /* ... and has minimally sane links */
++ assert(p->fd->bk == p);
++ assert(p->bk->fd == p);
++ }
++ else /* markers are always of size SIZE_SZ */
++ assert(sz == SIZE_SZ);
++}
++
++/*
++ Properties of inuse chunks
++*/
++
++INLINE
++#if __STD_C
++static void do_check_inuse_chunk(mchunkptr p)
++#else
++static void do_check_inuse_chunk(p) mchunkptr p;
++#endif
++{
++ mstate av = get_malloc_state();
++ mchunkptr next;
++ do_check_chunk(p);
++
++ if (chunk_is_mmapped(p))
++ return; /* mmapped chunks have no next/prev */
++
++ /* Check whether it claims to be in use ... */
++ assert(inuse(p));
++
++ next = next_chunk(p);
++
++ /* ... and is surrounded by OK chunks.
++ Since more things can be checked with free chunks than inuse ones,
++ if an inuse chunk borders them and debug is on, it's worth doing them.
++ */
++ if (!prev_inuse(p)) {
++ /* Note that we cannot even look at prev unless it is not inuse */
++ mchunkptr prv = prev_chunk(p);
++ assert(next_chunk(prv) == p);
++ do_check_free_chunk(prv);
++ }
++
++ if (next == av->top) {
++ assert(prev_inuse(next));
++ assert(chunksize(next) >= MINSIZE);
++ }
++ else if (!inuse(next))
++ do_check_free_chunk(next);
++}
++
++/*
++ Properties of chunks recycled from fastbins
++*/
++
++INLINE
++#if __STD_C
++static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
++#else
++static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
++#endif
++{
++ INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
++
++ do_check_inuse_chunk(p);
++
++ /* Legal size ... */
++ assert((sz & MALLOC_ALIGN_MASK) == 0);
++ assert((unsigned long)(sz) >= MINSIZE);
++ /* ... and alignment */
++ assert(aligned_OK(chunk2mem(p)));
++ /* chunk is less than MINSIZE more than request */
++ assert((long)(sz) - (long)(s) >= 0);
++ assert((long)(sz) - (long)(s + MINSIZE) < 0);
++}
++
++/*
++ Properties of nonrecycled chunks at the point they are malloced
++*/
++
++INLINE
++#if __STD_C
++static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
++#else
++static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
++#endif
++{
++ /* same as recycled case ... */
++ do_check_remalloced_chunk(p, s);
++
++ /*
++ ... plus, must obey implementation invariant that prev_inuse is
++ always true of any allocated chunk; i.e., that each allocated
++ chunk borders either a previously allocated and still in-use
++ chunk, or the base of its memory arena. This is ensured
++ by making all allocations from the the `lowest' part of any found
++ chunk. This does not necessarily hold however for chunks
++ recycled via fastbins.
++ */
++
++ assert(prev_inuse(p));
++}
++
++
++/*
++ Properties of malloc_state.
++
++ This may be useful for debugging malloc, as well as detecting user
++ programmer errors that somehow write into malloc_state.
++
++ If you are extending or experimenting with this malloc, you can
++ probably figure out how to hack this routine to print out or
++ display chunk addresses, sizes, bins, and other instrumentation.
++*/
++
++static void do_check_malloc_state()
++{
++ mstate av = get_malloc_state();
++ int i;
++ mchunkptr p;
++ mchunkptr q;
++ mbinptr b;
++ unsigned int binbit;
++ int empty;
++ unsigned int idx;
++ INTERNAL_SIZE_T size;
++ unsigned long total = 0;
++ int max_fast_bin;
++
++ /* internal size_t must be no wider than pointer type */
++ assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*));
++
++ /* alignment is a power of 2 */
++ assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0);
++
++ /* cannot run remaining checks until fully initialized */
++ if (av->top == 0 || av->top == initial_top(av))
++ return;
++
++ /* pagesize is a power of 2 */
++ assert((av->pagesize & (av->pagesize-1)) == 0);
++
++ /* properties of fastbins */
++
++ /* max_fast is in allowed range */
++ assert((av->max_fast & ~1) <= request2size(MAX_FAST_SIZE));
++
++ max_fast_bin = fastbin_index(av->max_fast);
++
++ for (i = 0; i < NFASTBINS; ++i) {
++ p = av->fastbins[i];
++
++ /* all bins past max_fast are empty */
++ if (i > max_fast_bin)
++ assert(p == 0);
++
++ while (p != 0) {
++ /* each chunk claims to be inuse */
++ do_check_inuse_chunk(p);
++ total += chunksize(p);
++ /* chunk belongs in this bin */
++ assert(fastbin_index(chunksize(p)) == i);
++ p = p->fd;
++ }
++ }
++
++ if (total != 0)
++ assert(have_fastchunks(av));
++ else if (!have_fastchunks(av))
++ assert(total == 0);
++
++ /* check normal bins */
++ for (i = 1; i < NBINS; ++i) {
++ b = bin_at(av,i);
++
++ /* binmap is accurate (except for bin 1 == unsorted_chunks) */
++ if (i >= 2) {
++ binbit = get_binmap(av,i);
++ empty = last(b) == b;
++ if (!binbit)
++ assert(empty);
++ else if (!empty)
++ assert(binbit);
++ }
++
++ for (p = last(b); p != b; p = p->bk) {
++ /* each chunk claims to be free */
++ do_check_free_chunk(p);
++ size = chunksize(p);
++ total += size;
++ if (i >= 2) {
++ /* chunk belongs in bin */
++ idx = bin_index(size);
++ assert(idx == i);
++ /* lists are sorted */
++ assert(p->bk == b ||
++ (unsigned long)chunksize(p->bk) >= (unsigned long)chunksize(p));
++ }
++ /* chunk is followed by a legal chain of inuse chunks */
++ for (q = next_chunk(p);
++ (q != av->top && inuse(q) &&
++ (unsigned long)(chunksize(q)) >= MINSIZE);
++ q = next_chunk(q))
++ do_check_inuse_chunk(q);
++ }
++ }
++
++ /* top chunk is OK */
++ check_chunk(av->top);
++
++ /* sanity checks for statistics */
++
++ assert(total <= (unsigned long)(av->max_total_mem));
++ assert(av->n_mmaps >= 0);
++ assert(av->n_mmaps <= av->n_mmaps_max);
++ assert(av->n_mmaps <= av->max_n_mmaps);
++
++ assert((unsigned long)(av->sbrked_mem) <=
++ (unsigned long)(av->max_sbrked_mem));
++
++ assert((unsigned long)(av->mmapped_mem) <=
++ (unsigned long)(av->max_mmapped_mem));
++
++ assert((unsigned long)(av->max_total_mem) >=
++ (unsigned long)(av->mmapped_mem) + (unsigned long)(av->sbrked_mem));
++}
++#endif
++
++
++/* ----------- Routines dealing with system allocation -------------- */
++
++/*
++ sYSTRIm is an inverse of sorts to sYSMALLOc. It gives memory back
++ to the system (via negative arguments to sbrk) if there is unused
++ memory at the `high' end of the malloc pool. It is called
++ automatically by free() when top space exceeds the trim
++ threshold. It is also called by the public malloc_trim routine. It
++ returns 1 if it actually released any memory, else 0.
++*/
++
++INLINE
++#if __STD_C
++static int sYSTRIm(size_t pad, mstate av)
++#else
++static int sYSTRIm(pad, av) size_t pad; mstate av;
++#endif
++{
++ long top_size; /* Amount of top-most memory */
++ long extra; /* Amount to release */
++ long released; /* Amount actually released */
++ char* current_brk; /* address returned by pre-check sbrk call */
++ char* new_brk; /* address returned by post-check sbrk call */
++ size_t pagesz;
++
++ pagesz = av->pagesize;
++ top_size = chunksize(av->top);
++
++ /* Release in pagesize units, keeping at least one page */
++ extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
++
++ if (extra > 0) {
++
++ /*
++ Only proceed if end of memory is where we last set it.
++ This avoids problems if there were foreign sbrk calls.
++ */
++ current_brk = (char*)(MORECORE(0));
++ if (current_brk == (char*)(av->top) + top_size) {
++
++ /*
++ Attempt to release memory. We ignore MORECORE return value,
++ and instead call again to find out where new end of memory is.
++ This avoids problems if first call releases less than we asked,
++ of if failure somehow altered brk value. (We could still
++ encounter problems if it altered brk in some very bad way,
++ but the only thing we can do is adjust anyway, which will cause
++ some downstream failure.)
++ */
++
++ MORECORE(-extra);
++ new_brk = (char*)(MORECORE(0));
++
++ if (new_brk != (char*)MORECORE_FAILURE) {
++ released = (long)(current_brk - new_brk);
++
++ if (released != 0) {
++ /* Success. Adjust top. */
++ av->sbrked_mem -= released;
++ set_head(av->top, (top_size - released) | PREV_INUSE);
++ check_malloc_state();
++ return 1;
++ }
++ }
++ }
++ }
++ return 0;
++}
++
++/*
++ ------------------------- malloc_consolidate -------------------------
++
++ malloc_consolidate is a specialized version of free() that tears
++ down chunks held in fastbins. Free itself cannot be used for this
++ purpose since, among other things, it might place chunks back onto
++ fastbins. So, instead, we need to use a minor variant of the same
++ code.
++
++ Also, because this routine needs to be called the first time through
++ malloc anyway, it turns out to be the perfect place to trigger
++ initialization code.
++*/
++
++INLINE
++#if __STD_C
++static void malloc_consolidate(mstate av)
++#else
++static void malloc_consolidate(av) mstate av;
++#endif
++{
++ mfastbinptr* fb; /* current fastbin being consolidated */
++ mfastbinptr* maxfb; /* last fastbin (for loop control) */
++ mchunkptr p; /* current chunk being consolidated */
++ mchunkptr nextp; /* next chunk to consolidate */
++ mchunkptr unsorted_bin; /* bin header */
++ mchunkptr first_unsorted; /* chunk to link to */
++
++ /* These have same use as in free() */
++ mchunkptr nextchunk;
++ INTERNAL_SIZE_T size;
++ INTERNAL_SIZE_T nextsize;
++ INTERNAL_SIZE_T prevsize;
++ int nextinuse;
++ mchunkptr bck;
++ mchunkptr fwd;
++
++ /*
++ If max_fast is 0, we know that av hasn't
++ yet been initialized, in which case do so below
++ */
++
++ if (av->max_fast != 0) {
++ clear_fastchunks(av);
++
++ unsorted_bin = unsorted_chunks(av);
++
++ /*
++ Remove each chunk from fast bin and consolidate it, placing it
++ then in unsorted bin. Among other reasons for doing this,
++ placing in unsorted bin avoids needing to calculate actual bins
++ until malloc is sure that chunks aren't immediately going to be
++ reused anyway.
++ */
++
++ maxfb = &(av->fastbins[fastbin_index(av->max_fast)]);
++ fb = &(av->fastbins[0]);
++ do {
++ if ( (p = *fb) != 0) {
++ *fb = 0;
++
++ do {
++ check_inuse_chunk(p);
++ nextp = p->fd;
++
++ /* Slightly streamlined version of consolidation code in free() */
++ size = p->size & ~PREV_INUSE;
++ nextchunk = chunk_at_offset(p, size);
++ nextsize = chunksize(nextchunk);
++
++ if (!prev_inuse(p)) {
++ prevsize = p->prev_size;
++ size += prevsize;
++ p = chunk_at_offset(p, -((long) prevsize));
++ unlink(p, bck, fwd);
++ }
++
++ if (nextchunk != av->top) {
++ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
++ set_head(nextchunk, nextsize);
++
++ if (!nextinuse) {
++ size += nextsize;
++ unlink(nextchunk, bck, fwd);
++ }
++
++ first_unsorted = unsorted_bin->fd;
++ unsorted_bin->fd = p;
++ first_unsorted->bk = p;
++
++ set_head(p, size | PREV_INUSE);
++ p->bk = unsorted_bin;
++ p->fd = first_unsorted;
++ set_foot(p, size);
++ }
++
++ else {
++ size += nextsize;
++ set_head(p, size | PREV_INUSE);
++ av->top = p;
++ }
++
++ } while ( (p = nextp) != 0);
++
++ }
++ } while (fb++ != maxfb);
++ }
++ else {
++ malloc_init_state(av);
++ check_malloc_state();
++ }
++}
++
++/*
++ ------------------------------ free ------------------------------
++*/
++
++INLINE
++#if __STD_C
++void fREe(Void_t* mem)
++#else
++void fREe(mem) Void_t* mem;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ mchunkptr p; /* chunk corresponding to mem */
++ INTERNAL_SIZE_T size; /* its size */
++ mfastbinptr* fb; /* associated fastbin */
++ mchunkptr nextchunk; /* next contiguous chunk */
++ INTERNAL_SIZE_T nextsize; /* its size */
++ int nextinuse; /* true if nextchunk is used */
++ INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
++ mchunkptr bck; /* misc temp for linking */
++ mchunkptr fwd; /* misc temp for linking */
++
++
++ /* free(0) has no effect */
++ if (mem != 0) {
++ p = mem2chunk(mem);
++ size = chunksize(p);
++
++ check_inuse_chunk(p);
++
++ /*
++ If eligible, place chunk on a fastbin so it can be found
++ and used quickly in malloc.
++ */
++
++ if ((unsigned long)(size) <= (unsigned long)(av->max_fast)
++
++#if TRIM_FASTBINS
++ /*
++ If TRIM_FASTBINS set, don't place chunks
++ bordering top into fastbins
++ */
++ && (chunk_at_offset(p, size) != av->top)
++#endif
++ ) {
++
++ set_fastchunks(av);
++ fb = &(av->fastbins[fastbin_index(size)]);
++ p->fd = *fb;
++ *fb = p;
++ }
++
++ /*
++ Consolidate other non-mmapped chunks as they arrive.
++ */
++
++ else if (!chunk_is_mmapped(p)) {
++ nextchunk = chunk_at_offset(p, size);
++ nextsize = chunksize(nextchunk);
++
++ /* consolidate backward */
++ if (!prev_inuse(p)) {
++ prevsize = p->prev_size;
++ size += prevsize;
++ p = chunk_at_offset(p, -((long) prevsize));
++ unlink(p, bck, fwd);
++ }
++
++ if (nextchunk != av->top) {
++ /* get and clear inuse bit */
++ nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
++ set_head(nextchunk, nextsize);
++
++ /* consolidate forward */
++ if (!nextinuse) {
++ unlink(nextchunk, bck, fwd);
++ size += nextsize;
++ }
++
++ /*
++ Place the chunk in unsorted chunk list. Chunks are
++ not placed into regular bins until after they have
++ been given one chance to be used in malloc.
++ */
++
++ bck = unsorted_chunks(av);
++ fwd = bck->fd;
++ p->bk = bck;
++ p->fd = fwd;
++ bck->fd = p;
++ fwd->bk = p;
++
++ set_head(p, size | PREV_INUSE);
++ set_foot(p, size);
++
++ check_free_chunk(p);
++ }
++
++ /*
++ If the chunk borders the current high end of memory,
++ consolidate into top
++ */
++
++ else {
++ size += nextsize;
++ set_head(p, size | PREV_INUSE);
++ av->top = p;
++ check_chunk(p);
++ }
++
++ /*
++ If freeing a large space, consolidate possibly-surrounding
++ chunks. Then, if the total unused topmost memory exceeds trim
++ threshold, ask malloc_trim to reduce top.
++
++ Unless max_fast is 0, we don't know if there are fastbins
++ bordering top, so we cannot tell for sure whether threshold
++ has been reached unless fastbins are consolidated. But we
++ don't want to consolidate on each free. As a compromise,
++ consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
++ is reached.
++ */
++
++ if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
++ if (have_fastchunks(av))
++ malloc_consolidate(av);
++
++#ifndef MORECORE_CANNOT_TRIM
++ if ((unsigned long)(chunksize(av->top)) >=
++ (unsigned long)(av->trim_threshold))
++ sYSTRIm(av->top_pad, av);
++#endif
++ }
++
++ }
++ /*
++ If the chunk was allocated via mmap, release via munmap()
++ Note that if HAVE_MMAP is false but chunk_is_mmapped is
++ true, then user must have overwritten memory. There's nothing
++ we can do to catch this error unless DEBUG is set, in which case
++ check_inuse_chunk (above) will have triggered error.
++ */
++
++ else {
++#if HAVE_MMAP
++ int ret;
++ INTERNAL_SIZE_T offset = p->prev_size;
++ av->n_mmaps--;
++ av->mmapped_mem -= (size + offset);
++ ret = munmap((char*)p - offset, size + offset);
++ /* munmap returns non-zero on failure */
++ assert(ret == 0);
++#endif
++ }
++ }
++}
++
++/*
++ sysmalloc handles malloc cases requiring more memory from the system.
++ On entry, it is assumed that av->top does not have enough
++ space to service request for nb bytes, thus requiring that av->top
++ be extended or replaced.
++*/
++
++INLINE
++#if __STD_C
++static Void_t* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
++#else
++static Void_t* sYSMALLOc(nb, av) INTERNAL_SIZE_T nb; mstate av;
++#endif
++{
++ mchunkptr old_top; /* incoming value of av->top */
++ INTERNAL_SIZE_T old_size; /* its size */
++ char* old_end; /* its end address */
++
++ long size; /* arg to first MORECORE or mmap call */
++ char* brk; /* return value from MORECORE */
++
++ long correction; /* arg to 2nd MORECORE call */
++ char* snd_brk; /* 2nd return val */
++
++ INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
++ INTERNAL_SIZE_T end_misalign; /* partial page left at end of new space */
++ char* aligned_brk; /* aligned offset into brk */
++
++ mchunkptr p; /* the allocated/returned chunk */
++ mchunkptr remainder; /* remainder from allocation */
++ unsigned long remainder_size; /* its size */
++
++ unsigned long sum; /* for updating stats */
++
++ size_t pagemask = av->pagesize - 1;
++
++
++#if HAVE_MMAP
++
++ /*
++ If have mmap, and the request size meets the mmap threshold, and
++ the system supports mmap, and there are few enough currently
++ allocated mmapped regions, try to directly map this request
++ rather than expanding top.
++ */
++
++ if ((unsigned long)(nb) >= (unsigned long)(av->mmap_threshold) &&
++ (av->n_mmaps < av->n_mmaps_max)) {
++
++ char* mm; /* return value from mmap call*/
++
++ /*
++ Round up size to nearest page. For mmapped chunks, the overhead
++ is one SIZE_SZ unit larger than for normal chunks, because there
++ is no following chunk whose prev_size field could be used.
++ */
++ size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
++
++ /* Don't try if size wraps around 0 */
++ if ((unsigned long)(size) > (unsigned long)(nb)) {
++
++ mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
++
++ if (mm != (char*)(MORECORE_FAILURE)) {
++
++ /*
++ The offset to the start of the mmapped region is stored
++ in the prev_size field of the chunk. This allows us to adjust
++ returned start address to meet alignment requirements here
++ and in memalign(), and still be able to compute proper
++ address argument for later munmap in free() and realloc().
++ */
++
++ front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK;
++ if (front_misalign > 0) {
++ correction = MALLOC_ALIGNMENT - front_misalign;
++ p = (mchunkptr)(mm + correction);
++ p->prev_size = correction;
++ set_head(p, (size - correction) |IS_MMAPPED);
++ }
++ else {
++ p = (mchunkptr)mm;
++ p->prev_size = 0;
++ set_head(p, size|IS_MMAPPED);
++ }
++
++ /* update statistics */
++
++ if (++av->n_mmaps > av->max_n_mmaps)
++ av->max_n_mmaps = av->n_mmaps;
++
++ sum = av->mmapped_mem += size;
++ if (sum > (unsigned long)(av->max_mmapped_mem))
++ av->max_mmapped_mem = sum;
++ sum += av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ check_chunk(p);
++
++ return chunk2mem(p);
++ }
++ }
++ }
++#endif
++
++ /* Record incoming configuration of top */
++
++ old_top = av->top;
++ old_size = chunksize(old_top);
++ old_end = (char*)(chunk_at_offset(old_top, old_size));
++
++ brk = snd_brk = (char*)(MORECORE_FAILURE);
++
++ /*
++ If not the first time through, we require old_size to be
++ at least MINSIZE and to have prev_inuse set.
++ */
++
++ assert((old_top == initial_top(av) && old_size == 0) ||
++ ((unsigned long) (old_size) >= MINSIZE &&
++ prev_inuse(old_top)));
++
++ /* Precondition: not enough current space to satisfy nb request */
++ assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
++
++ /* Precondition: all fastbins are consolidated */
++ assert(!have_fastchunks(av));
++
++
++ /* Request enough space for nb + pad + overhead */
++
++ size = nb + av->top_pad + MINSIZE;
++
++ /*
++ If contiguous, we can subtract out existing space that we hope to
++ combine with new space. We add it back later only if
++ we don't actually get contiguous space.
++ */
++
++ if (contiguous(av))
++ size -= old_size;
++
++ /*
++ Round to a multiple of page size.
++ If MORECORE is not contiguous, this ensures that we only call it
++ with whole-page arguments. And if MORECORE is contiguous and
++ this is not first time through, this preserves page-alignment of
++ previous calls. Otherwise, we correct to page-align below.
++ */
++
++ size = (size + pagemask) & ~pagemask;
++
++ /*
++ Don't try to call MORECORE if argument is so big as to appear
++ negative. Note that since mmap takes size_t arg, it may succeed
++ below even if we cannot call MORECORE.
++ */
++
++ if (size > 0)
++ brk = (char*)(MORECORE(size));
++
++ /*
++ If have mmap, try using it as a backup when MORECORE fails or
++ cannot be used. This is worth doing on systems that have "holes" in
++ address space, so sbrk cannot extend to give contiguous space, but
++ space is available elsewhere. Note that we ignore mmap max count
++ and threshold limits, since the space will not be used as a
++ segregated mmap region.
++ */
++
++#if HAVE_MMAP
++ if (brk == (char*)(MORECORE_FAILURE)) {
++
++ /* Cannot merge with old top, so add its size back in */
++ if (contiguous(av))
++ size = (size + old_size + pagemask) & ~pagemask;
++
++ /* If we are relying on mmap as backup, then use larger units */
++ if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
++ size = MMAP_AS_MORECORE_SIZE;
++
++ /* Don't try if size wraps around 0 */
++ if ((unsigned long)(size) > (unsigned long)(nb)) {
++
++ brk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE));
++
++ if (brk != (char*)(MORECORE_FAILURE)) {
++
++ /* We do not need, and cannot use, another sbrk call to find end */
++ snd_brk = brk + size;
++
++ /*
++ Record that we no longer have a contiguous sbrk region.
++ After the first time mmap is used as backup, we do not
++ ever rely on contiguous space since this could incorrectly
++ bridge regions.
++ */
++ set_noncontiguous(av);
++ }
++ }
++ }
++#endif
++
++ if (brk != (char*)(MORECORE_FAILURE)) {
++ av->sbrked_mem += size;
++
++ /*
++ If MORECORE extends previous space, we can likewise extend top size.
++ */
++
++ if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE)) {
++ set_head(old_top, (size + old_size) | PREV_INUSE);
++ }
++
++ /*
++ Otherwise, make adjustments:
++
++ * If the first time through or noncontiguous, we need to call sbrk
++ just to find out where the end of memory lies.
++
++ * We need to ensure that all returned chunks from malloc will meet
++ MALLOC_ALIGNMENT
++
++ * If there was an intervening foreign sbrk, we need to adjust sbrk
++ request size to account for fact that we will not be able to
++ combine new space with existing space in old_top.
++
++ * Almost all systems internally allocate whole pages at a time, in
++ which case we might as well use the whole last page of request.
++ So we allocate enough more memory to hit a page boundary now,
++ which in turn causes future contiguous calls to page-align.
++ */
++
++ else {
++ front_misalign = 0;
++ end_misalign = 0;
++ correction = 0;
++ aligned_brk = brk;
++
++ /* handle contiguous cases */
++ if (contiguous(av)) {
++
++ /* Guarantee alignment of first new chunk made from this space */
++
++ front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
++ if (front_misalign > 0) {
++
++ /*
++ Skip over some bytes to arrive at an aligned position.
++ We don't need to specially mark these wasted front bytes.
++ They will never be accessed anyway because
++ prev_inuse of av->top (and any chunk created from its start)
++ is always true after initialization.
++ */
++
++ correction = MALLOC_ALIGNMENT - front_misalign;
++ aligned_brk += correction;
++ }
++
++ /*
++ If this isn't adjacent to existing space, then we will not
++ be able to merge with old_top space, so must add to 2nd request.
++ */
++
++ correction += old_size;
++
++ /* Extend the end address to hit a page boundary */
++ end_misalign = (INTERNAL_SIZE_T)(brk + size + correction);
++ correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
++
++ assert(correction >= 0);
++ snd_brk = (char*)(MORECORE(correction));
++
++ /*
++ If can't allocate correction, try to at least find out current
++ brk. It might be enough to proceed without failing.
++
++ Note that if second sbrk did NOT fail, we assume that space
++ is contiguous with first sbrk. This is a safe assumption unless
++ program is multithreaded but doesn't use locks and a foreign sbrk
++ occurred between our first and second calls.
++ */
++
++ if (snd_brk == (char*)(MORECORE_FAILURE)) {
++ correction = 0;
++ snd_brk = (char*)(MORECORE(0));
++ }
++ }
++
++ /* handle non-contiguous cases */
++ else {
++ /* MORECORE/mmap must correctly align */
++ assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
++
++ /* Find out current end of memory */
++ if (snd_brk == (char*)(MORECORE_FAILURE)) {
++ snd_brk = (char*)(MORECORE(0));
++ }
++ }
++
++ /* Adjust top based on results of second sbrk */
++ if (snd_brk != (char*)(MORECORE_FAILURE)) {
++ av->top = (mchunkptr)aligned_brk;
++ set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
++ av->sbrked_mem += correction;
++
++ /*
++ If not the first time through, we either have a
++ gap due to foreign sbrk or a non-contiguous region. Insert a
++ double fencepost at old_top to prevent consolidation with space
++ we don't own. These fenceposts are artificial chunks that are
++ marked as inuse and are in any case too small to use. We need
++ two to make sizes and alignments work out.
++ */
++
++ if (old_size != 0) {
++ /*
++ Shrink old_top to insert fenceposts, keeping size a
++ multiple of MALLOC_ALIGNMENT. We know there is at least
++ enough space in old_top to do this.
++ */
++ old_size = (old_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
++ set_head(old_top, old_size | PREV_INUSE);
++
++ /*
++ Note that the following assignments completely overwrite
++ old_top when old_size was previously MINSIZE. This is
++ intentional. We need the fencepost, even if old_top otherwise gets
++ lost.
++ */
++ chunk_at_offset(old_top, old_size )->size =
++ SIZE_SZ|PREV_INUSE;
++
++ chunk_at_offset(old_top, old_size + SIZE_SZ)->size =
++ SIZE_SZ|PREV_INUSE;
++
++ /* If possible, release the rest. */
++ if (old_size >= MINSIZE) {
++ fREe(chunk2mem(old_top));
++ }
++
++ }
++ }
++ }
++
++ /* Update statistics */
++ sum = av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_sbrked_mem))
++ av->max_sbrked_mem = sum;
++
++ sum += av->mmapped_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ check_malloc_state();
++
++ /* finally, do the allocation */
++ p = av->top;
++ size = chunksize(p);
++
++ /* check that one of the above allocation paths succeeded */
++ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(p, nb);
++ av->top = remainder;
++ set_head(p, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ check_malloced_chunk(p, nb);
++ return chunk2mem(p);
++ }
++ }
++
++ /* catch all failure paths */
++ MALLOC_FAILURE_ACTION;
++ return 0;
++}
++
++
++/*
++ ------------------------------ malloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* mALLOc(size_t bytes)
++#else
++ Void_t* mALLOc(bytes) size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T nb; /* normalized request size */
++ unsigned int idx; /* associated bin index */
++ mbinptr bin; /* associated bin */
++ mfastbinptr* fb; /* associated fastbin */
++
++ mchunkptr victim; /* inspected/selected chunk */
++ INTERNAL_SIZE_T size; /* its size */
++ int victim_index; /* its bin index */
++
++ mchunkptr remainder; /* remainder from a split */
++ unsigned long remainder_size; /* its size */
++
++ unsigned int block; /* bit map traverser */
++ unsigned int bit; /* bit map traverser */
++ unsigned int map; /* current word of binmap */
++
++ mchunkptr fwd; /* misc temp for linking */
++ mchunkptr bck; /* misc temp for linking */
++
++ /*
++ Convert request size to internal form by adding SIZE_SZ bytes
++ overhead plus possibly more to obtain necessary alignment and/or
++ to obtain a size of at least MINSIZE, the smallest allocatable
++ size. Also, checked_request2size traps (returning 0) request sizes
++ that are so large that they wrap around zero when padded and
++ aligned.
++ */
++
++ checked_request2size(bytes, nb);
++
++ /*
++ If the size qualifies as a fastbin, first check corresponding bin.
++ This code is safe to execute even if av is not yet initialized, so we
++ can try it without checking, which saves some time on this fast path.
++ */
++
++ if ((unsigned long)(nb) <= (unsigned long)(av->max_fast)) {
++ fb = &(av->fastbins[(fastbin_index(nb))]);
++ if ( (victim = *fb) != 0) {
++ *fb = victim->fd;
++ check_remalloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++
++ /*
++ If a small request, check regular bin. Since these "smallbins"
++ hold one size each, no searching within bins is necessary.
++ (For a large request, we need to wait until unsorted chunks are
++ processed to find best fit. But for small ones, fits are exact
++ anyway, so we can check now, which is faster.)
++ */
++
++ if (in_smallbin_range(nb)) {
++ idx = smallbin_index(nb);
++ bin = bin_at(av,idx);
++
++ if ( (victim = last(bin)) != bin) {
++ if (victim == 0) /* initialization check */
++ malloc_consolidate(av);
++ else {
++ bck = victim->bk;
++ set_inuse_bit_at_offset(victim, nb);
++ bin->bk = bck;
++ bck->fd = bin;
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ /*
++ If this is a large request, consolidate fastbins before continuing.
++ While it might look excessive to kill all fastbins before
++ even seeing if there is space available, this avoids
++ fragmentation problems normally associated with fastbins.
++ Also, in practice, programs tend to have runs of either small or
++ large requests, but less often mixtures, so consolidation is not
++ invoked all that often in most programs. And the programs that
++ it is called frequently in otherwise tend to fragment.
++ */
++
++ else {
++ idx = largebin_index(nb);
++ if (have_fastchunks(av))
++ malloc_consolidate(av);
++ }
++
++ /*
++ Process recently freed or remaindered chunks, taking one only if
++ it is exact fit, or, if this a small request, the chunk is remainder from
++ the most recent non-exact fit. Place other traversed chunks in
++ bins. Note that this step is the only place in any routine where
++ chunks are placed in bins.
++
++ The outer loop here is needed because we might not realize until
++ near the end of malloc that we should have consolidated, so must
++ do so and retry. This happens at most once, and only when we would
++ otherwise need to expand memory to service a "small" request.
++ */
++
++ for(;;) {
++
++ while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
++ bck = victim->bk;
++ size = chunksize(victim);
++
++ /*
++ If a small request, try to use last remainder if it is the
++ only chunk in unsorted bin. This helps promote locality for
++ runs of consecutive small requests. This is the only
++ exception to best-fit, and applies only when there is
++ no exact fit for a small chunk.
++ */
++
++ if (in_smallbin_range(nb) &&
++ bck == unsorted_chunks(av) &&
++ victim == av->last_remainder &&
++ (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
++
++ /* split and reattach remainder */
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(victim, nb);
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ av->last_remainder = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* remove from unsorted list */
++ unsorted_chunks(av)->bk = bck;
++ bck->fd = unsorted_chunks(av);
++
++ /* Take now instead of binning if exact fit */
++
++ if (size == nb) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* place chunk in bin */
++
++ if (in_smallbin_range(size)) {
++ victim_index = smallbin_index(size);
++ bck = bin_at(av, victim_index);
++ fwd = bck->fd;
++ }
++ else {
++ victim_index = largebin_index(size);
++ bck = bin_at(av, victim_index);
++ fwd = bck->fd;
++
++ /* maintain large bins in sorted order */
++ if (fwd != bck) {
++ size |= PREV_INUSE; /* Or with inuse bit to speed comparisons */
++ /* if smaller than smallest, bypass loop below */
++ if ((unsigned long)(size) <= (unsigned long)(bck->bk->size)) {
++ fwd = bck;
++ bck = bck->bk;
++ }
++ else {
++ while ((unsigned long)(size) < (unsigned long)(fwd->size))
++ fwd = fwd->fd;
++ bck = fwd->bk;
++ }
++ }
++ }
++
++ mark_bin(av, victim_index);
++ victim->bk = bck;
++ victim->fd = fwd;
++ fwd->bk = victim;
++ bck->fd = victim;
++ }
++
++ /*
++ If a large request, scan through the chunks of current bin in
++ sorted order to find smallest that fits. This is the only step
++ where an unbounded number of chunks might be scanned without doing
++ anything useful with them. However the lists tend to be short.
++ */
++
++ if (!in_smallbin_range(nb)) {
++ bin = bin_at(av, idx);
++
++ /* skip scan if empty or largest chunk is too small */
++ if ((victim = last(bin)) != bin &&
++ (unsigned long)(first(bin)->size) >= (unsigned long)(nb)) {
++
++ while (((unsigned long)(size = chunksize(victim)) <
++ (unsigned long)(nb)))
++ victim = victim->bk;
++
++ remainder_size = size - nb;
++ unlink(victim, bck, fwd);
++
++ /* Exhaust */
++ if (remainder_size < MINSIZE) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ /* Split */
++ else {
++ remainder = chunk_at_offset(victim, nb);
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ /*
++ Search for a chunk by scanning bins, starting with next largest
++ bin. This search is strictly by best-fit; i.e., the smallest
++ (with ties going to approximately the least recently used) chunk
++ that fits is selected.
++
++ The bitmap avoids needing to check that most blocks are nonempty.
++ The particular case of skipping all bins during warm-up phases
++ when no chunks have been returned yet is faster than it might look.
++ */
++
++ ++idx;
++ bin = bin_at(av,idx);
++ block = idx2block(idx);
++ map = av->binmap[block];
++ bit = idx2bit(idx);
++
++ for (;;) {
++
++ /* Skip rest of block if there are no more set bits in this block. */
++ if (bit > map || bit == 0) {
++ do {
++ if (++block >= BINMAPSIZE) /* out of bins */
++ goto use_top;
++ } while ( (map = av->binmap[block]) == 0);
++
++ bin = bin_at(av, (block << BINMAPSHIFT));
++ bit = 1;
++ }
++
++ /* Advance to bin with set bit. There must be one. */
++ while ((bit & map) == 0) {
++ bin = next_bin(bin);
++ bit <<= 1;
++ assert(bit != 0);
++ }
++
++ /* Inspect the bin. It is likely to be non-empty */
++ victim = last(bin);
++
++ /* If a false alarm (empty bin), clear the bit. */
++ if (victim == bin) {
++ av->binmap[block] = map &= ~bit; /* Write through */
++ bin = next_bin(bin);
++ bit <<= 1;
++ }
++
++ else {
++ size = chunksize(victim);
++
++ /* We know the first chunk in this bin is big enough to use. */
++ assert((unsigned long)(size) >= (unsigned long)(nb));
++
++ remainder_size = size - nb;
++
++ /* unlink */
++ bck = victim->bk;
++ bin->bk = bck;
++ bck->fd = bin;
++
++ /* Exhaust */
++ if (remainder_size < MINSIZE) {
++ set_inuse_bit_at_offset(victim, size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /* Split */
++ else {
++ remainder = chunk_at_offset(victim, nb);
++
++ unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
++ remainder->bk = remainder->fd = unsorted_chunks(av);
++ /* advertise as last remainder */
++ if (in_smallbin_range(nb))
++ av->last_remainder = remainder;
++
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_foot(remainder, remainder_size);
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++ }
++ }
++
++ use_top:
++ /*
++ If large enough, split off the chunk bordering the end of memory
++ (held in av->top). Note that this is in accord with the best-fit
++ search rule. In effect, av->top is treated as larger (and thus
++ less well fitting) than any other available chunk since it can
++ be extended to be as large as necessary (up to system
++ limitations).
++
++ We require that av->top always exists (i.e., has size >=
++ MINSIZE) after initialization, so if it would otherwise be
++ exhuasted by current request, it is replenished. (The main
++ reason for ensuring it exists is that we may need MINSIZE space
++ to put in fenceposts in sysmalloc.)
++ */
++
++ victim = av->top;
++ size = chunksize(victim);
++
++ if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(victim, nb);
++ av->top = remainder;
++ set_head(victim, nb | PREV_INUSE);
++ set_head(remainder, remainder_size | PREV_INUSE);
++
++ check_malloced_chunk(victim, nb);
++ return chunk2mem(victim);
++ }
++
++ /*
++ If there is space available in fastbins, consolidate and retry,
++ to possibly avoid expanding memory. This can occur only if nb is
++ in smallbin range so we didn't consolidate upon entry.
++ */
++
++ else if (have_fastchunks(av)) {
++ assert(in_smallbin_range(nb));
++ malloc_consolidate(av);
++ idx = smallbin_index(nb); /* restore original bin index */
++ }
++
++ /*
++ Otherwise, relay to handle system-dependent cases
++ */
++ else
++ return sYSMALLOc(nb, av);
++ }
++}
++
++/*
++ ------------------------------ realloc ------------------------------
++*/
++
++
++INLINE
++#if __STD_C
++Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
++#else
++Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++
++ INTERNAL_SIZE_T nb; /* padded request size */
++
++ mchunkptr oldp; /* chunk corresponding to oldmem */
++ INTERNAL_SIZE_T oldsize; /* its size */
++
++ mchunkptr newp; /* chunk to return */
++ INTERNAL_SIZE_T newsize; /* its size */
++ Void_t* newmem; /* corresponding user mem */
++
++ mchunkptr next; /* next contiguous chunk after oldp */
++
++ mchunkptr remainder; /* extra space at end of newp */
++ unsigned long remainder_size; /* its size */
++
++ mchunkptr bck; /* misc temp for linking */
++ mchunkptr fwd; /* misc temp for linking */
++
++ unsigned long copysize; /* bytes to copy */
++ unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
++ INTERNAL_SIZE_T* s; /* copy source */
++ INTERNAL_SIZE_T* d; /* copy destination */
++
++
++#ifdef REALLOC_ZERO_BYTES_FREES
++ if (bytes == 0) {
++ fREe(oldmem);
++ return 0;
++ }
++#endif
++
++ /* realloc of null is supposed to be same as malloc */
++ if (oldmem == 0) return mALLOc(bytes);
++
++ checked_request2size(bytes, nb);
++
++ oldp = mem2chunk(oldmem);
++ oldsize = chunksize(oldp);
++
++ check_inuse_chunk(oldp);
++
++ if (!chunk_is_mmapped(oldp)) {
++
++ if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
++ /* already big enough; split below */
++ newp = oldp;
++ newsize = oldsize;
++ }
++
++ else {
++ next = chunk_at_offset(oldp, oldsize);
++
++ /* Try to expand forward into top */
++ if (next == av->top &&
++ (unsigned long)(newsize = oldsize + chunksize(next)) >=
++ (unsigned long)(nb + MINSIZE)) {
++ set_head_size(oldp, nb);
++ av->top = chunk_at_offset(oldp, nb);
++ set_head(av->top, (newsize - nb) | PREV_INUSE);
++ return chunk2mem(oldp);
++ }
++
++ /* Try to expand forward into next chunk; split off remainder below */
++ else if (next != av->top &&
++ !inuse(next) &&
++ (unsigned long)(newsize = oldsize + chunksize(next)) >=
++ (unsigned long)(nb)) {
++ newp = oldp;
++ unlink(next, bck, fwd);
++ }
++
++ /* allocate, copy, free */
++ else {
++ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
++ if (newmem == 0)
++ return 0; /* propagate failure */
++
++ newp = mem2chunk(newmem);
++ newsize = chunksize(newp);
++
++ /*
++ Avoid copy if newp is next chunk after oldp.
++ */
++ if (newp == next) {
++ newsize += oldsize;
++ newp = oldp;
++ }
++ else {
++ /*
++ Unroll copy of <= 36 bytes (72 if 8byte sizes)
++ We know that contents have an odd number of
++ INTERNAL_SIZE_T-sized words; minimally 3.
++ */
++
++ copysize = oldsize - SIZE_SZ;
++ s = (INTERNAL_SIZE_T*)(oldmem);
++ d = (INTERNAL_SIZE_T*)(newmem);
++ ncopies = copysize / sizeof(INTERNAL_SIZE_T);
++ assert(ncopies >= 3);
++
++ if (ncopies > 9)
++ MALLOC_COPY(d, s, copysize);
++
++ else {
++ *(d+0) = *(s+0);
++ *(d+1) = *(s+1);
++ *(d+2) = *(s+2);
++ if (ncopies > 4) {
++ *(d+3) = *(s+3);
++ *(d+4) = *(s+4);
++ if (ncopies > 6) {
++ *(d+5) = *(s+5);
++ *(d+6) = *(s+6);
++ if (ncopies > 8) {
++ *(d+7) = *(s+7);
++ *(d+8) = *(s+8);
++ }
++ }
++ }
++ }
++
++ fREe(oldmem);
++ check_inuse_chunk(newp);
++ return chunk2mem(newp);
++ }
++ }
++ }
++
++ /* If possible, free extra space in old or extended chunk */
++
++ assert((unsigned long)(newsize) >= (unsigned long)(nb));
++
++ remainder_size = newsize - nb;
++
++ if (remainder_size < MINSIZE) { /* not enough extra to split off */
++ set_head_size(newp, newsize);
++ set_inuse_bit_at_offset(newp, newsize);
++ }
++ else { /* split remainder */
++ remainder = chunk_at_offset(newp, nb);
++ set_head_size(newp, nb);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ /* Mark remainder as inuse so free() won't complain */
++ set_inuse_bit_at_offset(remainder, remainder_size);
++ fREe(chunk2mem(remainder));
++ }
++
++ check_inuse_chunk(newp);
++ return chunk2mem(newp);
++ }
++
++ /*
++ Handle mmap cases
++ */
++
++ else {
++#if HAVE_MMAP
++
++#if HAVE_MREMAP
++ INTERNAL_SIZE_T offset = oldp->prev_size;
++ size_t pagemask = av->pagesize - 1;
++ char *cp;
++ unsigned long sum;
++
++ /* Note the extra SIZE_SZ overhead */
++ newsize = (nb + offset + SIZE_SZ + pagemask) & ~pagemask;
++
++ /* don't need to remap if still within same page */
++ if (oldsize == newsize - offset)
++ return oldmem;
++
++ cp = (char*)mremap((char*)oldp - offset, oldsize + offset, newsize, 1);
++
++ if (cp != (char*)MORECORE_FAILURE) {
++
++ newp = (mchunkptr)(cp + offset);
++ set_head(newp, (newsize - offset)|IS_MMAPPED);
++
++ assert(aligned_OK(chunk2mem(newp)));
++ assert((newp->prev_size == offset));
++
++ /* update statistics */
++ sum = av->mmapped_mem += newsize - oldsize;
++ if (sum > (unsigned long)(av->max_mmapped_mem))
++ av->max_mmapped_mem = sum;
++ sum += av->sbrked_mem;
++ if (sum > (unsigned long)(av->max_total_mem))
++ av->max_total_mem = sum;
++
++ return chunk2mem(newp);
++ }
++#endif
++
++ /* Note the extra SIZE_SZ overhead. */
++ if ((unsigned long)(oldsize) >= (unsigned long)(nb + SIZE_SZ))
++ newmem = oldmem; /* do nothing */
++ else {
++ /* Must alloc, copy, free. */
++ newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
++ if (newmem != 0) {
++ MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
++ fREe(oldmem);
++ }
++ }
++ return newmem;
++
++#else
++ /* If !HAVE_MMAP, but chunk_is_mmapped, user must have overwritten mem */
++ check_malloc_state();
++ MALLOC_FAILURE_ACTION;
++ return 0;
++#endif
++ }
++}
++
++/*
++ ------------------------------ memalign ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* mEMALIGn(size_t alignment, size_t bytes)
++#else
++Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
++#endif
++{
++ INTERNAL_SIZE_T nb; /* padded request size */
++ char* m; /* memory returned by malloc call */
++ mchunkptr p; /* corresponding chunk */
++ char* brk; /* alignment point within p */
++ mchunkptr newp; /* chunk to return */
++ INTERNAL_SIZE_T newsize; /* its size */
++ INTERNAL_SIZE_T leadsize; /* leading space before alignment point */
++ mchunkptr remainder; /* spare room at end to split off */
++ unsigned long remainder_size; /* its size */
++ INTERNAL_SIZE_T size;
++
++ /* If need less alignment than we give anyway, just relay to malloc */
++
++ if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
++
++ /* Otherwise, ensure that it is at least a minimum chunk size */
++
++ if (alignment < MINSIZE) alignment = MINSIZE;
++
++ /* Make sure alignment is power of 2 (in case MINSIZE is not). */
++ if ((alignment & (alignment - 1)) != 0) {
++ size_t a = MALLOC_ALIGNMENT * 2;
++ while ((unsigned long)a < (unsigned long)alignment) a <<= 1;
++ alignment = a;
++ }
++
++ checked_request2size(bytes, nb);
++
++ /*
++ Strategy: find a spot within that chunk that meets the alignment
++ request, and then possibly free the leading and trailing space.
++ */
++
++
++ /* Call malloc with worst case padding to hit alignment. */
++
++ m = (char*)(mALLOc(nb + alignment + MINSIZE));
++
++ if (m == 0) return 0; /* propagate failure */
++
++ p = mem2chunk(m);
++
++ if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
++
++ /*
++ Find an aligned spot inside chunk. Since we need to give back
++ leading space in a chunk of at least MINSIZE, if the first
++ calculation places us at a spot with less than MINSIZE leader,
++ we can move to the next aligned spot -- we've allocated enough
++ total room so that this is always possible.
++ */
++
++ brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) &
++ -((signed long) alignment));
++ if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
++ brk += alignment;
++
++ newp = (mchunkptr)brk;
++ leadsize = brk - (char*)(p);
++ newsize = chunksize(p) - leadsize;
++
++ /* For mmapped chunks, just adjust offset */
++ if (chunk_is_mmapped(p)) {
++ newp->prev_size = p->prev_size + leadsize;
++ set_head(newp, newsize|IS_MMAPPED);
++ return chunk2mem(newp);
++ }
++
++ /* Otherwise, give back leader, use the rest */
++ set_head(newp, newsize | PREV_INUSE);
++ set_inuse_bit_at_offset(newp, newsize);
++ set_head_size(p, leadsize);
++ fREe(chunk2mem(p));
++ p = newp;
++
++ assert (newsize >= nb &&
++ (((unsigned long)(chunk2mem(p))) % alignment) == 0);
++ }
++
++ /* Also give back spare room at the end */
++ if (!chunk_is_mmapped(p)) {
++ size = chunksize(p);
++ if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
++ remainder_size = size - nb;
++ remainder = chunk_at_offset(p, nb);
++ set_head(remainder, remainder_size | PREV_INUSE);
++ set_head_size(p, nb);
++ fREe(chunk2mem(remainder));
++ }
++ }
++
++ check_inuse_chunk(p);
++ return chunk2mem(p);
++}
++
++/*
++ ------------------------------ calloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* cALLOc(size_t n_elements, size_t elem_size)
++#else
++Void_t* cALLOc(n_elements, elem_size) size_t n_elements; size_t elem_size;
++#endif
++{
++ mchunkptr p;
++ unsigned long clearsize;
++ unsigned long nclears;
++ INTERNAL_SIZE_T* d;
++
++ Void_t* mem = mALLOc(n_elements * elem_size);
++
++ if (mem != 0) {
++ p = mem2chunk(mem);
++
++ if (!chunk_is_mmapped(p))
++ {
++ /*
++ Unroll clear of <= 36 bytes (72 if 8byte sizes)
++ We know that contents have an odd number of
++ INTERNAL_SIZE_T-sized words; minimally 3.
++ */
++
++ d = (INTERNAL_SIZE_T*)mem;
++ clearsize = chunksize(p) - SIZE_SZ;
++ nclears = clearsize / sizeof(INTERNAL_SIZE_T);
++ assert(nclears >= 3);
++
++ if (nclears > 9)
++ MALLOC_ZERO(d, clearsize);
++
++ else {
++ *(d+0) = 0;
++ *(d+1) = 0;
++ *(d+2) = 0;
++ if (nclears > 4) {
++ *(d+3) = 0;
++ *(d+4) = 0;
++ if (nclears > 6) {
++ *(d+5) = 0;
++ *(d+6) = 0;
++ if (nclears > 8) {
++ *(d+7) = 0;
++ *(d+8) = 0;
++ }
++ }
++ }
++ }
++ }
++#if ! MMAP_CLEARS
++ else
++ {
++ d = (INTERNAL_SIZE_T*)mem;
++ clearsize = chunksize(p) - 2 * SIZE_SZ;
++ MALLOC_ZERO(d, clearsize);
++ }
++#endif
++ }
++ return mem;
++}
++
++/*
++ ------------------------------ cfree ------------------------------
++*/
++
++INLINE
++#if __STD_C
++void cFREe(Void_t *mem)
++#else
++void cFREe(mem) Void_t *mem;
++#endif
++{
++ fREe(mem);
++}
++
++/*
++ ------------------------------ ialloc ------------------------------
++ ialloc 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
++*/
++
++
++INLINE
++#if __STD_C
++static Void_t** iALLOc(size_t n_elements,
++ size_t* sizes,
++ int opts,
++ Void_t* chunks[])
++#else
++static Void_t** iALLOc(n_elements, sizes, opts, chunks) size_t n_elements; size_t* sizes; int opts; Void_t* chunks[];
++#endif
++{
++ mstate av = get_malloc_state();
++ INTERNAL_SIZE_T element_size; /* chunksize of each element, if all same */
++ INTERNAL_SIZE_T contents_size; /* total size of elements */
++ INTERNAL_SIZE_T array_size; /* request size of pointer array */
++ Void_t* mem; /* malloced aggregate space */
++ mchunkptr p; /* corresponding chunk */
++ INTERNAL_SIZE_T remainder_size; /* remaining bytes while splitting */
++ Void_t** marray; /* either "chunks" or malloced ptr array */
++ mchunkptr array_chunk; /* chunk for malloced ptr array */
++ int mmx; /* to disable mmap */
++ INTERNAL_SIZE_T size;
++ size_t i;
++
++ /* Ensure initialization/consolidation */
++ if (have_fastchunks(av)) malloc_consolidate(av);
++
++ /* 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_t**) mALLOc(0);
++ marray = 0;
++ array_size = request2size(n_elements * (sizeof(Void_t*)));
++ }
++
++ /* 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]);
++ }
++
++ /* subtract out alignment bytes from total to minimize overallocation */
++ size = contents_size + array_size - MALLOC_ALIGN_MASK;
++
++ /*
++ Allocate the aggregate chunk.
++ But first disable mmap so malloc won't use it, since
++ we would not be able to later free/realloc space internal
++ to a segregated mmap region.
++ */
++ mmx = av->n_mmaps_max; /* disable mmap */
++ av->n_mmaps_max = 0;
++ mem = mALLOc(size);
++ av->n_mmaps_max = mmx; /* reset mmap */
++ if (mem == 0)
++ return 0;
++
++ p = mem2chunk(mem);
++ assert(!chunk_is_mmapped(p));
++ remainder_size = chunksize(p);
++
++ if (opts & 0x2) { /* optionally clear the elements */
++ MALLOC_ZERO(mem, remainder_size - SIZE_SZ - array_size);
++ }
++
++ /* If not provided, allocate the pointer array as final part of chunk */
++ if (marray == 0) {
++ array_chunk = chunk_at_offset(p, contents_size);
++ marray = (Void_t**) (chunk2mem(array_chunk));
++ set_head(array_chunk, (remainder_size - contents_size) | PREV_INUSE);
++ 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_head(p, size | PREV_INUSE);
++ p = chunk_at_offset(p, size);
++ }
++ else { /* the final element absorbs any overallocation slop */
++ set_head(p, remainder_size | PREV_INUSE);
++ break;
++ }
++ }
++
++#ifdef 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(mem2chunk(marray));
++ }
++
++ for (i = 0; i != n_elements; ++i)
++ check_inuse_chunk(mem2chunk(marray[i]));
++#endif
++
++ return marray;
++}
++
++
++/*
++ ------------------------- independent_calloc -------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t** iCALLOc(size_t n_elements, size_t elem_size, Void_t* chunks[])
++#else
++Void_t** iCALLOc(n_elements, elem_size, chunks) size_t n_elements; size_t elem_size; Void_t* chunks[];
++#endif
++{
++ size_t sz = elem_size; /* serves as 1-element array */
++ /* opts arg of 3 means all elements are same size, and should be cleared */
++ return iALLOc(n_elements, &sz, 3, chunks);
++}
++
++/*
++ ------------------------- independent_comalloc -------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t** iCOMALLOc(size_t n_elements, size_t sizes[], Void_t* chunks[])
++#else
++Void_t** iCOMALLOc(n_elements, sizes, chunks) size_t n_elements; size_t sizes[]; Void_t* chunks[];
++#endif
++{
++ return iALLOc(n_elements, sizes, 0, chunks);
++}
++
++
++/*
++ ------------------------------ valloc ------------------------------
++*/
++
++INLINE
++#if __STD_C
++Void_t* vALLOc(size_t bytes)
++#else
++Void_t* vALLOc(bytes) size_t bytes;
++#endif
++{
++ /* Ensure initialization/consolidation */
++ mstate av = get_malloc_state();
++ if (have_fastchunks(av)) malloc_consolidate(av);
++ return mEMALIGn(av->pagesize, bytes);
++}
++
++/*
++ ------------------------------ pvalloc ------------------------------
++*/
++
++
++#if __STD_C
++Void_t* pVALLOc(size_t bytes)
++#else
++Void_t* pVALLOc(bytes) size_t bytes;
++#endif
++{
++ mstate av = get_malloc_state();
++ size_t pagesz;
++
++ /* Ensure initialization/consolidation */
++ if (have_fastchunks(av)) malloc_consolidate(av);
++ pagesz = av->pagesize;
++ return mEMALIGn(pagesz, (bytes + pagesz - 1) & ~(pagesz - 1));
++}
++
++
++/*
++ ------------------------------ malloc_trim ------------------------------
++*/
++
++INLINE
++#if __STD_C
++int mTRIm(size_t pad)
++#else
++int mTRIm(pad) size_t pad;
++#endif
++{
++ mstate av = get_malloc_state();
++ /* Ensure initialization/consolidation */
++ malloc_consolidate(av);
++
++#ifndef MORECORE_CANNOT_TRIM
++ return sYSTRIm(pad, av);
++#else
++ return 0;
++#endif
++}
++
++
++/*
++ ------------------------- malloc_usable_size -------------------------
++*/
++
++INLINE
++#if __STD_C
++size_t mUSABLe(Void_t* mem)
++#else
++size_t mUSABLe(mem) Void_t* mem;
++#endif
++{
++ mchunkptr p;
++ if (mem != 0) {
++ p = mem2chunk(mem);
++ if (chunk_is_mmapped(p))
++ return chunksize(p) - 2*SIZE_SZ;
++ else if (inuse(p))
++ return chunksize(p) - SIZE_SZ;
++ }
++ return 0;
++}
++
++/*
++ ------------------------------ mallinfo ------------------------------
++*/
++
++struct mallinfo mALLINFo()
++{
++ mstate av = get_malloc_state();
++ struct mallinfo mi;
++ unsigned int i;
++ mbinptr b;
++ mchunkptr p;
++ INTERNAL_SIZE_T avail;
++ INTERNAL_SIZE_T fastavail;
++ int nblocks;
++ int nfastblocks;
++
++ /* Ensure initialization */
++ if (av->top == 0) malloc_consolidate(av);
++
++ check_malloc_state();
++
++ /* Account for top */
++ avail = chunksize(av->top);
++ nblocks = 1; /* top always exists */
++
++ /* traverse fastbins */
++ nfastblocks = 0;
++ fastavail = 0;
++
++ for (i = 0; i < NFASTBINS; ++i) {
++ for (p = av->fastbins[i]; p != 0; p = p->fd) {
++ ++nfastblocks;
++ fastavail += chunksize(p);
++ }
++ }
++
++ avail += fastavail;
++
++ /* traverse regular bins */
++ for (i = 1; i < NBINS; ++i) {
++ b = bin_at(av, i);
++ for (p = last(b); p != b; p = p->bk) {
++ ++nblocks;
++ avail += chunksize(p);
++ }
++ }
++
++ mi.smblks = nfastblocks;
++ mi.ordblks = nblocks;
++ mi.fordblks = avail;
++ mi.uordblks = av->sbrked_mem - avail;
++ mi.arena = av->sbrked_mem;
++ mi.hblks = av->n_mmaps;
++ mi.hblkhd = av->mmapped_mem;
++ mi.fsmblks = fastavail;
++ mi.keepcost = chunksize(av->top);
++ mi.usmblks = av->max_total_mem;
++ return mi;
++}
++
++/*
++ ------------------------------ malloc_stats ------------------------------
++*/
++
++void mSTATs()
++{
++ struct mallinfo mi = mALLINFo();
++
++#ifdef WIN32
++ {
++ unsigned long free, reserved, committed;
++ vminfo (&free, &reserved, &committed);
++ fprintf(stderr, "free bytes = %10lu\n",
++ free);
++ fprintf(stderr, "reserved bytes = %10lu\n",
++ reserved);
++ fprintf(stderr, "committed bytes = %10lu\n",
++ committed);
++ }
++#endif
++
++
++ fprintf(stderr, "max system bytes = %10lu\n",
++ (unsigned long)(mi.usmblks));
++ fprintf(stderr, "system bytes = %10lu\n",
++ (unsigned long)(mi.arena + mi.hblkhd));
++ fprintf(stderr, "in use bytes = %10lu\n",
++ (unsigned long)(mi.uordblks + mi.hblkhd));
++
++
++#ifdef WIN32
++ {
++ unsigned long kernel, user;
++ if (cpuinfo (TRUE, &kernel, &user)) {
++ fprintf(stderr, "kernel ms = %10lu\n",
++ kernel);
++ fprintf(stderr, "user ms = %10lu\n",
++ user);
++ }
++ }
++#endif
++}
++
++
++/*
++ ------------------------------ mallopt ------------------------------
++*/
++
++INLINE
++#if __STD_C
++int mALLOPt(int param_number, int value)
++#else
++int mALLOPt(param_number, value) int param_number; int value;
++#endif
++{
++ mstate av = get_malloc_state();
++ /* Ensure initialization/consolidation */
++ malloc_consolidate(av);
++
++ switch(param_number) {
++ case M_MXFAST:
++ if (value >= 0 && value <= MAX_FAST_SIZE) {
++ set_max_fast(av, value);
++ return 1;
++ }
++ else
++ return 0;
++
++ case M_TRIM_THRESHOLD:
++ av->trim_threshold = value;
++ return 1;
++
++ case M_TOP_PAD:
++ av->top_pad = value;
++ return 1;
++
++ case M_MMAP_THRESHOLD:
++ av->mmap_threshold = value;
++ return 1;
++
++ case M_MMAP_MAX:
++#if !HAVE_MMAP
++ if (value != 0)
++ return 0;
++#endif
++ av->n_mmaps_max = value;
++ return 1;
++
++ default:
++ return 0;
++ }
++}
++
++
++/*
++ -------------------- Alternative MORECORE functions --------------------
++*/
++
++
++/*
++ General Requirements for MORECORE.
++
++ The MORECORE function must have the following properties:
++
++ If MORECORE_CONTIGUOUS is false:
++
++ * MORECORE must allocate in multiples of pagesize. It will
++ only be called with arguments that are multiples of pagesize.
++
++ * MORECORE(0) must return an address that is at least
++ MALLOC_ALIGNMENT aligned. (Page-aligning always suffices.)
++
++ else (i.e. If MORECORE_CONTIGUOUS is true):
++
++ * Consecutive calls to MORECORE with positive arguments
++ return increasing addresses, indicating that space has been
++ contiguously extended.
++
++ * MORECORE need not allocate in multiples of pagesize.
++ Calls to MORECORE need not have args of multiples of pagesize.
++
++ * MORECORE need not page-align.
++
++ In either case:
++
++ * MORECORE may allocate more memory than requested. (Or even less,
++ but this will generally result in a malloc failure.)
++
++ * MORECORE must not allocate memory when given argument zero, but
++ instead return one past the end address of memory from previous
++ nonzero call. This malloc does NOT call MORECORE(0)
++ until at least one call with positive arguments is made, so
++ the initial value returned is not important.
++
++ * Even though consecutive calls to MORECORE need not return contiguous
++ addresses, it must be OK for malloc'ed chunks to span multiple
++ regions in those cases where they do happen to be contiguous.
++
++ * MORECORE need not handle negative arguments -- it may instead
++ just return MORECORE_FAILURE when given negative arguments.
++ Negative arguments are always multiples of pagesize. MORECORE
++ must not misinterpret negative args as large positive unsigned
++ args. You can suppress all such calls from even occurring by defining
++ MORECORE_CANNOT_TRIM,
++
++ There is some variation across systems about the type of the
++ argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
++ actually be size_t, because sbrk supports negative args, so it is
++ normally the signed type of the same width as size_t (sometimes
++ declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much
++ matter though. Internally, we use "long" as arguments, which should
++ work across all reasonable possibilities.
++
++ Additionally, if MORECORE ever returns failure for a positive
++ 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 map noncontiguous space.
++
++ If you'd like mmap to ALWAYS be used, you can define MORECORE to be
++ a function that always returns MORECORE_FAILURE.
++
++ If you are using this malloc with something other than sbrk (or its
++ emulation) to supply memory regions, you probably want to set
++ MORECORE_CONTIGUOUS as false. As an example, here is a custom
++ allocator kindly contributed for pre-OSX macOS. It uses virtually
++ but not necessarily physically contiguous non-paged memory (locked
++ in, present and won't get swapped out). You can use it by
++ uncommenting this section, adding some #includes, and setting up the
++ appropriate defines above:
++
++ #define MORECORE osMoreCore
++ #define MORECORE_CONTIGUOUS 0
++
++ There is also a shutdown routine that should somehow be called for
++ cleanup upon program exit.
++
++ #define MAX_POOL_ENTRIES 100
++ #define MINIMUM_MORECORE_SIZE (64 * 1024)
++ static int next_os_pool;
++ void *our_os_pools[MAX_POOL_ENTRIES];
++
++ void *osMoreCore(int size)
++ {
++ void *ptr = 0;
++ static void *sbrk_top = 0;
++
++ if (size > 0)
++ {
++ if (size < MINIMUM_MORECORE_SIZE)
++ size = MINIMUM_MORECORE_SIZE;
++ if (CurrentExecutionLevel() == kTaskLevel)
++ ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
++ if (ptr == 0)
++ {
++ return (void *) MORECORE_FAILURE;
++ }
++ // save ptrs so they can be freed during cleanup
++ our_os_pools[next_os_pool] = ptr;
++ next_os_pool++;
++ ptr = (void *) ((((unsigned long) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
++ sbrk_top = (char *) ptr + size;
++ return ptr;
++ }
++ else if (size < 0)
++ {
++ // we don't currently support shrink behavior
++ return (void *) MORECORE_FAILURE;
++ }
++ else
++ {
++ return sbrk_top;
++ }
++ }
++
++ // cleanup any allocated memory pools
++ // called as last thing before shutting down driver
++
++ void osCleanupMem(void)
++ {
++ void **ptr;
++
++ for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
++ if (*ptr)
++ {
++ PoolDeallocate(*ptr);
++ *ptr = 0;
++ }
++ }
++
++*/
++
++
++/*
++ --------------------------------------------------------------
++
++ Emulation of sbrk for win32.
++ Donated by J. Walter <Walter@GeNeSys-e.de>.
++ For additional information about this code, and malloc on Win32, see
++ http://www.genesys-e.de/jwalter/
++*/
++
++
++#ifdef WIN32
++
++#ifdef _DEBUG
++/* #define TRACE */
++#endif
++
++/* Support for USE_MALLOC_LOCK */
++#ifdef USE_MALLOC_LOCK
++
++/* Wait for spin lock */
++static int slwait (int *sl) {
++ while (InterlockedCompareExchange ((void **) sl, (void *) 1, (void *) 0) != 0)
++ Sleep (0);
++ return 0;
++}
++
++/* Release spin lock */
++static int slrelease (int *sl) {
++ InterlockedExchange (sl, 0);
++ return 0;
++}
++
++#ifdef NEEDED
++/* Spin lock for emulation code */
++static int g_sl;
++#endif
++
++#endif /* USE_MALLOC_LOCK */
++
++/* getpagesize for windows */
++static long getpagesize (void) {
++ static long g_pagesize = 0;
++ if (! g_pagesize) {
++ SYSTEM_INFO system_info;
++ GetSystemInfo (&system_info);
++ g_pagesize = system_info.dwPageSize;
++ }
++ return g_pagesize;
++}
++static long getregionsize (void) {
++ static long g_regionsize = 0;
++ if (! g_regionsize) {
++ SYSTEM_INFO system_info;
++ GetSystemInfo (&system_info);
++ g_regionsize = system_info.dwAllocationGranularity;
++ }
++ return g_regionsize;
++}
++
++/* A region list entry */
++typedef struct _region_list_entry {
++ void *top_allocated;
++ void *top_committed;
++ void *top_reserved;
++ long reserve_size;
++ struct _region_list_entry *previous;
++} region_list_entry;
++
++/* Allocate and link a region entry in the region list */
++static int region_list_append (region_list_entry **last, void *base_reserved, long reserve_size) {
++ region_list_entry *next = HeapAlloc (GetProcessHeap (), 0, sizeof (region_list_entry));
++ if (! next)
++ return FALSE;
++ next->top_allocated = (char *) base_reserved;
++ next->top_committed = (char *) base_reserved;
++ next->top_reserved = (char *) base_reserved + reserve_size;
++ next->reserve_size = reserve_size;
++ next->previous = *last;
++ *last = next;
++ return TRUE;
++}
++/* Free and unlink the last region entry from the region list */
++static int region_list_remove (region_list_entry **last) {
++ region_list_entry *previous = (*last)->previous;
++ if (! HeapFree (GetProcessHeap (), sizeof (region_list_entry), *last))
++ return FALSE;
++ *last = previous;
++ return TRUE;
++}
++
++#define CEIL(size,to) (((size)+(to)-1)&~((to)-1))
++#define FLOOR(size,to) ((size)&~((to)-1))
++
++#define SBRK_SCALE 0
++/* #define SBRK_SCALE 1 */
++/* #define SBRK_SCALE 2 */
++/* #define SBRK_SCALE 4 */
++
++/* sbrk for windows */
++static void *sbrk (long size) {
++ static long g_pagesize, g_my_pagesize;
++ static long g_regionsize, g_my_regionsize;
++ static region_list_entry *g_last;
++ void *result = (void *) MORECORE_FAILURE;
++#ifdef TRACE
++ printf ("sbrk %d\n", size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize) {
++ g_pagesize = getpagesize ();
++ g_my_pagesize = g_pagesize << SBRK_SCALE;
++ }
++ if (! g_regionsize) {
++ g_regionsize = getregionsize ();
++ g_my_regionsize = g_regionsize << SBRK_SCALE;
++ }
++ if (! g_last) {
++ if (! region_list_append (&g_last, 0, 0))
++ goto sbrk_exit;
++ }
++ /* Assert invariants */
++ assert (g_last);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
++ g_last->top_allocated <= g_last->top_committed);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
++ g_last->top_committed <= g_last->top_reserved &&
++ (unsigned) g_last->top_committed % g_pagesize == 0);
++ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
++ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
++ /* Allocation requested? */
++ if (size >= 0) {
++ /* Allocation size is the requested size */
++ long allocate_size = size;
++ /* Compute the size to commit */
++ long to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Do we reach the commit limit? */
++ if (to_commit > 0) {
++ /* Round size to commit */
++ long commit_size = CEIL (to_commit, g_my_pagesize);
++ /* Compute the size to reserve */
++ long to_reserve = (char *) g_last->top_committed + commit_size - (char *) g_last->top_reserved;
++ /* Do we reach the reserve limit? */
++ if (to_reserve > 0) {
++ /* Compute the remaining size to commit in the current region */
++ long remaining_commit_size = (char *) g_last->top_reserved - (char *) g_last->top_committed;
++ if (remaining_commit_size > 0) {
++ /* Assert preconditions */
++ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
++ assert (0 < remaining_commit_size && remaining_commit_size % g_pagesize == 0); {
++ /* Commit this */
++ void *base_committed = VirtualAlloc (g_last->top_committed, remaining_commit_size,
++ MEM_COMMIT, PAGE_READWRITE);
++ /* Check returned pointer for consistency */
++ if (base_committed != g_last->top_committed)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", base_committed, remaining_commit_size);
++#endif
++ /* Adjust the regions commit top */
++ g_last->top_committed = (char *) base_committed + remaining_commit_size;
++ }
++ } {
++ /* Now we are going to search and reserve. */
++ int contiguous = -1;
++ int found = FALSE;
++ MEMORY_BASIC_INFORMATION memory_info;
++ void *base_reserved;
++ long reserve_size;
++ do {
++ /* Assume contiguous memory */
++ contiguous = TRUE;
++ /* Round size to reserve */
++ reserve_size = CEIL (to_reserve, g_my_regionsize);
++ /* Start with the current region's top */
++ memory_info.BaseAddress = g_last->top_reserved;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
++ /* Assert postconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Query %p %d %s\n", memory_info.BaseAddress, memory_info.RegionSize,
++ memory_info.State == MEM_FREE ? "FREE":
++ (memory_info.State == MEM_RESERVE ? "RESERVED":
++ (memory_info.State == MEM_COMMIT ? "COMMITTED": "?")));
++#endif
++ /* Region is free, well aligned and big enough: we are done */
++ if (memory_info.State == MEM_FREE &&
++ (unsigned) memory_info.BaseAddress % g_regionsize == 0 &&
++ memory_info.RegionSize >= (unsigned) reserve_size) {
++ found = TRUE;
++ break;
++ }
++ /* From now on we can't get contiguous memory! */
++ contiguous = FALSE;
++ /* Recompute size to reserve */
++ reserve_size = CEIL (allocate_size, g_my_regionsize);
++ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_pagesize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ }
++ /* Search failed? */
++ if (! found)
++ goto sbrk_exit;
++ /* Assert preconditions */
++ assert ((unsigned) memory_info.BaseAddress % g_regionsize == 0);
++ assert (0 < reserve_size && reserve_size % g_regionsize == 0);
++ /* Try to reserve this */
++ base_reserved = VirtualAlloc (memory_info.BaseAddress, reserve_size,
++ MEM_RESERVE, PAGE_NOACCESS);
++ if (! base_reserved) {
++ int rc = GetLastError ();
++ if (rc != ERROR_INVALID_ADDRESS)
++ goto sbrk_exit;
++ }
++ /* A null pointer signals (hopefully) a race condition with another thread. */
++ /* In this case, we try again. */
++ } while (! base_reserved);
++ /* Check returned pointer for consistency */
++ if (memory_info.BaseAddress && base_reserved != memory_info.BaseAddress)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_reserved % g_regionsize == 0);
++#ifdef TRACE
++ printf ("Reserve %p %d\n", base_reserved, reserve_size);
++#endif
++ /* Did we get contiguous memory? */
++ if (contiguous) {
++ long start_size = (char *) g_last->top_committed - (char *) g_last->top_allocated;
++ /* Adjust allocation size */
++ allocate_size -= start_size;
++ /* Adjust the regions allocation top */
++ g_last->top_allocated = g_last->top_committed;
++ /* Recompute the size to commit */
++ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Round size to commit */
++ commit_size = CEIL (to_commit, g_my_pagesize);
++ }
++ /* Append the new region to the list */
++ if (! region_list_append (&g_last, base_reserved, reserve_size))
++ goto sbrk_exit;
++ /* Didn't we get contiguous memory? */
++ if (! contiguous) {
++ /* Recompute the size to commit */
++ to_commit = (char *) g_last->top_allocated + allocate_size - (char *) g_last->top_committed;
++ /* Round size to commit */
++ commit_size = CEIL (to_commit, g_my_pagesize);
++ }
++ }
++ }
++ /* Assert preconditions */
++ assert ((unsigned) g_last->top_committed % g_pagesize == 0);
++ assert (0 < commit_size && commit_size % g_pagesize == 0); {
++ /* Commit this */
++ void *base_committed = VirtualAlloc (g_last->top_committed, commit_size,
++ MEM_COMMIT, PAGE_READWRITE);
++ /* Check returned pointer for consistency */
++ if (base_committed != g_last->top_committed)
++ goto sbrk_exit;
++ /* Assert postconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", base_committed, commit_size);
++#endif
++ /* Adjust the regions commit top */
++ g_last->top_committed = (char *) base_committed + commit_size;
++ }
++ }
++ /* Adjust the regions allocation top */
++ g_last->top_allocated = (char *) g_last->top_allocated + allocate_size;
++ result = (char *) g_last->top_allocated - size;
++ /* Deallocation requested? */
++ } else if (size < 0) {
++ long deallocate_size = - size;
++ /* As long as we have a region to release */
++ while ((char *) g_last->top_allocated - deallocate_size < (char *) g_last->top_reserved - g_last->reserve_size) {
++ /* Get the size to release */
++ long release_size = g_last->reserve_size;
++ /* Get the base address */
++ void *base_reserved = (char *) g_last->top_reserved - release_size;
++ /* Assert preconditions */
++ assert ((unsigned) base_reserved % g_regionsize == 0);
++ assert (0 < release_size && release_size % g_regionsize == 0); {
++ /* Release this */
++ int rc = VirtualFree (base_reserved, 0,
++ MEM_RELEASE);
++ /* Check returned code for consistency */
++ if (! rc)
++ goto sbrk_exit;
++#ifdef TRACE
++ printf ("Release %p %d\n", base_reserved, release_size);
++#endif
++ }
++ /* Adjust deallocation size */
++ deallocate_size -= (char *) g_last->top_allocated - (char *) base_reserved;
++ /* Remove the old region from the list */
++ if (! region_list_remove (&g_last))
++ goto sbrk_exit;
++ } {
++ /* Compute the size to decommit */
++ long to_decommit = (char *) g_last->top_committed - ((char *) g_last->top_allocated - deallocate_size);
++ if (to_decommit >= g_my_pagesize) {
++ /* Compute the size to decommit */
++ long decommit_size = FLOOR (to_decommit, g_my_pagesize);
++ /* Compute the base address */
++ void *base_committed = (char *) g_last->top_committed - decommit_size;
++ /* Assert preconditions */
++ assert ((unsigned) base_committed % g_pagesize == 0);
++ assert (0 < decommit_size && decommit_size % g_pagesize == 0); {
++ /* Decommit this */
++ int rc = VirtualFree ((char *) base_committed, decommit_size,
++ MEM_DECOMMIT);
++ /* Check returned code for consistency */
++ if (! rc)
++ goto sbrk_exit;
++#ifdef TRACE
++ printf ("Decommit %p %d\n", base_committed, decommit_size);
++#endif
++ }
++ /* Adjust deallocation size and regions commit and allocate top */
++ deallocate_size -= (char *) g_last->top_allocated - (char *) base_committed;
++ g_last->top_committed = base_committed;
++ g_last->top_allocated = base_committed;
++ }
++ }
++ /* Adjust regions allocate top */
++ g_last->top_allocated = (char *) g_last->top_allocated - deallocate_size;
++ /* Check for underflow */
++ if ((char *) g_last->top_reserved - g_last->reserve_size > (char *) g_last->top_allocated ||
++ g_last->top_allocated > g_last->top_committed) {
++ /* Adjust regions allocate top */
++ g_last->top_allocated = (char *) g_last->top_reserved - g_last->reserve_size;
++ goto sbrk_exit;
++ }
++ result = g_last->top_allocated;
++ }
++ /* Assert invariants */
++ assert (g_last);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_allocated &&
++ g_last->top_allocated <= g_last->top_committed);
++ assert ((char *) g_last->top_reserved - g_last->reserve_size <= (char *) g_last->top_committed &&
++ g_last->top_committed <= g_last->top_reserved &&
++ (unsigned) g_last->top_committed % g_pagesize == 0);
++ assert ((unsigned) g_last->top_reserved % g_regionsize == 0);
++ assert ((unsigned) g_last->reserve_size % g_regionsize == 0);
++
++sbrk_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return result;
++}
++
++/* mmap for windows */
++static void *mmap (void *ptr, long size, long prot, long type, long handle, long arg) {
++ static long g_pagesize;
++ static long g_regionsize;
++#ifdef TRACE
++ printf ("mmap %d\n", size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize)
++ g_pagesize = getpagesize ();
++ if (! g_regionsize)
++ g_regionsize = getregionsize ();
++ /* Assert preconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++ assert (size % g_pagesize == 0);
++ /* Allocate this */
++ ptr = VirtualAlloc (ptr, size,
++ MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE);
++ if (! ptr) {
++ ptr = (void *) MORECORE_FAILURE;
++ goto mmap_exit;
++ }
++ /* Assert postconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++#ifdef TRACE
++ printf ("Commit %p %d\n", ptr, size);
++#endif
++mmap_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return ptr;
++}
++
++/* munmap for windows */
++static long munmap (void *ptr, long size) {
++ static long g_pagesize;
++ static long g_regionsize;
++ int rc = MUNMAP_FAILURE;
++#ifdef TRACE
++ printf ("munmap %p %d\n", ptr, size);
++#endif
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Wait for spin lock */
++ slwait (&g_sl);
++#endif
++ /* First time initialization */
++ if (! g_pagesize)
++ g_pagesize = getpagesize ();
++ if (! g_regionsize)
++ g_regionsize = getregionsize ();
++ /* Assert preconditions */
++ assert ((unsigned) ptr % g_regionsize == 0);
++ assert (size % g_pagesize == 0);
++ /* Free this */
++ if (! VirtualFree (ptr, 0,
++ MEM_RELEASE))
++ goto munmap_exit;
++ rc = 0;
++#ifdef TRACE
++ printf ("Release %p %d\n", ptr, size);
++#endif
++munmap_exit:
++#if defined (USE_MALLOC_LOCK) && defined (NEEDED)
++ /* Release spin lock */
++ slrelease (&g_sl);
++#endif
++ return rc;
++}
++
++static void vminfo (unsigned long *free, unsigned long *reserved, unsigned long *committed) {
++ MEMORY_BASIC_INFORMATION memory_info;
++ memory_info.BaseAddress = 0;
++ *free = *reserved = *committed = 0;
++ while (VirtualQuery (memory_info.BaseAddress, &memory_info, sizeof (memory_info))) {
++ switch (memory_info.State) {
++ case MEM_FREE:
++ *free += memory_info.RegionSize;
++ break;
++ case MEM_RESERVE:
++ *reserved += memory_info.RegionSize;
++ break;
++ case MEM_COMMIT:
++ *committed += memory_info.RegionSize;
++ break;
++ }
++ memory_info.BaseAddress = (char *) memory_info.BaseAddress + memory_info.RegionSize;
++ }
++}
++
++static int cpuinfo (int whole, unsigned long *kernel, unsigned long *user) {
++ if (whole) {
++ __int64 creation64, exit64, kernel64, user64;
++ int rc = GetProcessTimes (GetCurrentProcess (),
++ (FILETIME *) &creation64,
++ (FILETIME *) &exit64,
++ (FILETIME *) &kernel64,
++ (FILETIME *) &user64);
++ if (! rc) {
++ *kernel = 0;
++ *user = 0;
++ return FALSE;
++ }
++ *kernel = (unsigned long) (kernel64 / 10000);
++ *user = (unsigned long) (user64 / 10000);
++ return TRUE;
++ } else {
++ __int64 creation64, exit64, kernel64, user64;
++ int rc = GetThreadTimes (GetCurrentThread (),
++ (FILETIME *) &creation64,
++ (FILETIME *) &exit64,
++ (FILETIME *) &kernel64,
++ (FILETIME *) &user64);
++ if (! rc) {
++ *kernel = 0;
++ *user = 0;
++ return FALSE;
++ }
++ *kernel = (unsigned long) (kernel64 / 10000);
++ *user = (unsigned long) (user64 / 10000);
++ return TRUE;
++ }
++}
++
++#endif /* WIN32 */
++
++/* ------------------------------------------------------------
++History:
++
++ V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
++ * Introduce independent_comalloc and independent_calloc.
++ Thanks to Michael Pachos for motivation and help.
++ * Make optional .h file available
++ * Allow > 2GB requests on 32bit systems.
++ * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>.
++ Thanks also to Andreas Mueller <a.mueller at paradatec.de>,
++ and Anonymous.
++ * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for
++ helping test this.)
++ * memalign: check alignment arg
++ * realloc: don't try to shift chunks backwards, since this
++ leads to more fragmentation in some programs and doesn't
++ seem to help in any others.
++ * Collect all cases in malloc requiring system memory into sYSMALLOc
++ * Use mmap as backup to sbrk
++ * Place all internal state in malloc_state
++ * Introduce fastbins (although similar to 2.5.1)
++ * Many minor tunings and cosmetic improvements
++ * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK
++ * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS
++ Thanks to Tony E. Bennett <tbennett@nvidia.com> and others.
++ * Include errno.h to support default failure action.
++
++ V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee)
++ * return null for negative arguments
++ * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com>
++ * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h'
++ (e.g. WIN32 platforms)
++ * Cleanup header file inclusion for WIN32 platforms
++ * Cleanup code to avoid Microsoft Visual C++ compiler complaints
++ * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing
++ memory allocation routines
++ * Set 'malloc_getpagesize' for WIN32 platforms (needs more work)
++ * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to
++ usage of 'assert' in non-WIN32 code
++ * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to
++ avoid infinite loop
++ * Always call 'fREe()' rather than 'free()'
++
++ V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee)
++ * Fixed ordering problem with boundary-stamping
++
++ V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
++ * Added pvalloc, as recommended by H.J. Liu
++ * Added 64bit pointer support mainly from Wolfram Gloger
++ * Added anonymously donated WIN32 sbrk emulation
++ * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
++ * malloc_extend_top: fix mask error that caused wastage after
++ foreign sbrks
++ * Add linux mremap support code from HJ Liu
++
++ V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
++ * Integrated most documentation with the code.
++ * Add support for mmap, with help from
++ Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
++ * Use last_remainder in more cases.
++ * Pack bins using idea from colin@nyx10.cs.du.edu
++ * Use ordered bins instead of best-fit threshold
++ * Eliminate block-local decls to simplify tracing and debugging.
++ * Support another case of realloc via move into top
++ * Fix error occurring when initial sbrk_base not word-aligned.
++ * Rely on page size for units instead of SBRK_UNIT to
++ avoid surprises about sbrk alignment conventions.
++ * Add mallinfo, mallopt. Thanks to Raymond Nijssen
++ (raymond@es.ele.tue.nl) for the suggestion.
++ * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
++ * More precautions for cases where other routines call sbrk,
++ courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
++ * Added macros etc., allowing use in linux libc from
++ H.J. Lu (hjl@gnu.ai.mit.edu)
++ * Inverted this history list
++
++ V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
++ * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
++ * Removed all preallocation code since under current scheme
++ the work required to undo bad preallocations exceeds
++ the work saved in good cases for most test programs.
++ * No longer use return list or unconsolidated bins since
++ no scheme using them consistently outperforms those that don't
++ given above changes.
++ * Use best fit for very large chunks to prevent some worst-cases.
++ * Added some support for debugging
++
++ V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
++ * Removed footers when chunks are in use. Thanks to
++ Paul Wilson (wilson@cs.texas.edu) for the suggestion.
++
++ V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
++ * Added malloc_trim, with help from Wolfram Gloger
++ (wmglo@Dent.MED.Uni-Muenchen.DE).
++
++ V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
++
++ V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
++ * realloc: try to expand in both directions
++ * malloc: swap order of clean-bin strategy;
++ * realloc: only conditionally expand backwards
++ * Try not to scavenge used bins
++ * Use bin counts as a guide to preallocation
++ * Occasionally bin return list chunks in first scan
++ * Add a few optimizations from colin@nyx10.cs.du.edu
++
++ V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
++ * faster bin computation & slightly different binning
++ * merged all consolidations to one part of malloc proper
++ (eliminating old malloc_find_space & malloc_clean_bin)
++ * Scan 2 returns chunks (not just 1)
++ * Propagate failure in realloc if malloc returns 0
++ * Add stuff to allow compilation on non-ANSI compilers
++ from kpv@research.att.com
++
++ V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
++ * removed potential for odd address access in prev_chunk
++ * removed dependency on getpagesize.h
++ * misc cosmetics and a bit more internal documentation
++ * anticosmetics: mangled names in macros to evade debugger strangeness
++ * tested on sparc, hp-700, dec-mips, rs6000
++ with gcc & native cc (hp, dec only) allowing
++ Detlefs & Zorn comparison study (in SIGPLAN Notices.)
++
++ Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
++ * Based loosely on libg++-1.2X malloc. (It retains some of the overall
++ structure of old version, but most details differ.)
++
++*/
++
++#ifdef USE_PUBLIC_MALLOC_WRAPPERS
++
++#ifndef KDE_MALLOC_FULL
++
++#ifdef KDE_MALLOC_GLIBC
++#include "glibc.h"
++#else
++/* cannot use dlsym(RTLD_NEXT,...) here, it calls malloc()*/
++#error Unknown libc
++#endif
++
++/* 0 - uninitialized
++ 1 - this malloc
++ 2 - standard libc malloc*/
++extern char* getenv(const char*);
++static int malloc_type = 0;
++static void init_malloc_type(void)
++ {
++ const char* const env = getenv( "KDE_MALLOC" );
++ if( env == NULL )
++ malloc_type = 1;
++ else if( env[ 0 ] == '0' || env[ 0 ] == 'n' || env[ 0 ] == 'N' )
++ malloc_type = 2;
++ else
++ malloc_type = 1;
++ }
++
++#endif
++
++Void_t* public_mALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_malloc( bytes );
++ init_malloc_type();
++ return public_mALLOc( bytes );
++#endif
++}
++
++void public_fREe(Void_t* m) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ fREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++#ifndef KDE_MALLOC_FULL
++ return;
++ }
++ if( malloc_type == 2 )
++ {
++ libc_free( m );
++ return;
++ }
++ init_malloc_type();
++ public_fREe( m );
++#endif
++}
++
++Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = rEALLOc(m, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_realloc( m, bytes );
++ init_malloc_type();
++ return public_rEALLOc( m, bytes );
++#endif
++}
++
++Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = mEMALIGn(alignment, bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_memalign( alignment, bytes );
++ init_malloc_type();
++ return public_mEMALIGn( alignment, bytes );
++#endif
++}
++
++Void_t* public_vALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = vALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_valloc( bytes );
++ init_malloc_type();
++ return public_vALLOc( bytes );
++#endif
++}
++
++Void_t* public_pVALLOc(size_t bytes) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = pVALLOc(bytes);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_pvalloc( bytes );
++ init_malloc_type();
++ return public_pVALLOc( bytes );
++#endif
++}
++
++Void_t* public_cALLOc(size_t n, size_t elem_size) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ Void_t* m;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ m = cALLOc(n, elem_size);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_calloc( n, elem_size );
++ init_malloc_type();
++ return public_cALLOc( n, elem_size );
++#endif
++}
++
++void public_cFREe(Void_t* m) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ if (MALLOC_PREACTION != 0) {
++ return;
++ }
++ cFREe(m);
++ if (MALLOC_POSTACTION != 0) {
++ }
++#ifndef KDE_MALLOC_FULL
++ return;
++ }
++ if( malloc_type == 2 )
++ {
++ libc_cfree( m );
++ return;
++ }
++ init_malloc_type();
++ public_cFREe( m );
++#endif
++}
++
++struct mallinfo public_mALLINFo() {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ struct mallinfo m;
++ if (MALLOC_PREACTION != 0) {
++ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
++ return nm;
++ }
++ m = mALLINFo();
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return m;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_mallinfo();
++ init_malloc_type();
++ return public_mALLINFo();
++#endif
++}
++
++int public_mALLOPt(int p, int v) {
++#ifndef KDE_MALLOC_FULL
++ if( malloc_type == 1 )
++ {
++#endif
++ int result;
++ if (MALLOC_PREACTION != 0) {
++ return 0;
++ }
++ result = mALLOPt(p, v);
++ if (MALLOC_POSTACTION != 0) {
++ }
++ return result;
++#ifndef KDE_MALLOC_FULL
++ }
++ if( malloc_type == 2 )
++ return libc_mallopt( p, v );
++ init_malloc_type();
++ return public_mALLOPt( p, v );
++#endif
++}
++#endif
++
++int
++posix_memalign (void **memptr, size_t alignment, size_t size)
++{
++ void *mem;
++
++ /* Test whether the SIZE argument is valid. It must be a power of
++ two multiple of sizeof (void *). */
++ if (size % sizeof (void *) != 0 || (size & (size - 1)) != 0)
++ return EINVAL;
++
++ mem = memalign (alignment, size);
++
++ if (mem != NULL) {
++ *memptr = mem;
++ return 0;
++ }
++
++ return ENOMEM;
++}
++
++#else
++/* Some linkers (Solaris 2.6) don't like empty archives, but for
++ easier Makefile's we want to link against libklmalloc.la every time,
++ so simply make it non-empty. */
++void kde_malloc_dummy_function ()
++{
++ return;
++}
++#endif
+diff -Nupr a/src/corelib/arch/avr32/qatomic.cpp b/src/corelib/arch/avr32/qatomic.cpp
+--- a/src/corelib/arch/avr32/qatomic.cpp 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/avr32/qatomic.cpp 2006-07-26 11:02:43.000000000 +0200
+@@ -0,0 +1,24 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#include "QtCore/qatomic_avr32.h"
++
++Q_CORE_EXPORT long q_atomic_lock = 0;
+diff -Nupr a/src/corelib/arch/qatomic_arch.h b/src/corelib/arch/qatomic_arch.h
+--- a/src/corelib/arch/qatomic_arch.h 2006-06-30 09:49:44.000000000 +0200
++++ b/src/corelib/arch/qatomic_arch.h 2006-07-27 12:42:58.000000000 +0200
+@@ -47,6 +47,8 @@ QT_BEGIN_HEADER
+ # include "QtCore/qatomic_alpha.h"
+ #elif defined(QT_ARCH_ARM)
+ # include "QtCore/qatomic_arm.h"
++#elif defined(QT_ARCH_AVR32)
++# include "QtCore/qatomic_avr32.h"
+ #elif defined(QT_ARCH_BOUNDSCHECKER)
+ # include "QtCore/qatomic_boundschecker.h"
+ #elif defined(QT_ARCH_GENERIC)
+diff -Nupr a/src/corelib/arch/qatomic_avr32.h b/src/corelib/arch/qatomic_avr32.h
+--- a/src/corelib/arch/qatomic_avr32.h 1970-01-01 01:00:00.000000000 +0100
++++ b/src/corelib/arch/qatomic_avr32.h 2006-07-28 10:30:08.000000000 +0200
+@@ -0,0 +1,132 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the QtCore module of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#ifndef AVR32_QATOMIC_H
++#define AVR32_QATOMIC_H
++
++#include <QtCore/qglobal.h>
++
++QT_BEGIN_HEADER
++
++extern Q_CORE_EXPORT long q_atomic_lock;
++
++inline long q_atomic_swp(volatile long *ptr, long newval)
++{
++ register int ret;
++ asm volatile("xchg %0,%1,%2"
++ : "=&r"(ret)
++ : "r"(ptr), "r"(newval)
++ : "memory", "cc");
++ return ret;
++}
++
++inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
++{
++ int ret = 0;
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0);
++ if (*ptr == expected) {
++ *ptr = newval;
++ ret = 1;
++ }
++ q_atomic_swp(&q_atomic_lock, 0);
++ return ret;
++}
++
++inline int q_atomic_test_and_set_acquire_int(volatile int *ptr, int expected, int newval)
++{
++ return q_atomic_test_and_set_int(ptr, expected, newval);
++}
++
++inline int q_atomic_test_and_set_release_int(volatile int *ptr, int expected, int newval)
++{
++ return q_atomic_test_and_set_int(ptr, expected, newval);
++}
++
++inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
++{
++ int ret = 0;
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ if (*reinterpret_cast<void * volatile *>(ptr) == expected) {
++ *reinterpret_cast<void * volatile *>(ptr) = newval;
++ ret = 1;
++ }
++ q_atomic_swp(&q_atomic_lock, 0);
++ return ret;
++}
++
++inline int q_atomic_increment(volatile int *ptr)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = originalValue + 1;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue != -1;
++}
++
++inline int q_atomic_decrement(volatile int *ptr)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = originalValue - 1;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue != 1;
++}
++
++inline int q_atomic_set_int(volatile int *ptr, int newval)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr = newval;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue;
++}
++
++inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ void *originalValue = *reinterpret_cast<void * volatile *>(ptr);
++ *reinterpret_cast<void * volatile *>(ptr) = newval;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue;
++}
++
++inline int q_atomic_fetch_and_add_int(volatile int *ptr, int value)
++{
++ while (q_atomic_swp(&q_atomic_lock, ~0) != 0) ;
++ int originalValue = *ptr;
++ *ptr += value;
++ q_atomic_swp(&q_atomic_lock, 0);
++ return originalValue;
++}
++
++inline int q_atomic_fetch_and_add_acquire_int(volatile int *ptr, int value)
++{
++ return q_atomic_fetch_and_add_int(ptr, value);
++}
++
++inline int q_atomic_fetch_and_add_release_int(volatile int *ptr, int value)
++{
++ return q_atomic_fetch_and_add_int(ptr, value);
++}
++
++QT_END_HEADER
++
++#endif // AVR32_QATOMIC_H
+diff -Nupr a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
+--- a/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-06-30 09:49:45.000000000 +0200
++++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp 2006-07-27 13:24:27.000000000 +0200
+@@ -87,6 +87,10 @@
+ # define __NR_inotify_init 316
+ # define __NR_inotify_add_watch 317
+ # define __NR_inotify_rm_watch 318
++#elif defined (__avr32__)
++# define __NR_inotify_init 240
++# define __NR_inotify_add_watch 241
++# define __NR_inotify_rm_watch 242
+ #elif defined (__SH4__)
+ # define __NR_inotify_init 290
+ # define __NR_inotify_add_watch 291
+diff -uprN a/mkspecs/qws/linux-avr32-g++/qmake.conf b/mkspecs/qws/linux-avr32-g++/qmake.conf
+--- a/mkspecs/qws/linux-avr32-g++/qmake.conf 1970-01-01 01:00:00.000000000 +0100
++++ b/mkspecs/qws/linux-avr32-g++/qmake.conf 2006-08-01 08:47:12.000000000 +0200
+@@ -0,0 +1,85 @@
++#
++# qmake configuration for linux-g++ using the avr32-linux-g++ crosscompiler
++#
++
++MAKEFILE_GENERATOR = UNIX
++TEMPLATE = app
++CONFIG += qt warn_on release link_prl
++QT += core gui network
++QMAKE_INCREMENTAL_STYLE = sublib
++
++QMAKE_CC = avr32-linux-gcc
++QMAKE_LEX = flex
++QMAKE_LEXFLAGS =
++QMAKE_YACC = yacc
++QMAKE_YACCFLAGS = -d
++QMAKE_CFLAGS = -pipe
++QMAKE_CFLAGS_WARN_ON = -Wall -W
++QMAKE_CFLAGS_WARN_OFF =
++QMAKE_CFLAGS_RELEASE = -O2
++QMAKE_CFLAGS_DEBUG = -g -O2
++QMAKE_CFLAGS_SHLIB = -fPIC
++QMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
++QMAKE_CFLAGS_THREAD = -D_REENTRANT
++QMAKE_CFLAGS_HIDESYMS = -fvisibility=hidden
++
++QMAKE_CXX = avr32-linux-g++
++QMAKE_CXXFLAGS = $$QMAKE_CFLAGS -fno-exceptions
++QMAKE_CXXFLAGS_WARN_ON = $$QMAKE_CFLAGS_WARN_ON
++QMAKE_CXXFLAGS_WARN_OFF = $$QMAKE_CFLAGS_WARN_OFF
++QMAKE_CXXFLAGS_RELEASE = $$QMAKE_CFLAGS_RELEASE
++QMAKE_CXXFLAGS_DEBUG = $$QMAKE_CFLAGS_DEBUG
++QMAKE_CXXFLAGS_SHLIB = $$QMAKE_CFLAGS_SHLIB
++QMAKE_CXXFLAGS_YACC = $$QMAKE_CFLAGS_YACC
++QMAKE_CXXFLAGS_THREAD = $$QMAKE_CFLAGS_THREAD
++QMAKE_CXXFLAGS_HIDESYMS = $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden
++
++QMAKE_INCDIR =
++QMAKE_LIBDIR =
++QMAKE_INCDIR_X11 =
++QMAKE_LIBDIR_X11 =
++QMAKE_INCDIR_QT = $$[QT_INSTALL_HEADERS]
++QMAKE_LIBDIR_QT = $$[QT_INSTALL_LIBS]
++QMAKE_INCDIR_OPENGL =
++QMAKE_LIBDIR_OPENGL =
++QMAKE_INCDIR_QTOPIA = $(QPEDIR)/include
++QMAKE_LIBDIR_QTOPIA = $(QPEDIR)/lib
++
++QMAKE_LINK = avr32-linux-g++
++QMAKE_LINK_SHLIB = avr32-linux-g++
++QMAKE_LFLAGS =
++QMAKE_LFLAGS_RELEASE =
++QMAKE_LFLAGS_DEBUG =
++QMAKE_LFLAGS_SHLIB = -shared
++QMAKE_LFLAGS_PLUGIN = $$QMAKE_LFLAGS_SHLIB
++QMAKE_LFLAGS_SONAME = -Wl,-soname,
++QMAKE_LFLAGS_THREAD =
++QMAKE_RPATH = -Wl,-rpath,
++
++QMAKE_LIBS =
++QMAKE_LIBS_DYNLOAD = -ldl
++QMAKE_LIBS_X11 =
++QMAKE_LIBS_X11SM =
++QMAKE_LIBS_QT = -lqte
++QMAKE_LIBS_QT_THREAD = -lqte-mt
++QMAKE_LIBS_QT_OPENGL = -lqgl
++QMAKE_LIBS_QTOPIA = -lqpe -lqtopia
++QMAKE_LIBS_THREAD = -lpthread
++
++QMAKE_MOC = $$[QT_INSTALL_BINS]/moc
++QMAKE_UIC = $$[QT_INSTALL_BINS]/uic
++
++QMAKE_AR = avr32-linux-ar cqs
++QMAKE_RANLIB = avr32-linux-ranlib
++
++QMAKE_TAR = tar -cf
++QMAKE_GZIP = gzip -9f
++
++QMAKE_COPY = cp -f
++QMAKE_MOVE = mv -f
++QMAKE_DEL_FILE = rm -f
++QMAKE_DEL_DIR = rmdir
++QMAKE_STRIP = avr32-linux-strip
++QMAKE_CHK_DIR_EXISTS = test -d
++QMAKE_MKDIR = mkdir -p
++load(qt_config)
+diff -uprN a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h
+--- a/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 1970-01-01 01:00:00.000000000 +0100
++++ b/mkspecs/qws/linux-avr32-g++/qplatformdefs.h 2006-07-26 09:16:52.000000000 +0200
+@@ -0,0 +1,22 @@
++/****************************************************************************
++**
++** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
++**
++** This file is part of the qmake spec of the Qt Toolkit.
++**
++** Licensees holding valid Qt Preview licenses may use this file in
++** accordance with the Qt Preview License Agreement provided with the
++** Software.
++**
++** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
++** information about Qt Commercial License Agreements.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++****************************************************************************/
++
++#include "../../linux-g++/qplatformdefs.h"
+--- a/include/QtCore/headers.pri 2007-08-02 15:03:31.000000000 +0200
++++ b/include/QtCore/headers.pri 2007-08-02 15:03:44.000000000 +0200
+@@ -1,2 +1,2 @@
+-SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
++SYNCQT.HEADER_FILES = ../corelib/io/qdatastream.h ../corelib/io/qdebug.h ../corelib/io/qtextstream.h ../corelib/io/qtemporaryfile.h ../corelib/io/qfsfileengine.h ../corelib/io/qiodevice.h ../corelib/io/qprocess.h ../corelib/io/qresource.h ../corelib/io/qdiriterator.h ../corelib/io/qbuffer.h ../corelib/io/qfilesystemwatcher.h ../corelib/io/qdir.h ../corelib/io/qurl.h ../corelib/io/qabstractfileengine.h ../corelib/io/qfileinfo.h ../corelib/io/qsettings.h ../corelib/io/qfile.h ../corelib/arch/qatomic_arch.h ../corelib/arch/qatomic_i386.h ../corelib/arch/qatomic_sparc.h ../corelib/arch/qatomic_x86_64.h ../corelib/arch/qatomic_ia64.h ../corelib/arch/qatomic_parisc.h ../corelib/arch/qatomic_mips.h ../corelib/arch/qatomic_s390.h ../corelib/arch/qatomic_arm.h ../corelib/arch/qatomic_avr32.h ../corelib/arch/qatomic_powerpc.h ../corelib/arch/qatomic_alpha.h ../corelib/arch/qatomic_boundschecker.h ../corelib/arch/qatomic_generic.h ../corelib/tools/qcache.h ../corelib/tools/qline.h ../corelib/tools/qlist.h ../corelib/tools/qpair.h ../corelib/tools/qpoint.h ../corelib/tools/qrect.h ../corelib/tools/qsize.h ../corelib/tools/qstringlist.h ../corelib/tools/qstringmatcher.h ../corelib/tools/qlinkedlist.h ../corelib/tools/qbitarray.h ../corelib/tools/qvector.h ../corelib/tools/qbytearraymatcher.h ../corelib/tools/qqueue.h ../corelib/tools/qbytearray.h ../corelib/tools/qalgorithms.h ../corelib/tools/qvarlengtharray.h ../corelib/tools/qshareddata.h ../corelib/tools/qcryptographichash.h ../corelib/tools/qiterator.h ../corelib/tools/qlocale.h ../corelib/tools/qstack.h ../corelib/tools/qmap.h ../corelib/tools/qset.h ../corelib/tools/qdatetime.h ../corelib/tools/qstring.h ../corelib/tools/qcontainerfwd.h ../corelib/tools/qregexp.h ../corelib/tools/qchar.h ../corelib/tools/qhash.h ../corelib/tools/qtimeline.h ../corelib/codecs/qtextcodecplugin.h ../corelib/codecs/qtextcodec.h ../corelib/global/qconfig-large.h ../corelib/global/qconfig-dist.h ../corelib/global/qconfig-small.h ../corelib/global/qlibraryinfo.h ../corelib/global/qendian.h ../corelib/global/qfeatures.h ../corelib/global/qglobal.h ../corelib/global/qconfig-minimal.h ../corelib/global/qnamespace.h ../corelib/global/qnumeric.h ../corelib/global/qconfig-medium.h ../corelib/kernel/qtranslator.h ../corelib/kernel/qvariant.h ../corelib/kernel/qmimedata.h ../corelib/kernel/qeventloop.h ../corelib/kernel/qcoreapplication.h ../corelib/kernel/qabstractitemmodel.h ../corelib/kernel/qsignalmapper.h ../corelib/kernel/qobjectcleanuphandler.h ../corelib/kernel/qbasictimer.h ../corelib/kernel/qsocketnotifier.h ../corelib/kernel/qobject.h ../corelib/kernel/qtimer.h ../corelib/kernel/qmetatype.h ../corelib/kernel/qabstracteventdispatcher.h ../corelib/kernel/qpointer.h ../corelib/kernel/qmetaobject.h ../corelib/kernel/qcoreevent.h ../corelib/kernel/qobjectdefs.h ../corelib/plugin/qpluginloader.h ../corelib/plugin/quuid.h ../corelib/plugin/qlibrary.h ../corelib/plugin/qplugin.h ../corelib/plugin/qfactoryinterface.h ../corelib/thread/qsemaphore.h ../corelib/thread/qthreadstorage.h ../corelib/thread/qwaitcondition.h ../corelib/thread/qthread.h ../corelib/thread/qmutex.h ../corelib/thread/qreadwritelock.h ../corelib/thread/qatomic.h ../../include/QtCore/QtCore
+ SYNCQT.HEADER_CLASSES = ../../include/QtCore/QDataStream ../../include/QtCore/QtDebug ../../include/QtCore/QDebug ../../include/QtCore/QNoDebug ../../include/QtCore/QTextStream ../../include/QtCore/QTextStreamFunction ../../include/QtCore/QTextStreamManipulator ../../include/QtCore/QTS ../../include/QtCore/QTextIStream ../../include/QtCore/QTextOStream ../../include/QtCore/QTemporaryFile ../../include/QtCore/QFSFileEngine ../../include/QtCore/QIODevice ../../include/QtCore/Q_PID ../../include/QtCore/QProcess ../../include/QtCore/QResource ../../include/QtCore/QDirIterator ../../include/QtCore/QBuffer ../../include/QtCore/QFileSystemWatcher ../../include/QtCore/QDir ../../include/QtCore/QUrl ../../include/QtCore/QAbstractFileEngine ../../include/QtCore/QAbstractFileEngineHandler ../../include/QtCore/QAbstractFileEngineIterator ../../include/QtCore/QFileInfo ../../include/QtCore/QFileInfoList ../../include/QtCore/QFileInfoListIterator ../../include/QtCore/QSettings ../../include/QtCore/QFile ../../include/QtCore/QBasicAtomic ../../include/QtCore/QBasicAtomicPointer ../../include/QtCore/QCache ../../include/QtCore/QLine ../../include/QtCore/QLineF ../../include/QtCore/QListData ../../include/QtCore/QList ../../include/QtCore/QListIterator ../../include/QtCore/QMutableListIterator ../../include/QtCore/QPair ../../include/QtCore/QPoint ../../include/QtCore/QPointF ../../include/QtCore/QRect ../../include/QtCore/QRectF ../../include/QtCore/QSize ../../include/QtCore/QSizeF ../../include/QtCore/QStringListIterator ../../include/QtCore/QMutableStringListIterator ../../include/QtCore/QStringList ../../include/QtCore/QStringMatcher ../../include/QtCore/QLinkedListData ../../include/QtCore/QLinkedListNode ../../include/QtCore/QLinkedList ../../include/QtCore/QLinkedListIterator ../../include/QtCore/QMutableLinkedListIterator ../../include/QtCore/QBitArray ../../include/QtCore/QBitRef ../../include/QtCore/QVectorData ../../include/QtCore/QVectorTypedData ../../include/QtCore/QVector ../../include/QtCore/QVectorIterator ../../include/QtCore/QMutableVectorIterator ../../include/QtCore/QByteArrayMatcher ../../include/QtCore/QQueue ../../include/QtCore/QByteArray ../../include/QtCore/QByteRef ../../include/QtCore/QtAlgorithms ../../include/QtCore/QVarLengthArray ../../include/QtCore/QSharedData ../../include/QtCore/QSharedDataPointer ../../include/QtCore/QExplicitlySharedDataPointer ../../include/QtCore/QCryptographicHash ../../include/QtCore/QLocale ../../include/QtCore/QSystemLocale ../../include/QtCore/QStack ../../include/QtCore/QMapData ../../include/QtCore/QMap ../../include/QtCore/QMultiMap ../../include/QtCore/QMapIterator ../../include/QtCore/QMutableMapIterator ../../include/QtCore/QSet ../../include/QtCore/QSetIterator ../../include/QtCore/QMutableSetIterator ../../include/QtCore/QDate ../../include/QtCore/QTime ../../include/QtCore/QDateTime ../../include/QtCore/QStdWString ../../include/QtCore/QString ../../include/QtCore/QLatin1String ../../include/QtCore/QCharRef ../../include/QtCore/QConstString ../../include/QtCore/QStringRef ../../include/QtCore/QtContainerFwd ../../include/QtCore/QRegExp ../../include/QtCore/QLatin1Char ../../include/QtCore/QChar ../../include/QtCore/QHashData ../../include/QtCore/QHashDummyValue ../../include/QtCore/QHashDummyNode ../../include/QtCore/QHashNode ../../include/QtCore/QHash ../../include/QtCore/QMultiHash ../../include/QtCore/QHashIterator ../../include/QtCore/QMutableHashIterator ../../include/QtCore/QTimeLine ../../include/QtCore/QTextCodecFactoryInterface ../../include/QtCore/QTextCodecPlugin ../../include/QtCore/QTextCodec ../../include/QtCore/QTextEncoder ../../include/QtCore/QTextDecoder ../../include/QtCore/QLibraryInfo ../../include/QtCore/QtEndian ../../include/QtCore/QtGlobal ../../include/QtCore/QUintForSize ../../include/QtCore/QUintForType ../../include/QtCore/QIntForSize ../../include/QtCore/QIntForType ../../include/QtCore/QNoImplicitBoolCast ../../include/QtCore/Q_INT8 ../../include/QtCore/Q_UINT8 ../../include/QtCore/Q_INT16 ../../include/QtCore/Q_UINT16 ../../include/QtCore/Q_INT32 ../../include/QtCore/Q_UINT32 ../../include/QtCore/Q_INT64 ../../include/QtCore/Q_UINT64 ../../include/QtCore/Q_LLONG ../../include/QtCore/Q_ULLONG ../../include/QtCore/Q_LONG ../../include/QtCore/Q_ULONG ../../include/QtCore/QSysInfo ../../include/QtCore/QtMsgHandler ../../include/QtCore/QGlobalStatic ../../include/QtCore/QGlobalStaticDeleter ../../include/QtCore/QBool ../../include/QtCore/QTypeInfo ../../include/QtCore/QFlag ../../include/QtCore/QFlags ../../include/QtCore/QForeachContainer ../../include/QtCore/QForeachContainerBase ../../include/QtCore/Qt ../../include/QtCore/QInternal ../../include/QtCore/QCOORD ../../include/QtCore/QTranslator ../../include/QtCore/QVariant ../../include/QtCore/QVariantList ../../include/QtCore/QVariantMap ../../include/QtCore/QVariantComparisonHelper ../../include/QtCore/QMimeData ../../include/QtCore/QEventLoop ../../include/QtCore/QCoreApplication ../../include/QtCore/QtCleanUpFunction ../../include/QtCore/QModelIndex ../../include/QtCore/QPersistentModelIndex ../../include/QtCore/QModelIndexList ../../include/QtCore/QAbstractItemModel ../../include/QtCore/QAbstractTableModel ../../include/QtCore/QAbstractListModel ../../include/QtCore/QSignalMapper ../../include/QtCore/QObjectCleanupHandler ../../include/QtCore/QBasicTimer ../../include/QtCore/QSocketNotifier ../../include/QtCore/QObjectList ../../include/QtCore/QObjectData ../../include/QtCore/QObject ../../include/QtCore/QObjectUserData ../../include/QtCore/QTimer ../../include/QtCore/QMetaType ../../include/QtCore/QMetaTypeId ../../include/QtCore/QMetaTypeId2 ../../include/QtCore/QAbstractEventDispatcher ../../include/QtCore/QPointer ../../include/QtCore/QMetaMethod ../../include/QtCore/QMetaEnum ../../include/QtCore/QMetaProperty ../../include/QtCore/QMetaClassInfo ../../include/QtCore/QEvent ../../include/QtCore/QTimerEvent ../../include/QtCore/QChildEvent ../../include/QtCore/QCustomEvent ../../include/QtCore/QDynamicPropertyChangeEvent ../../include/QtCore/QGenericArgument ../../include/QtCore/QGenericReturnArgument ../../include/QtCore/QArgument ../../include/QtCore/QReturnArgument ../../include/QtCore/QMetaObject ../../include/QtCore/QPluginLoader ../../include/QtCore/QUuid ../../include/QtCore/QLibrary ../../include/QtCore/QtPlugin ../../include/QtCore/QtPluginInstanceFunction ../../include/QtCore/QFactoryInterface ../../include/QtCore/QSemaphore ../../include/QtCore/QThreadStorageData ../../include/QtCore/QThreadStorage ../../include/QtCore/QWaitCondition ../../include/QtCore/QThread ../../include/QtCore/QMutex ../../include/QtCore/QMutexLocker ../../include/QtCore/QReadWriteLock ../../include/QtCore/QReadLocker ../../include/QtCore/QWriteLocker ../../include/QtCore/QAtomic ../../include/QtCore/QAtomicPointer
$(QTOPIA4_TARGET_DIR)/.unpacked: $(DL_DIR)/$(QTOPIA4_SOURCE)
$(QTOPIA4_CAT) $(DL_DIR)/$(QTOPIA4_SOURCE) | tar -C $(BUILD_DIR) $(TAR_OPTIONS) -
toolchain/patch-kernel.sh $(QTOPIA4_TARGET_DIR) package/qtopia4/ \
- qtopia-$(QTOPIA4_VERSION)-\*.patch\*
+ qtopia-$(QTOPIA4_VERSION)-\*.patch \
+ qtopia-$(QTOPIA4_VERSION)-\*.patch.$(ARCH)
touch $@
$(QTOPIA4_TARGET_DIR)/.configured: $(QTOPIA4_TARGET_DIR)/.unpacked
projects / buildroot.git / commitdiff