--- /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
projects / buildroot.git / commitdiff