diff options
Diffstat (limited to 'package/qtopia4/qtopia-4.3.1-add-avr32-arch.patch.avr32')
| -rw-r--r-- | package/qtopia4/qtopia-4.3.1-add-avr32-arch.patch.avr32 | 6164 |
1 files changed, 0 insertions, 6164 deletions
diff --git a/package/qtopia4/qtopia-4.3.1-add-avr32-arch.patch.avr32 b/package/qtopia4/qtopia-4.3.1-add-avr32-arch.patch.avr32 deleted file mode 100644 index a885a4f03..000000000 --- a/package/qtopia4/qtopia-4.3.1-add-avr32-arch.patch.avr32 +++ /dev/null @@ -1,6164 +0,0 @@ -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 |