malloc.c
上传用户:wealth48
上传日期:2022-06-24
资源大小:1701k
文件大小:182k
源码类别:

uCOS

开发平台:

C/C++

  1. #include "../inc/sysconfig.h"
  2. #if defined(_USE_OWN_MALLOC) && (USE_MINIGUI==0)
  3. #ifndef ENOMEM
  4. #define ENOMEM 12
  5. #endif
  6. /*
  7.   This is a version (aka dlmalloc) of malloc/free/realloc written by
  8.   Doug Lea and released to the public domain.  Use, modify, and
  9.   redistribute this code without permission or acknowledgement in any
  10.   way you wish.  Send questions, comments, complaints, performance
  11.   data, etc to dl@cs.oswego.edu
  12. * VERSION 2.7.2 Sat Aug 17 09:07:30 2002  Doug Lea  (dl at gee)
  13.    Note: There may be an updated version of this malloc obtainable at
  14.            ftp://gee.cs.oswego.edu/pub/misc/malloc.c
  15.          Check before installing!
  16. * Quickstart
  17.   This library is all in one file to simplify the most common usage:
  18.   ftp it, compile it (-O), and link it into another program. All
  19.   of the compile-time options default to reasonable values for use on
  20.   most unix platforms. Compile -DWIN32 for reasonable defaults on windows.
  21.   You might later want to step through various compile-time and dynamic
  22.   tuning options.
  23.   For convenience, an include file for code using this malloc is at:
  24.      ftp://gee.cs.oswego.edu/pub/misc/malloc-2.7.1.h
  25.   You don't really need this .h file unless you call functions not
  26.   defined in your system include files.  The .h file contains only the
  27.   excerpts from this file needed for using this malloc on ANSI C/C++
  28.   systems, so long as you haven't changed compile-time options about
  29.   naming and tuning parameters.  If you do, then you can create your
  30.   own malloc.h that does include all settings by cutting at the point
  31.   indicated below.
  32. * Why use this malloc?
  33.   This is not the fastest, most space-conserving, most portable, or
  34.   most tunable malloc ever written. However it is among the fastest
  35.   while also being among the most space-conserving, portable and tunable.
  36.   Consistent balance across these factors results in a good general-purpose
  37.   allocator for malloc-intensive programs.
  38.   The main properties of the algorithms are:
  39.   * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
  40.     with ties normally decided via FIFO (i.e. least recently used).
  41.   * For small (<= 64 bytes by default) requests, it is a caching
  42.     allocator, that maintains pools of quickly recycled chunks.
  43.   * In between, and for combinations of large and small requests, it does
  44.     the best it can trying to meet both goals at once.
  45.   * For very large requests (>= 128KB by default), it relies on system
  46.     memory mapping facilities, if supported.
  47.   For a longer but slightly out of date high-level description, see
  48.      http://gee.cs.oswego.edu/dl/html/malloc.html
  49.   You may already by default be using a C library containing a malloc
  50.   that is  based on some version of this malloc (for example in
  51.   linux). You might still want to use the one in this file in order to
  52.   customize settings or to avoid overheads associated with library
  53.   versions.
  54. * Contents, described in more detail in "description of public routines" below.
  55.   Standard (ANSI/SVID/...)  functions:
  56.     malloc(size_t n);
  57.     calloc(size_t n_elements, size_t element_size);
  58.     free(Void_t* p);
  59.     realloc(Void_t* p, size_t n);
  60.     memalign(size_t alignment, size_t n);
  61.     valloc(size_t n);
  62.     mallinfo()
  63.     mallopt(int parameter_number, int parameter_value)
  64.   Additional functions:
  65.     independent_calloc(size_t n_elements, size_t size, Void_t* chunks[]);
  66.     independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
  67.     pvalloc(size_t n);
  68.     cfree(Void_t* p);
  69.     malloc_trim(size_t pad);
  70.     malloc_usable_size(Void_t* p);
  71.     malloc_stats();
  72. * Vital statistics:
  73.   Supported pointer representation:       4 or 8 bytes
  74.   Supported size_t  representation:       4 or 8 bytes 
  75.        Note that size_t is allowed to be 4 bytes even if pointers are 8.
  76.        You can adjust this by defining INTERNAL_SIZE_T
  77.   Alignment:                              2 * sizeof(size_t) (default)
  78.        (i.e., 8 byte alignment with 4byte size_t). This suffices for
  79.        nearly all current machines and C compilers. However, you can
  80.        define MALLOC_ALIGNMENT to be wider than this if necessary.
  81.   Minimum overhead per allocated chunk:   4 or 8 bytes
  82.        Each malloced chunk has a hidden word of overhead holding size
  83.        and status information.
  84.   Minimum allocated size: 4-byte ptrs:  16 bytes    (including 4 overhead)
  85.                           8-byte ptrs:  24/32 bytes (including, 4/8 overhead)
  86.        When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte
  87.        ptrs but 4 byte size) or 24 (for 8/8) additional bytes are
  88.        needed; 4 (8) for a trailing size field and 8 (16) bytes for
  89.        free list pointers. Thus, the minimum allocatable size is
  90.        16/24/32 bytes.
  91.        Even a request for zero bytes (i.e., malloc(0)) returns a
  92.        pointer to something of the minimum allocatable size.
  93.        The maximum overhead wastage (i.e., number of extra bytes
  94.        allocated than were requested in malloc) is less than or equal
  95.        to the minimum size, except for requests >= mmap_threshold that
  96.        are serviced via mmap(), where the worst case wastage is 2 *
  97.        sizeof(size_t) bytes plus the remainder from a system page (the
  98.        minimal mmap unit); typically 4096 or 8192 bytes.
  99.   Maximum allocated size:  4-byte size_t: 2^32 minus about two pages 
  100.                            8-byte size_t: 2^64 minus about two pages
  101.        It is assumed that (possibly signed) size_t values suffice to
  102.        represent chunk sizes. `Possibly signed' is due to the fact
  103.        that `size_t' may be defined on a system as either a signed or
  104.        an unsigned type. The ISO C standard says that it must be
  105.        unsigned, but a few systems are known not to adhere to this.
  106.        Additionally, even when size_t is unsigned, sbrk (which is by
  107.        default used to obtain memory from system) accepts signed
  108.        arguments, and may not be able to handle size_t-wide arguments
  109.        with negative sign bit.  Generally, values that would
  110.        appear as negative after accounting for overhead and alignment
  111.        are supported only via mmap(), which does not have this
  112.        limitation.
  113.        Requests for sizes outside the allowed range will perform an optional
  114.        failure action and then return null. (Requests may also
  115.        also fail because a system is out of memory.)
  116.   Thread-safety: NOT thread-safe unless USE_MALLOC_LOCK defined
  117.        When USE_MALLOC_LOCK is defined, wrappers are created to
  118.        surround every public call with either a pthread mutex or
  119.        a win32 spinlock (depending on WIN32). This is not
  120.        especially fast, and can be a major bottleneck.
  121.        It is designed only to provide minimal protection
  122.        in concurrent environments, and to provide a basis for
  123.        extensions.  If you are using malloc in a concurrent program,
  124.        you would be far better off obtaining ptmalloc, which is
  125.        derived from a version of this malloc, and is well-tuned for
  126.        concurrent programs. (See http://www.malloc.de) Note that
  127.        even when USE_MALLOC_LOCK is defined, you can can guarantee
  128.        full thread-safety only if no threads acquire memory through 
  129.        direct calls to MORECORE or other system-level allocators.
  130.   Compliance: I believe it is compliant with the 1997 Single Unix Specification
  131.        (See http://www.opennc.org). Also SVID/XPG, ANSI C, and probably 
  132.        others as well.
  133. * Synopsis of compile-time options:
  134.     People have reported using previous versions of this malloc on all
  135.     versions of Unix, sometimes by tweaking some of the defines
  136.     below. It has been tested most extensively on Solaris and
  137.     Linux. It is also reported to work on WIN32 platforms.
  138.     People also report using it in stand-alone embedded systems.
  139.     The implementation is in straight, hand-tuned ANSI C.  It is not
  140.     at all modular. (Sorry!)  It uses a lot of macros.  To be at all
  141.     usable, this code should be compiled using an optimizing compiler
  142.     (for example gcc -O3) that can simplify expressions and control
  143.     paths. (FAQ: some macros import variables as arguments rather than
  144.     declare locals because people reported that some debuggers
  145.     otherwise get confused.)
  146.     OPTION                     DEFAULT VALUE
  147.     Compilation Environment options:
  148.     __STD_C                    derived from C compiler defines
  149.     WIN32                      NOT defined
  150.     HAVE_MEMCPY                defined
  151.     USE_MEMCPY                 1 if HAVE_MEMCPY is defined
  152.     HAVE_MMAP                  defined as 1 
  153.     MMAP_CLEARS                1
  154.     HAVE_MREMAP                0 unless linux defined
  155.     malloc_getpagesize         derived from system #includes, or 4096 if not
  156.     HAVE_USR_INCLUDE_MALLOC_H  NOT defined
  157.     LACKS_UNISTD_H             NOT defined unless WIN32
  158.     LACKS_SYS_PARAM_H          NOT defined unless WIN32
  159.     LACKS_SYS_MMAN_H           NOT defined unless WIN32
  160.     LACKS_FCNTL_H              NOT defined
  161.     Changing default word sizes:
  162.     INTERNAL_SIZE_T            size_t
  163.     MALLOC_ALIGNMENT           2 * sizeof(INTERNAL_SIZE_T)
  164.     PTR_UINT                   unsigned long
  165.     CHUNK_SIZE_T               unsigned long
  166.     Configuration and functionality options:
  167.     USE_DL_PREFIX              NOT defined
  168.     USE_PUBLIC_MALLOC_WRAPPERS NOT defined
  169.     USE_MALLOC_LOCK            NOT defined
  170.     DEBUG                      NOT defined
  171.     REALLOC_ZERO_BYTES_FREES   NOT defined
  172.     MALLOC_FAILURE_ACTION      errno = ENOMEM, if __STD_C defined, else no-op
  173.     TRIM_FASTBINS              0
  174.     FIRST_SORTED_BIN_SIZE      512
  175.     Options for customizing MORECORE:
  176.     MORECORE                   sbrk
  177.     MORECORE_CONTIGUOUS        1 
  178.     MORECORE_CANNOT_TRIM       NOT defined
  179.     MMAP_AS_MORECORE_SIZE      (1024 * 1024) 
  180.     Tuning options that are also dynamically changeable via mallopt:
  181.     DEFAULT_MXFAST             64
  182.     DEFAULT_TRIM_THRESHOLD     256 * 1024
  183.     DEFAULT_TOP_PAD            0
  184.     DEFAULT_MMAP_THRESHOLD     256 * 1024
  185.     DEFAULT_MMAP_MAX           65536
  186.     There are several other #defined constants and macros that you
  187.     probably don't want to touch unless you are extending or adapting malloc.
  188. */
  189. #ifndef DEBUG
  190. #    define DEBUG 0
  191. #endif
  192. #ifdef __UCOSII__
  193. #define HAVE_MMAP           0
  194. #define MMAP_CLEARS         0
  195. #define HAVE_MREMAP         0
  196. #define LACKS_UNISTD_H
  197. #define LACKS_SYS_PARAM_H
  198. #define LACKS_SYS_MMAN_H
  199. #undef HAVE_GETPAGESIZE
  200. #define USE_MALLOC_LOCK     1
  201. /* mutex priority of the malloc */
  202. #define UCOS2_MALLOC_MUTEX_PRIO 42
  203. #define MORECORE            __ucos2_MoreCore
  204. #define MORECORE_CONTIGUOUS 1
  205. #define MORECORE_FAILURE    ((void*)(-1))
  206. #define MORECORE_CANNOT_TRIM
  207. extern unsigned int bottom_of_heap;     /* defined in heap.s */
  208. static char* __ucos2_heap;
  209. static void* __ucos2_MoreCore (int size)
  210. {
  211.     void* start;
  212.     if (size >= 0 && (int)__ucos2_heap + size <= HEAPEND) {
  213.         start = __ucos2_heap;
  214.         __ucos2_heap += size;
  215.         return start;
  216.     }
  217.     return MORECORE_FAILURE;
  218. }
  219. #include "os_cpu.h" //by threewater
  220. #include "os_cfg.h"
  221. #include "ucos_ii.h"
  222. static OS_EVENT* __ucos2_malloc_mutex;
  223. static int __ucos2_mutex_lock (void)
  224. {
  225.     INT8U err;
  226.     OSMutexPend (__ucos2_malloc_mutex, 0, &err);
  227.     if (err == OS_NO_ERR)
  228.         return 0;
  229.     return -1;
  230. }
  231. static int __ucos2_mutex_unlock (void)
  232. {
  233.     OSMutexPost (__ucos2_malloc_mutex);
  234.     return 0;
  235. }
  236. int ucos2_malloc_init (void)
  237. {
  238.     INT8U err;
  239.     __ucos2_heap = (char *)&bottom_of_heap;
  240.     __ucos2_malloc_mutex = OSMutexCreate (UCOS2_MALLOC_MUTEX_PRIO, &err);
  241.     if (err == OS_NO_ERR) {
  242.         return 0;
  243.     }
  244.     return -1;
  245. }
  246. #endif /* __UCOSII__ */
  247. #ifdef __ADSONLY__
  248. #define HAVE_MMAP           0
  249. #define MMAP_CLEARS         0
  250. #define HAVE_MREMAP         0
  251. #define LACKS_UNISTD_H
  252. #define LACKS_SYS_PARAM_H
  253. #define LACKS_SYS_MMAN_H
  254. #undef HAVE_GETPAGESIZE
  255. //#define USE_MALLOC_LOCK     1
  256. #undef USE_MALLOC_LOCK
  257. #define MORECORE            __ucos2_MoreCore
  258. #define MORECORE_CONTIGUOUS 1
  259. #define MORECORE_FAILURE    ((void*)(-1))
  260. #define MORECORE_CANNOT_TRIM
  261. extern unsigned int bottom_of_heap;     /* defined in heap.s */
  262. static char* __ucos2_heap;
  263. static void* __ucos2_MoreCore (int size)
  264. {
  265.     void* start;
  266.     if (size >= 0 && (int)__ucos2_heap + size <= HEAPEND) {
  267.         start = __ucos2_heap;
  268.         __ucos2_heap += size;
  269.         return start;
  270.     }
  271.     return MORECORE_FAILURE;
  272. }
  273. int ucos2_malloc_init (void)
  274. {
  275.     __ucos2_heap = (char *)&bottom_of_heap;
  276.     return 0;
  277. }
  278. #endif /* __ADSONLY__ */
  279. /*
  280.   WIN32 sets up defaults for MS environment and compilers.
  281.   Otherwise defaults are for unix.
  282. */
  283. /* #define WIN32 */
  284. #ifdef WIN32
  285. #define WIN32_LEAN_AND_MEAN
  286. #include <windows.h>
  287. /* Win32 doesn't supply or need the following headers */
  288. #define LACKS_UNISTD_H
  289. #define LACKS_SYS_PARAM_H
  290. #define LACKS_SYS_MMAN_H
  291. /* Use the supplied emulation of sbrk */
  292. #define MORECORE sbrk
  293. #define MORECORE_CONTIGUOUS 1
  294. #define MORECORE_FAILURE    ((void*)(-1))
  295. /* Use the supplied emulation of mmap and munmap */
  296. #define HAVE_MMAP 1
  297. #define MUNMAP_FAILURE  (-1)
  298. #define MMAP_CLEARS 1
  299. /* These values don't really matter in windows mmap emulation */
  300. #define MAP_PRIVATE 1
  301. #define MAP_ANONYMOUS 2
  302. #define PROT_READ 1
  303. #define PROT_WRITE 2
  304. /* Emulation functions defined at the end of this file */
  305. /* If USE_MALLOC_LOCK, use supplied critical-section-based lock functions */
  306. #ifdef USE_MALLOC_LOCK
  307. static int slwait(int *sl);
  308. static int slrelease(int *sl);
  309. #endif
  310. static long getpagesize(void);
  311. static long getregionsize(void);
  312. static void *sbrk(long size);
  313. static void *mmap(void *ptr, long size, long prot, long type, long handle, long arg);
  314. static long munmap(void *ptr, long size);
  315. static void vminfo (unsigned long*free, unsigned long*reserved, unsigned long*committed);
  316. static int cpuinfo (int whole, unsigned long*kernel, unsigned long*user);
  317. #endif
  318. /*
  319.   __STD_C should be nonzero if using ANSI-standard C compiler, a C++
  320.   compiler, or a C compiler sufficiently close to ANSI to get away
  321.   with it.
  322. */
  323. #ifndef __STD_C
  324. #if defined(__STDC__) || defined(_cplusplus)
  325. #define __STD_C     1
  326. #else
  327. #define __STD_C     0
  328. #endif 
  329. #endif /*__STD_C*/
  330. /*
  331.   Void_t* is the pointer type that malloc should say it returns
  332. */
  333. #ifndef Void_t
  334. #if (__STD_C || defined(WIN32))
  335. #define Void_t      void
  336. #else
  337. #define Void_t      char
  338. #endif
  339. #endif /*Void_t*/
  340. #if __STD_C
  341. #include <stddef.h>   /* for size_t */
  342. #else
  343. #include <sys/types.h>
  344. #endif
  345. #ifdef __cplusplus
  346. extern "C" {
  347. #endif
  348. /* define LACKS_UNISTD_H if your system does not have a <unistd.h>. */
  349. /* #define  LACKS_UNISTD_H */
  350. #ifndef LACKS_UNISTD_H
  351. #include <unistd.h>
  352. #endif
  353. /* define LACKS_SYS_PARAM_H if your system does not have a <sys/param.h>. */
  354. /* #define  LACKS_SYS_PARAM_H */
  355. #include <stdio.h>    /* needed for malloc_stats */
  356. #include <errno.h>    /* needed for optional MALLOC_FAILURE_ACTION */
  357. /*
  358.   Debugging:
  359.   Because freed chunks may be overwritten with bookkeeping fields, this
  360.   malloc will often die when freed memory is overwritten by user
  361.   programs.  This can be very effective (albeit in an annoying way)
  362.   in helping track down dangling pointers.
  363.   If you compile with -DDEBUG, a number of assertion checks are
  364.   enabled that will catch more memory errors. You probably won't be
  365.   able to make much sense of the actual assertion errors, but they
  366.   should help you locate incorrectly overwritten memory.  The
  367.   checking is fairly extensive, and will slow down execution
  368.   noticeably. Calling malloc_stats or mallinfo with DEBUG set will
  369.   attempt to check every non-mmapped allocated and free chunk in the
  370.   course of computing the summmaries. (By nature, mmapped regions
  371.   cannot be checked very much automatically.)
  372.   Setting DEBUG may also be helpful if you are trying to modify
  373.   this code. The assertions in the check routines spell out in more
  374.   detail the assumptions and invariants underlying the algorithms.
  375.   Setting DEBUG does NOT provide an automated mechanism for checking
  376.   that all accesses to malloced memory stay within their
  377.   bounds. However, there are several add-ons and adaptations of this
  378.   or other mallocs available that do this.
  379. */
  380. #if DEBUG
  381. #include <assert.h>
  382. #else
  383. #define assert(x) ((void)0)
  384. #endif
  385. /*
  386.   The unsigned integer type used for comparing any two chunk sizes.
  387.   This should be at least as wide as size_t, but should not be signed.
  388. */
  389. #ifndef CHUNK_SIZE_T
  390. #define CHUNK_SIZE_T unsigned long
  391. #endif
  392. /* 
  393.   The unsigned integer type used to hold addresses when they are are
  394.   manipulated as integers. Except that it is not defined on all
  395.   systems, intptr_t would suffice.
  396. */
  397. #ifndef PTR_UINT
  398. #define PTR_UINT unsigned long
  399. #endif
  400. /*
  401.   INTERNAL_SIZE_T is the word-size used for internal bookkeeping
  402.   of chunk sizes.
  403.   The default version is the same as size_t.
  404.   While not strictly necessary, it is best to define this as an
  405.   unsigned type, even if size_t is a signed type. This may avoid some
  406.   artificial size limitations on some systems.
  407.   On a 64-bit machine, you may be able to reduce malloc overhead by
  408.   defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the
  409.   expense of not being able to handle more than 2^32 of malloced
  410.   space. If this limitation is acceptable, you are encouraged to set
  411.   this unless you are on a platform requiring 16byte alignments. In
  412.   this case the alignment requirements turn out to negate any
  413.   potential advantages of decreasing size_t word size.
  414.   Implementors: Beware of the possible combinations of:
  415.      - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,
  416.        and might be the same width as int or as long
  417.      - size_t might have different width and signedness as INTERNAL_SIZE_T
  418.      - int and long might be 32 or 64 bits, and might be the same width
  419.   To deal with this, most comparisons and difference computations
  420.   among INTERNAL_SIZE_Ts should cast them to CHUNK_SIZE_T, being
  421.   aware of the fact that casting an unsigned int to a wider long does
  422.   not sign-extend. (This also makes checking for negative numbers
  423.   awkward.) Some of these casts result in harmless compiler warnings
  424.   on some systems.
  425. */
  426. #ifndef INTERNAL_SIZE_T
  427. #define INTERNAL_SIZE_T size_t
  428. #endif
  429. /* The corresponding word size */
  430. #define SIZE_SZ                (sizeof(INTERNAL_SIZE_T))
  431. /*
  432.   MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.
  433.   It must be a power of two at least 2 * SIZE_SZ, even on machines
  434.   for which smaller alignments would suffice. It may be defined as
  435.   larger than this though. Note however that code and data structures
  436.   are optimized for the case of 8-byte alignment.
  437. */
  438. #ifndef MALLOC_ALIGNMENT
  439. #define MALLOC_ALIGNMENT       (2 * SIZE_SZ)
  440. #endif
  441. /* The corresponding bit mask value */
  442. #define MALLOC_ALIGN_MASK      (MALLOC_ALIGNMENT - 1)
  443. /*
  444.   REALLOC_ZERO_BYTES_FREES should be set if a call to
  445.   realloc with zero bytes should be the same as a call to free.
  446.   Some people think it should. Otherwise, since this malloc
  447.   returns a unique pointer for malloc(0), so does realloc(p, 0).
  448. */
  449. /*   #define REALLOC_ZERO_BYTES_FREES */
  450. /*
  451.   TRIM_FASTBINS controls whether free() of a very small chunk can
  452.   immediately lead to trimming. Setting to true (1) can reduce memory
  453.   footprint, but will almost always slow down programs that use a lot
  454.   of small chunks.
  455.   Define this only if you are willing to give up some speed to more
  456.   aggressively reduce system-level memory footprint when releasing
  457.   memory in programs that use many small chunks.  You can get
  458.   essentially the same effect by setting MXFAST to 0, but this can
  459.   lead to even greater slowdowns in programs using many small chunks.
  460.   TRIM_FASTBINS is an in-between compile-time option, that disables
  461.   only those chunks bordering topmost memory from being placed in
  462.   fastbins.
  463. */
  464. #ifndef TRIM_FASTBINS
  465. #define TRIM_FASTBINS  0
  466. #endif
  467. /*
  468.   USE_DL_PREFIX will prefix all public routines with the string 'dl'.
  469.   This is necessary when you only want to use this malloc in one part 
  470.   of a program, using your regular system malloc elsewhere.
  471. */
  472. /* #define USE_DL_PREFIX */
  473. /*
  474.   USE_MALLOC_LOCK causes wrapper functions to surround each
  475.   callable routine with pthread mutex lock/unlock.
  476.   USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined
  477. */
  478. /* #define USE_MALLOC_LOCK */
  479. /*
  480.   If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is
  481.   actually a wrapper function that first calls MALLOC_PREACTION, then
  482.   calls the internal routine, and follows it with
  483.   MALLOC_POSTACTION. This is needed for locking, but you can also use
  484.   this, without USE_MALLOC_LOCK, for purposes of interception,
  485.   instrumentation, etc. It is a sad fact that using wrappers often
  486.   noticeably degrades performance of malloc-intensive programs.
  487. */
  488. #ifdef USE_MALLOC_LOCK
  489. #define USE_PUBLIC_MALLOC_WRAPPERS
  490. #else
  491. /* #define USE_PUBLIC_MALLOC_WRAPPERS */
  492. #endif
  493. /* 
  494.    Two-phase name translation.
  495.    All of the actual routines are given mangled names.
  496.    When wrappers are used, they become the public callable versions.
  497.    When DL_PREFIX is used, the callable names are prefixed.
  498. */
  499. #ifndef USE_PUBLIC_MALLOC_WRAPPERS
  500. #define cALLOc      public_cALLOc
  501. #define fREe        public_fREe
  502. #define cFREe       public_cFREe
  503. #define mALLOc      public_mALLOc
  504. #define mEMALIGn    public_mEMALIGn
  505. #define rEALLOc     public_rEALLOc
  506. #define vALLOc      public_vALLOc
  507. #define pVALLOc     public_pVALLOc
  508. #define mALLINFo    public_mALLINFo
  509. #define mALLOPt     public_mALLOPt
  510. #define mTRIm       public_mTRIm
  511. #define mSTATs      public_mSTATs
  512. #define mUSABLe     public_mUSABLe
  513. #define iCALLOc     public_iCALLOc
  514. #define iCOMALLOc   public_iCOMALLOc
  515. #endif
  516. #ifdef USE_DL_PREFIX
  517. #define public_cALLOc    dlcalloc
  518. #define public_fREe      dlfree
  519. #define public_cFREe     dlcfree
  520. #define public_mALLOc    dlmalloc
  521. #define public_mEMALIGn  dlmemalign
  522. #define public_rEALLOc   dlrealloc
  523. #define public_vALLOc    dlvalloc
  524. #define public_pVALLOc   dlpvalloc
  525. #define public_mALLINFo  dlmallinfo
  526. #define public_mALLOPt   dlmallopt
  527. #define public_mTRIm     dlmalloc_trim
  528. #define public_mSTATs    dlmalloc_stats
  529. #define public_mUSABLe   dlmalloc_usable_size
  530. #define public_iCALLOc   dlindependent_calloc
  531. #define public_iCOMALLOc dlindependent_comalloc
  532. #else /* USE_DL_PREFIX */
  533. #define public_cALLOc    calloc
  534. #define public_fREe      free
  535. #define public_cFREe     cfree
  536. #define public_mALLOc    malloc
  537. #define public_mEMALIGn  memalign
  538. #define public_rEALLOc   realloc
  539. #define public_vALLOc    valloc
  540. #define public_pVALLOc   pvalloc
  541. #define public_mALLINFo  mallinfo
  542. #define public_mALLOPt   mallopt
  543. #define public_mTRIm     malloc_trim
  544. #define public_mSTATs    malloc_stats
  545. #define public_mUSABLe   malloc_usable_size
  546. #define public_iCALLOc   independent_calloc
  547. #define public_iCOMALLOc independent_comalloc
  548. #endif /* USE_DL_PREFIX */
  549. /*
  550.   HAVE_MEMCPY should be defined if you are not otherwise using
  551.   ANSI STD C, but still have memcpy and memset in your C library
  552.   and want to use them in calloc and realloc. Otherwise simple
  553.   macro versions are defined below.
  554.   USE_MEMCPY should be defined as 1 if you actually want to
  555.   have memset and memcpy called. People report that the macro
  556.   versions are faster than libc versions on some systems.
  557.   
  558.   Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks
  559.   (of <= 36 bytes) are manually unrolled in realloc and calloc.
  560. */
  561. #define HAVE_MEMCPY
  562. #ifndef USE_MEMCPY
  563. #ifdef HAVE_MEMCPY
  564. #define USE_MEMCPY 1
  565. #else
  566. #define USE_MEMCPY 0
  567. #endif
  568. #endif
  569. #if (__STD_C || defined(HAVE_MEMCPY))
  570. #ifdef WIN32
  571. /* On Win32 memset and memcpy are already declared in windows.h */
  572. #else
  573. #if __STD_C
  574. void* memset(void*, int, size_t);
  575. void* memcpy(void*, const void*, size_t);
  576. #else
  577. Void_t* memset();
  578. Void_t* memcpy();
  579. #endif
  580. #endif
  581. #endif
  582. /*
  583.   MALLOC_FAILURE_ACTION is the action to take before "return 0" when
  584.   malloc fails to be able to return memory, either because memory is
  585.   exhausted or because of illegal arguments.
  586.   
  587.   By default, sets errno if running on STD_C platform, else does nothing.  
  588. */
  589. #ifndef MALLOC_FAILURE_ACTION
  590. #if __STD_C
  591. #define MALLOC_FAILURE_ACTION 
  592.    errno = ENOMEM;
  593. #else
  594. #define MALLOC_FAILURE_ACTION
  595. #endif
  596. #endif
  597. /*
  598.   MORECORE-related declarations. By default, rely on sbrk
  599. */
  600. #ifdef LACKS_UNISTD_H
  601. #if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
  602. #if __STD_C
  603. extern Void_t*     sbrk(ptrdiff_t);
  604. #else
  605. extern Void_t*     sbrk();
  606. #endif
  607. #endif
  608. #endif
  609. /*
  610.   MORECORE is the name of the routine to call to obtain more memory
  611.   from the system.  See below for general guidance on writing
  612.   alternative MORECORE functions, as well as a version for WIN32 and a
  613.   sample version for pre-OSX macos.
  614. */
  615. #ifndef MORECORE
  616. #define MORECORE sbrk
  617. #endif
  618. /*
  619.   MORECORE_FAILURE is the value returned upon failure of MORECORE
  620.   as well as mmap. Since it cannot be an otherwise valid memory address,
  621.   and must reflect values of standard sys calls, you probably ought not
  622.   try to redefine it.
  623. */
  624. #ifndef MORECORE_FAILURE
  625. #define MORECORE_FAILURE (-1)
  626. #endif
  627. /*
  628.   If MORECORE_CONTIGUOUS is true, take advantage of fact that
  629.   consecutive calls to MORECORE with positive arguments always return
  630.   contiguous increasing addresses.  This is true of unix sbrk.  Even
  631.   if not defined, when regions happen to be contiguous, malloc will
  632.   permit allocations spanning regions obtained from different
  633.   calls. But defining this when applicable enables some stronger
  634.   consistency checks and space efficiencies. 
  635. */
  636. #ifndef MORECORE_CONTIGUOUS
  637. #define MORECORE_CONTIGUOUS 1
  638. #endif
  639. /*
  640.   Define MORECORE_CANNOT_TRIM if your version of MORECORE
  641.   cannot release space back to the system when given negative
  642.   arguments. This is generally necessary only if you are using
  643.   a hand-crafted MORECORE function that cannot handle negative arguments.
  644. */
  645. /* #define MORECORE_CANNOT_TRIM */
  646. /*
  647.   Define HAVE_MMAP as true to optionally make malloc() use mmap() to
  648.   allocate very large blocks.  These will be returned to the
  649.   operating system immediately after a free(). Also, if mmap
  650.   is available, it is used as a backup strategy in cases where
  651.   MORECORE fails to provide space from system.
  652.   This malloc is best tuned to work with mmap for large requests.
  653.   If you do not have mmap, operations involving very large chunks (1MB
  654.   or so) may be slower than you'd like.
  655. */
  656. #ifndef HAVE_MMAP
  657. #define HAVE_MMAP 1
  658. #endif
  659. #if HAVE_MMAP
  660. /* 
  661.    Standard unix mmap using /dev/zero clears memory so calloc doesn't
  662.    need to.
  663. */
  664. #ifndef MMAP_CLEARS
  665. #define MMAP_CLEARS 1
  666. #endif
  667. #else /* no mmap */
  668. #ifndef MMAP_CLEARS
  669. #define MMAP_CLEARS 0
  670. #endif
  671. #endif
  672. /* 
  673.    MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if
  674.    sbrk fails, and mmap is used as a backup (which is done only if
  675.    HAVE_MMAP).  The value must be a multiple of page size.  This
  676.    backup strategy generally applies only when systems have "holes" in
  677.    address space, so sbrk cannot perform contiguous expansion, but
  678.    there is still space available on system.  On systems for which
  679.    this is known to be useful (i.e. most linux kernels), this occurs
  680.    only when programs allocate huge amounts of memory.  Between this,
  681.    and the fact that mmap regions tend to be limited, the size should
  682.    be large, to avoid too many mmap calls and thus avoid running out
  683.    of kernel resources.
  684. */
  685. #ifndef MMAP_AS_MORECORE_SIZE
  686. #define MMAP_AS_MORECORE_SIZE (1024 * 1024)
  687. #endif
  688. /*
  689.   Define HAVE_MREMAP to make realloc() use mremap() to re-allocate
  690.   large blocks.  This is currently only possible on Linux with
  691.   kernel versions newer than 1.3.77.
  692. */
  693. #ifndef HAVE_MREMAP
  694. #ifdef linux
  695. #define HAVE_MREMAP 1
  696. #else
  697. #define HAVE_MREMAP 0
  698. #endif
  699. #endif /* HAVE_MMAP */
  700. /*
  701.   The system page size. To the extent possible, this malloc manages
  702.   memory from the system in page-size units.  Note that this value is
  703.   cached during initialization into a field of malloc_state. So even
  704.   if malloc_getpagesize is a function, it is only called once.
  705.   The following mechanics for getpagesize were adapted from bsd/gnu
  706.   getpagesize.h. If none of the system-probes here apply, a value of
  707.   4096 is used, which should be OK: If they don't apply, then using
  708.   the actual value probably doesn't impact performance.
  709. */
  710. #ifndef malloc_getpagesize
  711. #ifndef LACKS_UNISTD_H
  712. #  include <unistd.h>
  713. #endif
  714. #  ifdef _SC_PAGESIZE         /* some SVR4 systems omit an underscore */
  715. #    ifndef _SC_PAGE_SIZE
  716. #      define _SC_PAGE_SIZE _SC_PAGESIZE
  717. #    endif
  718. #  endif
  719. #  ifdef _SC_PAGE_SIZE
  720. #    define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
  721. #  else
  722. #    if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
  723.        extern size_t getpagesize();
  724. #      define malloc_getpagesize getpagesize()
  725. #    else
  726. #      ifdef WIN32 /* use supplied emulation of getpagesize */
  727. #        define malloc_getpagesize getpagesize() 
  728. #      else
  729. #        ifndef LACKS_SYS_PARAM_H
  730. #          include <sys/param.h>
  731. #        endif
  732. #        ifdef EXEC_PAGESIZE
  733. #          define malloc_getpagesize EXEC_PAGESIZE
  734. #        else
  735. #          ifdef NBPG
  736. #            ifndef CLSIZE
  737. #              define malloc_getpagesize NBPG
  738. #            else
  739. #              define malloc_getpagesize (NBPG * CLSIZE)
  740. #            endif
  741. #          else
  742. #            ifdef NBPC
  743. #              define malloc_getpagesize NBPC
  744. #            else
  745. #              ifdef PAGESIZE
  746. #                define malloc_getpagesize PAGESIZE
  747. #              else /* just guess */
  748. #                define malloc_getpagesize (4096) 
  749. #              endif
  750. #            endif
  751. #          endif
  752. #        endif
  753. #      endif
  754. #    endif
  755. #  endif
  756. #endif
  757. /*
  758.   This version of malloc supports the standard SVID/XPG mallinfo
  759.   routine that returns a struct containing usage properties and
  760.   statistics. It should work on any SVID/XPG compliant system that has
  761.   a /usr/include/malloc.h defining struct mallinfo. (If you'd like to
  762.   install such a thing yourself, cut out the preliminary declarations
  763.   as described above and below and save them in a malloc.h file. But
  764.   there's no compelling reason to bother to do this.)
  765.   The main declaration needed is the mallinfo struct that is returned
  766.   (by-copy) by mallinfo().  The SVID/XPG malloinfo struct contains a
  767.   bunch of fields that are not even meaningful in this version of
  768.   malloc.  These fields are are instead filled by mallinfo() with
  769.   other numbers that might be of interest.
  770.   HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
  771.   /usr/include/malloc.h file that includes a declaration of struct
  772.   mallinfo.  If so, it is included; else an SVID2/XPG2 compliant
  773.   version is declared below.  These must be precisely the same for
  774.   mallinfo() to work.  The original SVID version of this struct,
  775.   defined on most systems with mallinfo, declares all fields as
  776.   ints. But some others define as unsigned long. If your system
  777.   defines the fields using a type of different width than listed here,
  778.   you must #include your system version and #define
  779.   HAVE_USR_INCLUDE_MALLOC_H.
  780. */
  781. /* #define HAVE_USR_INCLUDE_MALLOC_H */
  782. #ifdef HAVE_USR_INCLUDE_MALLOC_H
  783. #include "/usr/include/malloc.h"
  784. #else
  785. /* SVID2/XPG mallinfo structure */
  786. struct mallinfo {
  787.   int arena;    /* non-mmapped space allocated from system */
  788.   int ordblks;  /* number of free chunks */
  789.   int smblks;   /* number of fastbin blocks */
  790.   int hblks;    /* number of mmapped regions */
  791.   int hblkhd;   /* space in mmapped regions */
  792.   int usmblks;  /* maximum total allocated space */
  793.   int fsmblks;  /* space available in freed fastbin blocks */
  794.   int uordblks; /* total allocated space */
  795.   int fordblks; /* total free space */
  796.   int keepcost; /* top-most, releasable (via malloc_trim) space */
  797. };
  798. /*
  799.   SVID/XPG defines four standard parameter numbers for mallopt,
  800.   normally defined in malloc.h.  Only one of these (M_MXFAST) is used
  801.   in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
  802.   so setting them has no effect. But this malloc also supports other
  803.   options in mallopt described below.
  804. */
  805. #endif
  806. /* ---------- description of public routines ------------ */
  807. /*
  808.   malloc(size_t n)
  809.   Returns a pointer to a newly allocated chunk of at least n bytes, or null
  810.   if no space is available. Additionally, on failure, errno is
  811.   set to ENOMEM on ANSI C systems.
  812.   If n is zero, malloc returns a minumum-sized chunk. (The minimum
  813.   size is 16 bytes on most 32bit systems, and 24 or 32 bytes on 64bit
  814.   systems.)  On most systems, size_t is an unsigned type, so calls
  815.   with negative arguments are interpreted as requests for huge amounts
  816.   of space, which will often fail. The maximum supported value of n
  817.   differs across systems, but is in all cases less than the maximum
  818.   representable value of a size_t.
  819. */
  820. #if __STD_C
  821. Void_t*  public_mALLOc(size_t);
  822. #else
  823. Void_t*  public_mALLOc();
  824. #endif
  825. /*
  826.   free(Void_t* p)
  827.   Releases the chunk of memory pointed to by p, that had been previously
  828.   allocated using malloc or a related routine such as realloc.
  829.   It has no effect if p is null. It can have arbitrary (i.e., bad!)
  830.   effects if p has already been freed.
  831.   Unless disabled (using mallopt), freeing very large spaces will
  832.   when possible, automatically trigger operations that give
  833.   back unused memory to the system, thus reducing program footprint.
  834. */
  835. #if __STD_C
  836. void     public_fREe(Void_t*);
  837. #else
  838. void     public_fREe();
  839. #endif
  840. /*
  841.   calloc(size_t n_elements, size_t element_size);
  842.   Returns a pointer to n_elements * element_size bytes, with all locations
  843.   set to zero.
  844. */
  845. #if __STD_C
  846. Void_t*  public_cALLOc(size_t, size_t);
  847. #else
  848. Void_t*  public_cALLOc();
  849. #endif
  850. /*
  851.   realloc(Void_t* p, size_t n)
  852.   Returns a pointer to a chunk of size n that contains the same data
  853.   as does chunk p up to the minimum of (n, p's size) bytes, or null
  854.   if no space is available. 
  855.   The returned pointer may or may not be the same as p. The algorithm
  856.   prefers extending p when possible, otherwise it employs the
  857.   equivalent of a malloc-copy-free sequence.
  858.   If p is null, realloc is equivalent to malloc.  
  859.   If space is not available, realloc returns null, errno is set (if on
  860.   ANSI) and p is NOT freed.
  861.   if n is for fewer bytes than already held by p, the newly unused
  862.   space is lopped off and freed if possible.  Unless the #define
  863.   REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of
  864.   zero (re)allocates a minimum-sized chunk.
  865.   Large chunks that were internally obtained via mmap will always
  866.   be reallocated using malloc-copy-free sequences unless
  867.   the system supports MREMAP (currently only linux).
  868.   The old unix realloc convention of allowing the last-free'd chunk
  869.   to be used as an argument to realloc is not supported.
  870. */
  871. #if __STD_C
  872. Void_t*  public_rEALLOc(Void_t*, size_t);
  873. #else
  874. Void_t*  public_rEALLOc();
  875. #endif
  876. /*
  877.   memalign(size_t alignment, size_t n);
  878.   Returns a pointer to a newly allocated chunk of n bytes, aligned
  879.   in accord with the alignment argument.
  880.   The alignment argument should be a power of two. If the argument is
  881.   not a power of two, the nearest greater power is used.
  882.   8-byte alignment is guaranteed by normal malloc calls, so don't
  883.   bother calling memalign with an argument of 8 or less.
  884.   Overreliance on memalign is a sure way to fragment space.
  885. */
  886. #if __STD_C
  887. Void_t*  public_mEMALIGn(size_t, size_t);
  888. #else
  889. Void_t*  public_mEMALIGn();
  890. #endif
  891. /*
  892.   valloc(size_t n);
  893.   Equivalent to memalign(pagesize, n), where pagesize is the page
  894.   size of the system. If the pagesize is unknown, 4096 is used.
  895. */
  896. #if __STD_C
  897. Void_t*  public_vALLOc(size_t);
  898. #else
  899. Void_t*  public_vALLOc();
  900. #endif
  901. /*
  902.   mallopt(int parameter_number, int parameter_value)
  903.   Sets tunable parameters The format is to provide a
  904.   (parameter-number, parameter-value) pair.  mallopt then sets the
  905.   corresponding parameter to the argument value if it can (i.e., so
  906.   long as the value is meaningful), and returns 1 if successful else
  907.   0.  SVID/XPG/ANSI defines four standard param numbers for mallopt,
  908.   normally defined in malloc.h.  Only one of these (M_MXFAST) is used
  909.   in this malloc. The others (M_NLBLKS, M_GRAIN, M_KEEP) don't apply,
  910.   so setting them has no effect. But this malloc also supports four
  911.   other options in mallopt. See below for details.  Briefly, supported
  912.   parameters are as follows (listed defaults are for "typical"
  913.   configurations).
  914.   Symbol            param #   default    allowed param values
  915.   M_MXFAST          1         64         0-80  (0 disables fastbins)
  916.   M_TRIM_THRESHOLD -1         256*1024   any   (-1U disables trimming)
  917.   M_TOP_PAD        -2         0          any  
  918.   M_MMAP_THRESHOLD -3         256*1024   any   (or 0 if no MMAP support)
  919.   M_MMAP_MAX       -4         65536      any   (0 disables use of mmap)
  920. */
  921. #if __STD_C
  922. int      public_mALLOPt(int, int);
  923. #else
  924. int      public_mALLOPt();
  925. #endif
  926. #if 0
  927. /*
  928.   mallinfo()
  929.   Returns (by copy) a struct containing various summary statistics:
  930.   arena:     current total non-mmapped bytes allocated from system 
  931.   ordblks:   the number of free chunks 
  932.   smblks:    the number of fastbin blocks (i.e., small chunks that
  933.                have been freed but not use resused or consolidated)
  934.   hblks:     current number of mmapped regions 
  935.   hblkhd:    total bytes held in mmapped regions 
  936.   usmblks:   the maximum total allocated space. This will be greater
  937.                 than current total if trimming has occurred.
  938.   fsmblks:   total bytes held in fastbin blocks 
  939.   uordblks:  current total allocated space (normal or mmapped)
  940.   fordblks:  total free space 
  941.   keepcost:  the maximum number of bytes that could ideally be released
  942.                back to system via malloc_trim. ("ideally" means that
  943.                it ignores page restrictions etc.)
  944.   Because these fields are ints, but internal bookkeeping may
  945.   be kept as longs, the reported values may wrap around zero and 
  946.   thus be inaccurate.
  947. */
  948. #if __STD_C
  949. struct mallinfo public_mALLINFo(void);
  950. #else
  951. struct mallinfo public_mALLINFo();
  952. #endif
  953. /*
  954.   independent_calloc(size_t n_elements, size_t element_size, Void_t* chunks[]);
  955.   independent_calloc is similar to calloc, but instead of returning a
  956.   single cleared space, it returns an array of pointers to n_elements
  957.   independent elements that can hold contents of size elem_size, each
  958.   of which starts out cleared, and can be independently freed,
  959.   realloc'ed etc. The elements are guaranteed to be adjacently
  960.   allocated (this is not guaranteed to occur with multiple callocs or
  961.   mallocs), which may also improve cache locality in some
  962.   applications.
  963.   The "chunks" argument is optional (i.e., may be null, which is
  964.   probably the most typical usage). If it is null, the returned array
  965.   is itself dynamically allocated and should also be freed when it is
  966.   no longer needed. Otherwise, the chunks array must be of at least
  967.   n_elements in length. It is filled in with the pointers to the
  968.   chunks.
  969.   In either case, independent_calloc returns this pointer array, or
  970.   null if the allocation failed.  If n_elements is zero and "chunks"
  971.   is null, it returns a chunk representing an array with zero elements
  972.   (which should be freed if not wanted).
  973.   Each element must be individually freed when it is no longer
  974.   needed. If you'd like to instead be able to free all at once, you
  975.   should instead use regular calloc and assign pointers into this
  976.   space to represent elements.  (In this case though, you cannot
  977.   independently free elements.)
  978.   
  979.   independent_calloc simplifies and speeds up implementations of many
  980.   kinds of pools.  It may also be useful when constructing large data
  981.   structures that initially have a fixed number of fixed-sized nodes,
  982.   but the number is not known at compile time, and some of the nodes
  983.   may later need to be freed. For example:
  984.   struct Node { int item; struct Node* next; };
  985.   
  986.   struct Node* build_list() {
  987.     struct Node** pool;
  988.     int n = read_number_of_nodes_needed();
  989.     if (n <= 0) return 0;
  990.     pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
  991.     if (pool == 0) die(); 
  992.     // organize into a linked list... 
  993.     struct Node* first = pool[0];
  994.     for (i = 0; i < n-1; ++i) 
  995.       pool[i]->next = pool[i+1];
  996.     free(pool);     // Can now free the array (or not, if it is needed later)
  997.     return first;
  998.   }
  999. */
  1000. #if __STD_C
  1001. Void_t** public_iCALLOc(size_t, size_t, Void_t**);
  1002. #else
  1003. Void_t** public_iCALLOc();
  1004. #endif
  1005. /*
  1006.   independent_comalloc(size_t n_elements, size_t sizes[], Void_t* chunks[]);
  1007.   independent_comalloc allocates, all at once, a set of n_elements
  1008.   chunks with sizes indicated in the "sizes" array.    It returns
  1009.   an array of pointers to these elements, each of which can be
  1010.   independently freed, realloc'ed etc. The elements are guaranteed to
  1011.   be adjacently allocated (this is not guaranteed to occur with
  1012.   multiple callocs or mallocs), which may also improve cache locality
  1013.   in some applications.
  1014.   The "chunks" argument is optional (i.e., may be null). If it is null
  1015.   the returned array is itself dynamically allocated and should also
  1016.   be freed when it is no longer needed. Otherwise, the chunks array
  1017.   must be of at least n_elements in length. It is filled in with the
  1018.   pointers to the chunks.
  1019.   In either case, independent_comalloc returns this pointer array, or
  1020.   null if the allocation failed.  If n_elements is zero and chunks is
  1021.   null, it returns a chunk representing an array with zero elements
  1022.   (which should be freed if not wanted).
  1023.   
  1024.   Each element must be individually freed when it is no longer
  1025.   needed. If you'd like to instead be able to free all at once, you
  1026.   should instead use a single regular malloc, and assign pointers at
  1027.   particular offsets in the aggregate space. (In this case though, you 
  1028.   cannot independently free elements.)
  1029.   independent_comallac differs from independent_calloc in that each
  1030.   element may have a different size, and also that it does not
  1031.   automatically clear elements.
  1032.   independent_comalloc can be used to speed up allocation in cases
  1033.   where several structs or objects must always be allocated at the
  1034.   same time.  For example:
  1035.   struct Head { ... }
  1036.   struct Foot { ... }
  1037.   void send_message(char* msg) {
  1038.     int msglen = strlen(msg);
  1039.     size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
  1040.     void* chunks[3];
  1041.     if (independent_comalloc(3, sizes, chunks) == 0)
  1042.       die();
  1043.     struct Head* head = (struct Head*)(chunks[0]);
  1044.     char*        body = (char*)(chunks[1]);
  1045.     struct Foot* foot = (struct Foot*)(chunks[2]);
  1046.     // ...
  1047.   }
  1048.   In general though, independent_comalloc is worth using only for
  1049.   larger values of n_elements. For small values, you probably won't
  1050.   detect enough difference from series of malloc calls to bother.
  1051.   Overuse of independent_comalloc can increase overall memory usage,
  1052.   since it cannot reuse existing noncontiguous small chunks that
  1053.   might be available for some of the elements.
  1054. */
  1055. #if __STD_C
  1056. Void_t** public_iCOMALLOc(size_t, size_t*, Void_t**);
  1057. #else
  1058. Void_t** public_iCOMALLOc();
  1059. #endif
  1060. /*
  1061.   pvalloc(size_t n);
  1062.   Equivalent to valloc(minimum-page-that-holds(n)), that is,
  1063.   round up n to nearest pagesize.
  1064.  */
  1065. #if __STD_C
  1066. Void_t*  public_pVALLOc(size_t);
  1067. #else
  1068. Void_t*  public_pVALLOc();
  1069. #endif
  1070. /*
  1071.   cfree(Void_t* p);
  1072.   Equivalent to free(p).
  1073.   cfree is needed/defined on some systems that pair it with calloc,
  1074.   for odd historical reasons (such as: cfree is used in example 
  1075.   code in the first edition of K&R).
  1076. */
  1077. #if __STD_C
  1078. void     public_cFREe(Void_t*);
  1079. #else
  1080. void     public_cFREe();
  1081. #endif
  1082. /*
  1083.   malloc_trim(size_t pad);
  1084.   If possible, gives memory back to the system (via negative
  1085.   arguments to sbrk) if there is unused memory at the `high' end of
  1086.   the malloc pool. You can call this after freeing large blocks of
  1087.   memory to potentially reduce the system-level memory requirements
  1088.   of a program. However, it cannot guarantee to reduce memory. Under
  1089.   some allocation patterns, some large free blocks of memory will be
  1090.   locked between two used chunks, so they cannot be given back to
  1091.   the system.
  1092.   
  1093.   The `pad' argument to malloc_trim represents the amount of free
  1094.   trailing space to leave untrimmed. If this argument is zero,
  1095.   only the minimum amount of memory to maintain internal data
  1096.   structures will be left (one page or less). Non-zero arguments
  1097.   can be supplied to maintain enough trailing space to service
  1098.   future expected allocations without having to re-obtain memory
  1099.   from the system.
  1100.   
  1101.   Malloc_trim returns 1 if it actually released any memory, else 0.
  1102.   On systems that do not support "negative sbrks", it will always
  1103.   rreturn 0.
  1104. */
  1105. #if __STD_C
  1106. int      public_mTRIm(size_t);
  1107. #else
  1108. int      public_mTRIm();
  1109. #endif
  1110. /*
  1111.   malloc_usable_size(Void_t* p);
  1112.   Returns the number of bytes you can actually use in
  1113.   an allocated chunk, which may be more than you requested (although
  1114.   often not) due to alignment and minimum size constraints.
  1115.   You can use this many bytes without worrying about
  1116.   overwriting other allocated objects. This is not a particularly great
  1117.   programming practice. malloc_usable_size can be more useful in
  1118.   debugging and assertions, for example:
  1119.   p = malloc(n);
  1120.   assert(malloc_usable_size(p) >= 256);
  1121. */
  1122. #if __STD_C
  1123. size_t   public_mUSABLe(Void_t*);
  1124. #else
  1125. size_t   public_mUSABLe();
  1126. #endif
  1127. /*
  1128.   malloc_stats();
  1129.   Prints on stderr the amount of space obtained from the system (both
  1130.   via sbrk and mmap), the maximum amount (which may be more than
  1131.   current if malloc_trim and/or munmap got called), and the current
  1132.   number of bytes allocated via malloc (or realloc, etc) but not yet
  1133.   freed. Note that this is the number of bytes allocated, not the
  1134.   number requested. It will be larger than the number requested
  1135.   because of alignment and bookkeeping overhead. Because it includes
  1136.   alignment wastage as being in use, this figure may be greater than
  1137.   zero even when no user-level chunks are allocated.
  1138.   The reported current and maximum system memory can be inaccurate if
  1139.   a program makes other calls to system memory allocation functions
  1140.   (normally sbrk) outside of malloc.
  1141.   malloc_stats prints only the most commonly interesting statistics.
  1142.   More information can be obtained by calling mallinfo.
  1143. */
  1144. #if __STD_C
  1145. void     public_mSTATs();
  1146. #else
  1147. void     public_mSTATs();
  1148. #endif
  1149. #endif
  1150. /* mallopt tuning options */
  1151. /*
  1152.   M_MXFAST is the maximum request size used for "fastbins", special bins
  1153.   that hold returned chunks without consolidating their spaces. This
  1154.   enables future requests for chunks of the same size to be handled
  1155.   very quickly, but can increase fragmentation, and thus increase the
  1156.   overall memory footprint of a program.
  1157.   This malloc manages fastbins very conservatively yet still
  1158.   efficiently, so fragmentation is rarely a problem for values less
  1159.   than or equal to the default.  The maximum supported value of MXFAST
  1160.   is 80. You wouldn't want it any higher than this anyway.  Fastbins
  1161.   are designed especially for use with many small structs, objects or
  1162.   strings -- the default handles structs/objects/arrays with sizes up
  1163.   to 16 4byte fields, or small strings representing words, tokens,
  1164.   etc. Using fastbins for larger objects normally worsens
  1165.   fragmentation without improving speed.
  1166.   M_MXFAST is set in REQUEST size units. It is internally used in
  1167.   chunksize units, which adds padding and alignment.  You can reduce
  1168.   M_MXFAST to 0 to disable all use of fastbins.  This causes the malloc
  1169.   algorithm to be a closer approximation of fifo-best-fit in all cases,
  1170.   not just for larger requests, but will generally cause it to be
  1171.   slower.
  1172. */
  1173. /* M_MXFAST is a standard SVID/XPG tuning option, usually listed in malloc.h */
  1174. #ifndef M_MXFAST
  1175. #define M_MXFAST            1    
  1176. #endif
  1177. #ifndef DEFAULT_MXFAST
  1178. #define DEFAULT_MXFAST     64
  1179. #endif
  1180. /*
  1181.   M_TRIM_THRESHOLD is the maximum amount of unused top-most memory
  1182.   to keep before releasing via malloc_trim in free().
  1183.   Automatic trimming is mainly useful in long-lived programs.
  1184.   Because trimming via sbrk can be slow on some systems, and can
  1185.   sometimes be wasteful (in cases where programs immediately
  1186.   afterward allocate more large chunks) the value should be high
  1187.   enough so that your overall system performance would improve by
  1188.   releasing this much memory.
  1189.   The trim threshold and the mmap control parameters (see below)
  1190.   can be traded off with one another. Trimming and mmapping are
  1191.   two different ways of releasing unused memory back to the
  1192.   system. Between these two, it is often possible to keep
  1193.   system-level demands of a long-lived program down to a bare
  1194.   minimum. For example, in one test suite of sessions measuring
  1195.   the XF86 X server on Linux, using a trim threshold of 128K and a
  1196.   mmap threshold of 192K led to near-minimal long term resource
  1197.   consumption.
  1198.   If you are using this malloc in a long-lived program, it should
  1199.   pay to experiment with these values.  As a rough guide, you
  1200.   might set to a value close to the average size of a process
  1201.   (program) running on your system.  Releasing this much memory
  1202.   would allow such a process to run in memory.  Generally, it's
  1203.   worth it to tune for trimming rather tham memory mapping when a
  1204.   program undergoes phases where several large chunks are
  1205.   allocated and released in ways that can reuse each other's
  1206.   storage, perhaps mixed with phases where there are no such
  1207.   chunks at all.  And in well-behaved long-lived programs,
  1208.   controlling release of large blocks via trimming versus mapping
  1209.   is usually faster.
  1210.   However, in most programs, these parameters serve mainly as
  1211.   protection against the system-level effects of carrying around
  1212.   massive amounts of unneeded memory. Since frequent calls to
  1213.   sbrk, mmap, and munmap otherwise degrade performance, the default
  1214.   parameters are set to relatively high values that serve only as
  1215.   safeguards.
  1216.   The trim value must be greater than page size to have any useful
  1217.   effect.  To disable trimming completely, you can set to 
  1218.   (unsigned long)(-1)
  1219.   Trim settings interact with fastbin (MXFAST) settings: Unless
  1220.   TRIM_FASTBINS is defined, automatic trimming never takes place upon
  1221.   freeing a chunk with size less than or equal to MXFAST. Trimming is
  1222.   instead delayed until subsequent freeing of larger chunks. However,
  1223.   you can still force an attempted trim by calling malloc_trim.
  1224.   Also, trimming is not generally possible in cases where
  1225.   the main arena is obtained via mmap.
  1226.   Note that the trick some people use of mallocing a huge space and
  1227.   then freeing it at program startup, in an attempt to reserve system
  1228.   memory, doesn't have the intended effect under automatic trimming,
  1229.   since that memory will immediately be returned to the system.
  1230. */
  1231. #define M_TRIM_THRESHOLD       -1
  1232. #ifndef DEFAULT_TRIM_THRESHOLD
  1233. #define DEFAULT_TRIM_THRESHOLD (256 * 1024)
  1234. #endif
  1235. /*
  1236.   M_TOP_PAD is the amount of extra `padding' space to allocate or
  1237.   retain whenever sbrk is called. It is used in two ways internally:
  1238.   * When sbrk is called to extend the top of the arena to satisfy
  1239.   a new malloc request, this much padding is added to the sbrk
  1240.   request.
  1241.   * When malloc_trim is called automatically from free(),
  1242.   it is used as the `pad' argument.
  1243.   In both cases, the actual amount of padding is rounded
  1244.   so that the end of the arena is always a system page boundary.
  1245.   The main reason for using padding is to avoid calling sbrk so
  1246.   often. Having even a small pad greatly reduces the likelihood
  1247.   that nearly every malloc request during program start-up (or
  1248.   after trimming) will invoke sbrk, which needlessly wastes
  1249.   time.
  1250.   Automatic rounding-up to page-size units is normally sufficient
  1251.   to avoid measurable overhead, so the default is 0.  However, in
  1252.   systems where sbrk is relatively slow, it can pay to increase
  1253.   this value, at the expense of carrying around more memory than
  1254.   the program needs.
  1255. */
  1256. #define M_TOP_PAD              -2
  1257. #ifndef DEFAULT_TOP_PAD
  1258. #define DEFAULT_TOP_PAD        (0)
  1259. #endif
  1260. /*
  1261.   M_MMAP_THRESHOLD is the request size threshold for using mmap()
  1262.   to service a request. Requests of at least this size that cannot
  1263.   be allocated using already-existing space will be serviced via mmap.
  1264.   (If enough normal freed space already exists it is used instead.)
  1265.   Using mmap segregates relatively large chunks of memory so that
  1266.   they can be individually obtained and released from the host
  1267.   system. A request serviced through mmap is never reused by any
  1268.   other request (at least not directly; the system may just so
  1269.   happen to remap successive requests to the same locations).
  1270.   Segregating space in this way has the benefits that:
  1271.    1. Mmapped space can ALWAYS be individually released back 
  1272.       to the system, which helps keep the system level memory 
  1273.       demands of a long-lived program low. 
  1274.    2. Mapped memory can never become `locked' between
  1275.       other chunks, as can happen with normally allocated chunks, which
  1276.       means that even trimming via malloc_trim would not release them.
  1277.    3. On some systems with "holes" in address spaces, mmap can obtain
  1278.       memory that sbrk cannot.
  1279.   However, it has the disadvantages that:
  1280.    1. The space cannot be reclaimed, consolidated, and then
  1281.       used to service later requests, as happens with normal chunks.
  1282.    2. It can lead to more wastage because of mmap page alignment
  1283.       requirements
  1284.    3. It causes malloc performance to be more dependent on host
  1285.       system memory management support routines which may vary in
  1286.       implementation quality and may impose arbitrary
  1287.       limitations. Generally, servicing a request via normal
  1288.       malloc steps is faster than going through a system's mmap.
  1289.   The advantages of mmap nearly always outweigh disadvantages for
  1290.   "large" chunks, but the value of "large" varies across systems.  The
  1291.   default is an empirically derived value that works well in most
  1292.   systems.
  1293. */
  1294. #define M_MMAP_THRESHOLD      -3
  1295. #ifndef DEFAULT_MMAP_THRESHOLD
  1296. #define DEFAULT_MMAP_THRESHOLD (256 * 1024)
  1297. #endif
  1298. /*
  1299.   M_MMAP_MAX is the maximum number of requests to simultaneously
  1300.   service using mmap. This parameter exists because
  1301. . Some systems have a limited number of internal tables for
  1302.   use by mmap, and using more than a few of them may degrade
  1303.   performance.
  1304.   The default is set to a value that serves only as a safeguard.
  1305.   Setting to 0 disables use of mmap for servicing large requests.  If
  1306.   HAVE_MMAP is not set, the default value is 0, and attempts to set it
  1307.   to non-zero values in mallopt will fail.
  1308. */
  1309. #define M_MMAP_MAX             -4
  1310. #ifndef DEFAULT_MMAP_MAX
  1311. #if HAVE_MMAP
  1312. #define DEFAULT_MMAP_MAX       (65536)
  1313. #else
  1314. #define DEFAULT_MMAP_MAX       (0)
  1315. #endif
  1316. #endif
  1317. #ifdef __cplusplus
  1318. };  /* end of extern "C" */
  1319. #endif
  1320. /* 
  1321.   ========================================================================
  1322.   To make a fully customizable malloc.h header file, cut everything
  1323.   above this line, put into file malloc.h, edit to suit, and #include it 
  1324.   on the next line, as well as in programs that use this malloc.
  1325.   ========================================================================
  1326. */
  1327. /* #include "malloc.h" */
  1328. /* --------------------- public wrappers ---------------------- */
  1329. #ifdef USE_PUBLIC_MALLOC_WRAPPERS
  1330. /* Declare all routines as internal */
  1331. #if __STD_C
  1332. static Void_t*  mALLOc(size_t);
  1333. static void     fREe(Void_t*);
  1334. static Void_t*  rEALLOc(Void_t*, size_t);
  1335. static Void_t*  mEMALIGn(size_t, size_t);
  1336. static Void_t*  vALLOc(size_t);
  1337. static Void_t*  cALLOc(size_t, size_t);
  1338. #if 0
  1339. static Void_t*  pVALLOc(size_t);
  1340. static Void_t** iCALLOc(size_t, size_t, Void_t**);
  1341. static Void_t** iCOMALLOc(size_t, size_t*, Void_t**);
  1342. static void     cFREe(Void_t*);
  1343. static int      mTRIm(size_t);
  1344. static size_t   mUSABLe(Void_t*);
  1345. static void     mSTATs(void);
  1346. static int      mALLOPt(int, int);
  1347. static struct mallinfo mALLINFo(void);
  1348. #endif
  1349. #else
  1350. static Void_t*  mALLOc();
  1351. static void     fREe();
  1352. static Void_t*  rEALLOc();
  1353. static Void_t*  mEMALIGn();
  1354. static Void_t*  vALLOc();
  1355. static Void_t*  pVALLOc();
  1356. static Void_t*  cALLOc();
  1357. static Void_t** iCALLOc();
  1358. static Void_t** iCOMALLOc();
  1359. static void     cFREe();
  1360. static int      mTRIm();
  1361. static size_t   mUSABLe();
  1362. static void     mSTATs();
  1363. static int      mALLOPt();
  1364. static struct mallinfo mALLINFo();
  1365. #endif
  1366. /*
  1367.   MALLOC_PREACTION and MALLOC_POSTACTION should be
  1368.   defined to return 0 on success, and nonzero on failure.
  1369.   The return value of MALLOC_POSTACTION is currently ignored
  1370.   in wrapper functions since there is no reasonable default
  1371.   action to take on failure.
  1372. */
  1373. #ifdef USE_MALLOC_LOCK
  1374. #ifdef __UCOSII__
  1375. #define MALLOC_PREACTION   __ucos2_mutex_lock()
  1376. #define MALLOC_POSTACTION  __ucos2_mutex_unlock()
  1377. #elif defined(WIN32)
  1378. static int mALLOC_MUTEx;
  1379. #define MALLOC_PREACTION   slwait(&mALLOC_MUTEx)
  1380. #define MALLOC_POSTACTION  slrelease(&mALLOC_MUTEx)
  1381. #else
  1382. #include <pthread.h>
  1383. static pthread_mutex_t mALLOC_MUTEx = PTHREAD_MUTEX_INITIALIZER;
  1384. #define MALLOC_PREACTION   pthread_mutex_lock(&mALLOC_MUTEx)
  1385. #define MALLOC_POSTACTION  pthread_mutex_unlock(&mALLOC_MUTEx)
  1386. #endif /* USE_MALLOC_LOCK */
  1387. #else
  1388. /* Substitute anything you like for these */
  1389. #define MALLOC_PREACTION   (0)
  1390. #define MALLOC_POSTACTION  (0)
  1391. #endif
  1392. Void_t* public_mALLOc(size_t bytes) {
  1393.   Void_t* m;
  1394.   if (MALLOC_PREACTION != 0) {
  1395.     return 0;
  1396.   }
  1397.   m = mALLOc(bytes);
  1398.   if (MALLOC_POSTACTION != 0) {
  1399.   }
  1400.   return m;
  1401. }
  1402. void public_fREe(Void_t* m) {
  1403.   if (MALLOC_PREACTION != 0) {
  1404.     return;
  1405.   }
  1406.   fREe(m);
  1407.   if (MALLOC_POSTACTION != 0) {
  1408.   }
  1409. }
  1410. Void_t* public_rEALLOc(Void_t* m, size_t bytes) {
  1411.   if (MALLOC_PREACTION != 0) {
  1412.     return 0;
  1413.   }
  1414.   m = rEALLOc(m, bytes);
  1415.   if (MALLOC_POSTACTION != 0) {
  1416.   }
  1417.   return m;
  1418. }
  1419. Void_t* public_mEMALIGn(size_t alignment, size_t bytes) {
  1420.   Void_t* m;
  1421.   if (MALLOC_PREACTION != 0) {
  1422.     return 0;
  1423.   }
  1424.   m = mEMALIGn(alignment, bytes);
  1425.   if (MALLOC_POSTACTION != 0) {
  1426.   }
  1427.   return m;
  1428. }
  1429. Void_t* public_vALLOc(size_t bytes) {
  1430.   Void_t* m;
  1431.   if (MALLOC_PREACTION != 0) {
  1432.     return 0;
  1433.   }
  1434.   m = vALLOc(bytes);
  1435.   if (MALLOC_POSTACTION != 0) {
  1436.   }
  1437.   return m;
  1438. }
  1439. Void_t* public_cALLOc(size_t n, size_t elem_size) {
  1440.   Void_t* m;
  1441.   if (MALLOC_PREACTION != 0) {
  1442.     return 0;
  1443.   }
  1444.   m = cALLOc(n, elem_size);
  1445.   if (MALLOC_POSTACTION != 0) {
  1446.   }
  1447.   return m;
  1448. }
  1449. #if 0
  1450. Void_t* public_pVALLOc(size_t bytes) {
  1451.   Void_t* m;
  1452.   if (MALLOC_PREACTION != 0) {
  1453.     return 0;
  1454.   }
  1455.   m = pVALLOc(bytes);
  1456.   if (MALLOC_POSTACTION != 0) {
  1457.   }
  1458.   return m;
  1459. }
  1460. Void_t** public_iCALLOc(size_t n, size_t elem_size, Void_t** chunks) {
  1461.   Void_t** m;
  1462.   if (MALLOC_PREACTION != 0) {
  1463.     return 0;
  1464.   }
  1465.   m = iCALLOc(n, elem_size, chunks);
  1466.   if (MALLOC_POSTACTION != 0) {
  1467.   }
  1468.   return m;
  1469. }
  1470. Void_t** public_iCOMALLOc(size_t n, size_t sizes[], Void_t** chunks) {
  1471.   Void_t** m;
  1472.   if (MALLOC_PREACTION != 0) {
  1473.     return 0;
  1474.   }
  1475.   m = iCOMALLOc(n, sizes, chunks);
  1476.   if (MALLOC_POSTACTION != 0) {
  1477.   }
  1478.   return m;
  1479. }
  1480. void public_cFREe(Void_t* m) {
  1481.   if (MALLOC_PREACTION != 0) {
  1482.     return;
  1483.   }
  1484.   cFREe(m);
  1485.   if (MALLOC_POSTACTION != 0) {
  1486.   }
  1487. }
  1488. int public_mTRIm(size_t s) {
  1489.   int result;
  1490.   if (MALLOC_PREACTION != 0) {
  1491.     return 0;
  1492.   }
  1493.   result = mTRIm(s);
  1494.   if (MALLOC_POSTACTION != 0) {
  1495.   }
  1496.   return result;
  1497. }
  1498. size_t public_mUSABLe(Void_t* m) {
  1499.   size_t result;
  1500.   if (MALLOC_PREACTION != 0) {
  1501.     return 0;
  1502.   }
  1503.   result = mUSABLe(m);
  1504.   if (MALLOC_POSTACTION != 0) {
  1505.   }
  1506.   return result;
  1507. }
  1508. void public_mSTATs(void) {
  1509.   if (MALLOC_PREACTION != 0) {
  1510.     return;
  1511.   }
  1512.   mSTATs();
  1513.   if (MALLOC_POSTACTION != 0) {
  1514.   }
  1515. }
  1516. struct mallinfo public_mALLINFo() {
  1517.   struct mallinfo m;
  1518.   if (MALLOC_PREACTION != 0) {
  1519.     struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  1520.     return nm;
  1521.   }
  1522.   m = mALLINFo();
  1523.   if (MALLOC_POSTACTION != 0) {
  1524.   }
  1525.   return m;
  1526. }
  1527. int public_mALLOPt(int p, int v) {
  1528.   int result;
  1529.   if (MALLOC_PREACTION != 0) {
  1530.     return 0;
  1531.   }
  1532.   result = mALLOPt(p, v);
  1533.   if (MALLOC_POSTACTION != 0) {
  1534.   }
  1535.   return result;
  1536. }
  1537. #endif
  1538. #endif
  1539. /* ------------- Optional versions of memcopy ---------------- */
  1540. #if USE_MEMCPY
  1541. /* 
  1542.   Note: memcpy is ONLY invoked with non-overlapping regions,
  1543.   so the (usually slower) memmove is not needed.
  1544. */
  1545. #define MALLOC_COPY(dest, src, nbytes)  memcpy(dest, src, nbytes)
  1546. #define MALLOC_ZERO(dest, nbytes)       memset(dest, 0,   nbytes)
  1547. #else /* !USE_MEMCPY */
  1548. /* Use Duff's device for good zeroing/copying performance. */
  1549. #define MALLOC_ZERO(charp, nbytes)                                            
  1550. do {                                                                          
  1551.   INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp);                           
  1552.   CHUNK_SIZE_T  mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T);                     
  1553.   long mcn;                                                                   
  1554.   if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; }             
  1555.   switch (mctmp) {                                                            
  1556.     case 0: for(;;) { *mzp++ = 0;                                             
  1557.     case 7:           *mzp++ = 0;                                             
  1558.     case 6:           *mzp++ = 0;                                             
  1559.     case 5:           *mzp++ = 0;                                             
  1560.     case 4:           *mzp++ = 0;                                             
  1561.     case 3:           *mzp++ = 0;                                             
  1562.     case 2:           *mzp++ = 0;                                             
  1563.     case 1:           *mzp++ = 0; if(mcn <= 0) break; mcn--; }                
  1564.   }                                                                           
  1565. } while(0)
  1566. #define MALLOC_COPY(dest,src,nbytes)                                          
  1567. do {                                                                          
  1568.   INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src;                            
  1569.   INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest;                           
  1570.   CHUNK_SIZE_T  mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T);                     
  1571.   long mcn;                                                                   
  1572.   if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; }             
  1573.   switch (mctmp) {                                                            
  1574.     case 0: for(;;) { *mcdst++ = *mcsrc++;                                    
  1575.     case 7:           *mcdst++ = *mcsrc++;                                    
  1576.     case 6:           *mcdst++ = *mcsrc++;                                    
  1577.     case 5:           *mcdst++ = *mcsrc++;                                    
  1578.     case 4:           *mcdst++ = *mcsrc++;                                    
  1579.     case 3:           *mcdst++ = *mcsrc++;                                    
  1580.     case 2:           *mcdst++ = *mcsrc++;                                    
  1581.     case 1:           *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; }       
  1582.   }                                                                           
  1583. } while(0)
  1584. #endif
  1585. /* ------------------ MMAP support ------------------  */
  1586. #if HAVE_MMAP
  1587. #ifndef LACKS_FCNTL_H
  1588. #include <fcntl.h>
  1589. #endif
  1590. #ifndef LACKS_SYS_MMAN_H
  1591. #include <sys/mman.h>
  1592. #endif
  1593. #if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
  1594. #define MAP_ANONYMOUS MAP_ANON
  1595. #endif
  1596. /* 
  1597.    Nearly all versions of mmap support MAP_ANONYMOUS, 
  1598.    so the following is unlikely to be needed, but is
  1599.    supplied just in case.
  1600. */
  1601. #ifndef MAP_ANONYMOUS
  1602. static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
  1603. #define MMAP(addr, size, prot, flags) ((dev_zero_fd < 0) ? 
  1604.  (dev_zero_fd = open("/dev/zero", O_RDWR), 
  1605.   mmap((addr), (size), (prot), (flags), dev_zero_fd, 0)) : 
  1606.    mmap((addr), (size), (prot), (flags), dev_zero_fd, 0))
  1607. #else
  1608. #define MMAP(addr, size, prot, flags) 
  1609.  (mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0))
  1610. #endif
  1611. #endif /* HAVE_MMAP */
  1612. /*
  1613.   -----------------------  Chunk representations -----------------------
  1614. */
  1615. /*
  1616.   This struct declaration is misleading (but accurate and necessary).
  1617.   It declares a "view" into memory allowing access to necessary
  1618.   fields at known offsets from a given base. See explanation below.
  1619. */
  1620. struct malloc_chunk {
  1621.   INTERNAL_SIZE_T      prev_size;  /* Size of previous chunk (if free).  */
  1622.   INTERNAL_SIZE_T      size;       /* Size in bytes, including overhead. */
  1623.   struct malloc_chunk* fd;         /* double links -- used only if free. */
  1624.   struct malloc_chunk* bk;
  1625. };
  1626. typedef struct malloc_chunk* mchunkptr;
  1627. /*
  1628.    malloc_chunk details:
  1629.     (The following includes lightly edited explanations by Colin Plumb.)
  1630.     Chunks of memory are maintained using a `boundary tag' method as
  1631.     described in e.g., Knuth or Standish.  (See the paper by Paul
  1632.     Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
  1633.     survey of such techniques.)  Sizes of free chunks are stored both
  1634.     in the front of each chunk and at the end.  This makes
  1635.     consolidating fragmented chunks into bigger chunks very fast.  The
  1636.     size fields also hold bits representing whether chunks are free or
  1637.     in use.
  1638.     An allocated chunk looks like this:
  1639.     chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1640.             |             Size of previous chunk, if allocated            | |
  1641.             +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1642.             |             Size of chunk, in bytes                         |P|
  1643.       mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1644.             |             User data starts here...                          .
  1645.             .                                                               .
  1646.             .             (malloc_usable_space() bytes)                     .
  1647.             .                                                               |
  1648. nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1649.             |             Size of chunk                                     |
  1650.             +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1651.     Where "chunk" is the front of the chunk for the purpose of most of
  1652.     the malloc code, but "mem" is the pointer that is returned to the
  1653.     user.  "Nextchunk" is the beginning of the next contiguous chunk.
  1654.     Chunks always begin on even word boundries, so the mem portion
  1655.     (which is returned to the user) is also on an even word boundary, and
  1656.     thus at least double-word aligned.
  1657.     Free chunks are stored in circular doubly-linked lists, and look like this:
  1658.     chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1659.             |             Size of previous chunk                            |
  1660.             +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1661.     `head:' |             Size of chunk, in bytes                         |P|
  1662.       mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1663.             |             Forward pointer to next chunk in list             |
  1664.             +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1665.             |             Back pointer to previous chunk in list            |
  1666.             +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1667.             |             Unused space (may be 0 bytes long)                .
  1668.             .                                                               .
  1669.             .                                                               |
  1670. nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1671.     `foot:' |             Size of chunk, in bytes                           |
  1672.             +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  1673.     The P (PREV_INUSE) bit, stored in the unused low-order bit of the
  1674.     chunk size (which is always a multiple of two words), is an in-use
  1675.     bit for the *previous* chunk.  If that bit is *clear*, then the
  1676.     word before the current chunk size contains the previous chunk
  1677.     size, and can be used to find the front of the previous chunk.
  1678.     The very first chunk allocated always has this bit set,
  1679.     preventing access to non-existent (or non-owned) memory. If
  1680.     prev_inuse is set for any given chunk, then you CANNOT determine
  1681.     the size of the previous chunk, and might even get a memory
  1682.     addressing fault when trying to do so.
  1683.     Note that the `foot' of the current chunk is actually represented
  1684.     as the prev_size of the NEXT chunk. This makes it easier to
  1685.     deal with alignments etc but can be very confusing when trying
  1686.     to extend or adapt this code.
  1687.     The two exceptions to all this are
  1688.      1. The special chunk `top' doesn't bother using the
  1689.         trailing size field since there is no next contiguous chunk
  1690.         that would have to index off it. After initialization, `top'
  1691.         is forced to always exist.  If it would become less than
  1692.         MINSIZE bytes long, it is replenished.
  1693.      2. Chunks allocated via mmap, which have the second-lowest-order
  1694.         bit (IS_MMAPPED) set in their size fields.  Because they are
  1695.         allocated one-by-one, each must contain its own trailing size field.
  1696. */
  1697. /*
  1698.   ---------- Size and alignment checks and conversions ----------
  1699. */
  1700. /* conversion from malloc headers to user pointers, and back */
  1701. #define chunk2mem(p)   ((Void_t*)((char*)(p) + 2*SIZE_SZ))
  1702. #define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))
  1703. /* The smallest possible chunk */
  1704. #define MIN_CHUNK_SIZE        (sizeof(struct malloc_chunk))
  1705. /* The smallest size we can malloc is an aligned minimal chunk */
  1706. #define MINSIZE  
  1707.   (CHUNK_SIZE_T)(((MIN_CHUNK_SIZE+MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK))
  1708. /* Check if m has acceptable alignment */
  1709. #define aligned_OK(m)  (((PTR_UINT)((m)) & (MALLOC_ALIGN_MASK)) == 0)
  1710. /* 
  1711.    Check if a request is so large that it would wrap around zero when
  1712.    padded and aligned. To simplify some other code, the bound is made
  1713.    low enough so that adding MINSIZE will also not wrap around sero.
  1714. */
  1715. #define REQUEST_OUT_OF_RANGE(req)                                 
  1716.   ((CHUNK_SIZE_T)(req) >=                                        
  1717.    (CHUNK_SIZE_T)(INTERNAL_SIZE_T)(-2 * MINSIZE))    
  1718. /* pad request bytes into a usable size -- internal version */
  1719. #define request2size(req)                                         
  1720.   (((req) + SIZE_SZ + MALLOC_ALIGN_MASK < MINSIZE)  ?             
  1721.    MINSIZE :                                                      
  1722.    ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK)
  1723. /*  Same, except also perform argument check */
  1724. #define checked_request2size(req, sz)                             
  1725.   if (REQUEST_OUT_OF_RANGE(req)) {                                
  1726.     MALLOC_FAILURE_ACTION;                                        
  1727.     return 0;                                                     
  1728.   }                                                               
  1729.   (sz) = request2size(req);                                              
  1730. /*
  1731.   --------------- Physical chunk operations ---------------
  1732. */
  1733. /* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
  1734. #define PREV_INUSE 0x1
  1735. /* extract inuse bit of previous chunk */
  1736. #define prev_inuse(p)       ((p)->size & PREV_INUSE)
  1737. /* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */
  1738. #define IS_MMAPPED 0x2
  1739. /* check for mmap()'ed chunk */
  1740. #define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED)
  1741. /* 
  1742.   Bits to mask off when extracting size 
  1743.   Note: IS_MMAPPED is intentionally not masked off from size field in
  1744.   macros for which mmapped chunks should never be seen. This should
  1745.   cause helpful core dumps to occur if it is tried by accident by
  1746.   people extending or adapting this malloc.
  1747. */
  1748. #define SIZE_BITS (PREV_INUSE|IS_MMAPPED)
  1749. /* Get size, ignoring use bits */
  1750. #define chunksize(p)         ((p)->size & ~(SIZE_BITS))
  1751. /* Ptr to next physical malloc_chunk. */
  1752. #define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) ))
  1753. /* Ptr to previous physical malloc_chunk */
  1754. #define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
  1755. /* Treat space at ptr + offset as a chunk */
  1756. #define chunk_at_offset(p, s)  ((mchunkptr)(((char*)(p)) + (s)))
  1757. /* extract p's inuse bit */
  1758. #define inuse(p)
  1759. ((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE)
  1760. /* set/clear chunk as being inuse without otherwise disturbing */
  1761. #define set_inuse(p)
  1762. ((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE
  1763. #define clear_inuse(p)
  1764. ((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE)
  1765. /* check/set/clear inuse bits in known places */
  1766. #define inuse_bit_at_offset(p, s)
  1767.  (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
  1768. #define set_inuse_bit_at_offset(p, s)
  1769.  (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
  1770. #define clear_inuse_bit_at_offset(p, s)
  1771.  (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
  1772. /* Set size at head, without disturbing its use bit */
  1773. #define set_head_size(p, s)  ((p)->size = (((p)->size & PREV_INUSE) | (s)))
  1774. /* Set size/use field */
  1775. #define set_head(p, s)       ((p)->size = (s))
  1776. /* Set size at footer (only when chunk is not in use) */
  1777. #define set_foot(p, s)       (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
  1778. /*
  1779.   -------------------- Internal data structures --------------------
  1780.    All internal state is held in an instance of malloc_state defined
  1781.    below. There are no other static variables, except in two optional
  1782.    cases: 
  1783.    * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above. 
  1784.    * If HAVE_MMAP is true, but mmap doesn't support
  1785.      MAP_ANONYMOUS, a dummy file descriptor for mmap.
  1786.    Beware of lots of tricks that minimize the total bookkeeping space
  1787.    requirements. The result is a little over 1K bytes (for 4byte
  1788.    pointers and size_t.)
  1789. */
  1790. /*
  1791.   Bins
  1792.     An array of bin headers for free chunks. Each bin is doubly
  1793.     linked.  The bins are approximately proportionally (log) spaced.
  1794.     There are a lot of these bins (128). This may look excessive, but
  1795.     works very well in practice.  Most bins hold sizes that are
  1796.     unusual as malloc request sizes, but are more usual for fragments
  1797.     and consolidated sets of chunks, which is what these bins hold, so
  1798.     they can be found quickly.  All procedures maintain the invariant
  1799.     that no consolidated chunk physically borders another one, so each
  1800.     chunk in a list is known to be preceeded and followed by either
  1801.     inuse chunks or the ends of memory.
  1802.     Chunks in bins are kept in size order, with ties going to the
  1803.     approximately least recently used chunk. Ordering isn't needed
  1804.     for the small bins, which all contain the same-sized chunks, but
  1805.     facilitates best-fit allocation for larger chunks. These lists
  1806.     are just sequential. Keeping them in order almost never requires
  1807.     enough traversal to warrant using fancier ordered data
  1808.     structures.  
  1809.     Chunks of the same size are linked with the most
  1810.     recently freed at the front, and allocations are taken from the
  1811.     back.  This results in LRU (FIFO) allocation order, which tends
  1812.     to give each chunk an equal opportunity to be consolidated with
  1813.     adjacent freed chunks, resulting in larger free chunks and less
  1814.     fragmentation.
  1815.     To simplify use in double-linked lists, each bin header acts
  1816.     as a malloc_chunk. This avoids special-casing for headers.
  1817.     But to conserve space and improve locality, we allocate
  1818.     only the fd/bk pointers of bins, and then use repositioning tricks
  1819.     to treat these as the fields of a malloc_chunk*.  
  1820. */
  1821. typedef struct malloc_chunk* mbinptr;
  1822. /* addressing -- note that bin_at(0) does not exist */
  1823. #define bin_at(m, i) ((mbinptr)((char*)&((m)->bins[(i)<<1]) - (SIZE_SZ<<1)))
  1824. /* analog of ++bin */
  1825. #define next_bin(b)  ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
  1826. /* Reminders about list directionality within bins */
  1827. #define first(b)     ((b)->fd)
  1828. #define last(b)      ((b)->bk)
  1829. /* Take a chunk off a bin list */
  1830. #define unlink(P, BK, FD) {                                            
  1831.   FD = P->fd;                                                          
  1832.   BK = P->bk;                                                          
  1833.   FD->bk = BK;                                                         
  1834.   BK->fd = FD;                                                         
  1835. }
  1836. /*
  1837.   Indexing
  1838.     Bins for sizes < 512 bytes contain chunks of all the same size, spaced
  1839.     8 bytes apart. Larger bins are approximately logarithmically spaced:
  1840.     64 bins of size       8
  1841.     32 bins of size      64
  1842.     16 bins of size     512
  1843.      8 bins of size    4096
  1844.      4 bins of size   32768
  1845.      2 bins of size  262144
  1846.      1 bin  of size what's left
  1847.     The bins top out around 1MB because we expect to service large
  1848.     requests via mmap.
  1849. */
  1850. #define NBINS              96
  1851. #define NSMALLBINS         32
  1852. #define SMALLBIN_WIDTH      8
  1853. #define MIN_LARGE_SIZE    256
  1854. #define in_smallbin_range(sz)  
  1855.   ((CHUNK_SIZE_T)(sz) < (CHUNK_SIZE_T)MIN_LARGE_SIZE)
  1856. #define smallbin_index(sz)     (((unsigned)(sz)) >> 3)
  1857. /*
  1858.   Compute index for size. We expect this to be inlined when
  1859.   compiled with optimization, else not, which works out well.
  1860. */
  1861. static int largebin_index(unsigned int sz) {
  1862.   unsigned int  x = sz >> SMALLBIN_WIDTH; 
  1863.   unsigned int m;            /* bit position of highest set bit of m */
  1864.   if (x >= 0x10000) return NBINS-1;
  1865.   /* On intel, use BSRL instruction to find highest bit */
  1866. #if defined(__GNUC__) && defined(i386)
  1867.   __asm__("bsrl %1,%0nt"
  1868.           : "=r" (m) 
  1869.           : "g"  (x));
  1870. #else
  1871.   {
  1872.     /*
  1873.       Based on branch-free nlz algorithm in chapter 5 of Henry
  1874.       S. Warren Jr's book "Hacker's Delight".
  1875.     */
  1876.     unsigned int n = ((x - 0x100) >> 16) & 8;
  1877.     x <<= n; 
  1878.     m = ((x - 0x1000) >> 16) & 4;
  1879.     n += m; 
  1880.     x <<= m; 
  1881.     m = ((x - 0x4000) >> 16) & 2;
  1882.     n += m; 
  1883.     x = (x << m) >> 14;
  1884.     m = 13 - n + (x & ~(x>>1));
  1885.   }
  1886. #endif
  1887.   /* Use next 2 bits to create finer-granularity bins */
  1888.   return NSMALLBINS + (m << 2) + ((sz >> (m + 6)) & 3);
  1889. }
  1890. #define bin_index(sz) 
  1891.  ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
  1892. /*
  1893.   FIRST_SORTED_BIN_SIZE is the chunk size corresponding to the
  1894.   first bin that is maintained in sorted order. This must
  1895.   be the smallest size corresponding to a given bin.
  1896.   Normally, this should be MIN_LARGE_SIZE. But you can weaken
  1897.   best fit guarantees to sometimes speed up malloc by increasing value.
  1898.   Doing this means that malloc may choose a chunk that is 
  1899.   non-best-fitting by up to the width of the bin.
  1900.   Some useful cutoff values:
  1901.       512 - all bins sorted
  1902.      2560 - leaves bins <=     64 bytes wide unsorted  
  1903.     12288 - leaves bins <=    512 bytes wide unsorted
  1904.     65536 - leaves bins <=   4096 bytes wide unsorted
  1905.    262144 - leaves bins <=  32768 bytes wide unsorted
  1906.        -1 - no bins sorted (not recommended!)
  1907. */
  1908. #define FIRST_SORTED_BIN_SIZE MIN_LARGE_SIZE 
  1909. /* #define FIRST_SORTED_BIN_SIZE 65536 */
  1910. /*
  1911.   Unsorted chunks
  1912.     All remainders from chunk splits, as well as all returned chunks,
  1913.     are first placed in the "unsorted" bin. They are then placed
  1914.     in regular bins after malloc gives them ONE chance to be used before
  1915.     binning. So, basically, the unsorted_chunks list acts as a queue,
  1916.     with chunks being placed on it in free (and malloc_consolidate),
  1917.     and taken off (to be either used or placed in bins) in malloc.
  1918. */
  1919. /* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
  1920. #define unsorted_chunks(M)          (bin_at(M, 1))
  1921. /*
  1922.   Top
  1923.     The top-most available chunk (i.e., the one bordering the end of
  1924.     available memory) is treated specially. It is never included in
  1925.     any bin, is used only if no other chunk is available, and is
  1926.     released back to the system if it is very large (see
  1927.     M_TRIM_THRESHOLD).  Because top initially
  1928.     points to its own bin with initial zero size, thus forcing
  1929.     extension on the first malloc request, we avoid having any special
  1930.     code in malloc to check whether it even exists yet. But we still
  1931.     need to do so when getting memory from system, so we make
  1932.     initial_top treat the bin as a legal but unusable chunk during the
  1933.     interval between initialization and the first call to
  1934.     sYSMALLOc. (This is somewhat delicate, since it relies on
  1935.     the 2 preceding words to be zero during this interval as well.)
  1936. */
  1937. /* Conveniently, the unsorted bin can be used as dummy top on first call */
  1938. #define initial_top(M)              (unsorted_chunks(M))
  1939. /*
  1940.   Binmap
  1941.     To help compensate for the large number of bins, a one-level index
  1942.     structure is used for bin-by-bin searching.  `binmap' is a
  1943.     bitvector recording whether bins are definitely empty so they can
  1944.     be skipped over during during traversals.  The bits are NOT always
  1945.     cleared as soon as bins are empty, but instead only
  1946.     when they are noticed to be empty during traversal in malloc.
  1947. */
  1948. /* Conservatively use 32 bits per map word, even if on 64bit system */
  1949. #define BINMAPSHIFT      5
  1950. #define BITSPERMAP       (1U << BINMAPSHIFT)
  1951. #define BINMAPSIZE       (NBINS / BITSPERMAP)
  1952. #define idx2block(i)     ((i) >> BINMAPSHIFT)
  1953. #define idx2bit(i)       ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
  1954. #define mark_bin(m,i)    ((m)->binmap[idx2block(i)] |=  idx2bit(i))
  1955. #define unmark_bin(m,i)  ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
  1956. #define get_binmap(m,i)  ((m)->binmap[idx2block(i)] &   idx2bit(i))
  1957. /*
  1958.   Fastbins
  1959.     An array of lists holding recently freed small chunks.  Fastbins
  1960.     are not doubly linked.  It is faster to single-link them, and
  1961.     since chunks are never removed from the middles of these lists,
  1962.     double linking is not necessary. Also, unlike regular bins, they
  1963.     are not even processed in FIFO order (they use faster LIFO) since
  1964.     ordering doesn't much matter in the transient contexts in which
  1965.     fastbins are normally used.
  1966.     Chunks in fastbins keep their inuse bit set, so they cannot
  1967.     be consolidated with other free chunks. malloc_consolidate
  1968.     releases all chunks in fastbins and consolidates them with
  1969.     other free chunks. 
  1970. */
  1971. typedef struct malloc_chunk* mfastbinptr;
  1972. /* offset 2 to use otherwise unindexable first 2 bins */
  1973. #define fastbin_index(sz)        ((((unsigned int)(sz)) >> 3) - 2)
  1974. /* The maximum fastbin request size we support */
  1975. #define MAX_FAST_SIZE     80
  1976. #define NFASTBINS  (fastbin_index(request2size(MAX_FAST_SIZE))+1)
  1977. /*
  1978.   FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
  1979.   that triggers automatic consolidation of possibly-surrounding
  1980.   fastbin chunks. This is a heuristic, so the exact value should not
  1981.   matter too much. It is defined at half the default trim threshold as a
  1982.   compromise heuristic to only attempt consolidation if it is likely
  1983.   to lead to trimming. However, it is not dynamically tunable, since
  1984.   consolidation reduces fragmentation surrounding loarge chunks even 
  1985.   if trimming is not used.
  1986. */
  1987. #define FASTBIN_CONSOLIDATION_THRESHOLD  
  1988.   ((unsigned long)(DEFAULT_TRIM_THRESHOLD) >> 1)
  1989. /*
  1990.   Since the lowest 2 bits in max_fast don't matter in size comparisons, 
  1991.   they are used as flags.
  1992. */
  1993. /*
  1994.   ANYCHUNKS_BIT held in max_fast indicates that there may be any
  1995.   freed chunks at all. It is set true when entering a chunk into any
  1996.   bin.
  1997. */
  1998. #define ANYCHUNKS_BIT        (1U)
  1999. #define have_anychunks(M)     (((M)->max_fast &  ANYCHUNKS_BIT))
  2000. #define set_anychunks(M)      ((M)->max_fast |=  ANYCHUNKS_BIT)
  2001. #define clear_anychunks(M)    ((M)->max_fast &= ~ANYCHUNKS_BIT)
  2002. /*
  2003.   FASTCHUNKS_BIT held in max_fast indicates that there are probably
  2004.   some fastbin chunks. It is set true on entering a chunk into any
  2005.   fastbin, and cleared only in malloc_consolidate.
  2006. */
  2007. #define FASTCHUNKS_BIT        (2U)
  2008. #define have_fastchunks(M)   (((M)->max_fast &  FASTCHUNKS_BIT))
  2009. #define set_fastchunks(M)    ((M)->max_fast |=  (FASTCHUNKS_BIT|ANYCHUNKS_BIT))
  2010. #define clear_fastchunks(M)  ((M)->max_fast &= ~(FASTCHUNKS_BIT))
  2011. /* 
  2012.    Set value of max_fast. 
  2013.    Use impossibly small value if 0.
  2014. */
  2015. #define set_max_fast(M, s) 
  2016.   (M)->max_fast = (((s) == 0)? SMALLBIN_WIDTH: request2size(s)) | 
  2017.   ((M)->max_fast &  (FASTCHUNKS_BIT|ANYCHUNKS_BIT))
  2018. #define get_max_fast(M) 
  2019.   ((M)->max_fast & ~(FASTCHUNKS_BIT | ANYCHUNKS_BIT))
  2020. /*
  2021.   morecore_properties is a status word holding dynamically discovered
  2022.   or controlled properties of the morecore function
  2023. */
  2024. #define MORECORE_CONTIGUOUS_BIT  (1U)
  2025. #define contiguous(M) 
  2026.         (((M)->morecore_properties &  MORECORE_CONTIGUOUS_BIT))
  2027. #define noncontiguous(M) 
  2028.         (((M)->morecore_properties &  MORECORE_CONTIGUOUS_BIT) == 0)
  2029. #define set_contiguous(M) 
  2030.         ((M)->morecore_properties |=  MORECORE_CONTIGUOUS_BIT)
  2031. #define set_noncontiguous(M) 
  2032.         ((M)->morecore_properties &= ~MORECORE_CONTIGUOUS_BIT)
  2033. /*
  2034.    ----------- Internal state representation and initialization -----------
  2035. */
  2036. struct malloc_state {
  2037.   /* The maximum chunk size to be eligible for fastbin */
  2038.   INTERNAL_SIZE_T  max_fast;   /* low 2 bits used as flags */
  2039.   /* Fastbins */
  2040.   mfastbinptr      fastbins[NFASTBINS];
  2041.   /* Base of the topmost chunk -- not otherwise kept in a bin */
  2042.   mchunkptr        top;
  2043.   /* The remainder from the most recent split of a small request */
  2044.   mchunkptr        last_remainder;
  2045.   /* Normal bins packed as described above */
  2046.   mchunkptr        bins[NBINS * 2];
  2047.   /* Bitmap of bins. Trailing zero map handles cases of largest binned size */
  2048.   unsigned int     binmap[BINMAPSIZE+1];
  2049.   /* Tunable parameters */
  2050.   CHUNK_SIZE_T     trim_threshold;
  2051.   INTERNAL_SIZE_T  top_pad;
  2052.   INTERNAL_SIZE_T  mmap_threshold;
  2053.   /* Memory map support */
  2054.   int              n_mmaps;
  2055.   int              n_mmaps_max;
  2056.   int              max_n_mmaps;
  2057.   /* Cache malloc_getpagesize */
  2058.   unsigned int     pagesize;    
  2059.   /* Track properties of MORECORE */
  2060.   unsigned int     morecore_properties;
  2061.   /* Statistics */
  2062.   INTERNAL_SIZE_T  mmapped_mem;
  2063.   INTERNAL_SIZE_T  sbrked_mem;
  2064.   INTERNAL_SIZE_T  max_sbrked_mem;
  2065.   INTERNAL_SIZE_T  max_mmapped_mem;
  2066.   INTERNAL_SIZE_T  max_total_mem;
  2067. };
  2068. typedef struct malloc_state *mstate;
  2069. /* 
  2070.    There is exactly one instance of this struct in this malloc.
  2071.    If you are adapting this malloc in a way that does NOT use a static
  2072.    malloc_state, you MUST explicitly zero-fill it before using. This
  2073.    malloc relies on the property that malloc_state is initialized to
  2074.    all zeroes (as is true of C statics).
  2075. */
  2076. static struct malloc_state av_;  /* never directly referenced */
  2077. /*
  2078.    All uses of av_ are via get_malloc_state().
  2079.    At most one "call" to get_malloc_state is made per invocation of
  2080.    the public versions of malloc and free, but other routines
  2081.    that in turn invoke malloc and/or free may call more then once. 
  2082.    Also, it is called in check* routines if DEBUG is set.
  2083. */
  2084. #define get_malloc_state() (&(av_))
  2085. /*
  2086.   Initialize a malloc_state struct.
  2087.   This is called only from within malloc_consolidate, which needs
  2088.   be called in the same contexts anyway.  It is never called directly
  2089.   outside of malloc_consolidate because some optimizing compilers try
  2090.   to inline it at all call points, which turns out not to be an
  2091.   optimization at all. (Inlining it in malloc_consolidate is fine though.)
  2092. */
  2093. #if __STD_C
  2094. static void malloc_init_state(mstate av)
  2095. #else
  2096. static void malloc_init_state(av) mstate av;
  2097. #endif
  2098. {
  2099.   int     i;
  2100.   mbinptr bin;
  2101.   
  2102.   /* Establish circular links for normal bins */
  2103.   for (i = 1; i < NBINS; ++i) { 
  2104.     bin = bin_at(av,i);
  2105.     bin->fd = bin->bk = bin;
  2106.   }
  2107.   av->top_pad        = DEFAULT_TOP_PAD;
  2108.   av->n_mmaps_max    = DEFAULT_MMAP_MAX;
  2109.   av->mmap_threshold = DEFAULT_MMAP_THRESHOLD;
  2110.   av->trim_threshold = DEFAULT_TRIM_THRESHOLD;
  2111. #if MORECORE_CONTIGUOUS
  2112.   set_contiguous(av);
  2113. #else
  2114.   set_noncontiguous(av);
  2115. #endif
  2116.   set_max_fast(av, DEFAULT_MXFAST);
  2117.   av->top            = initial_top(av);
  2118.   av->pagesize       = malloc_getpagesize;
  2119. }
  2120. /* 
  2121.    Other internal utilities operating on mstates
  2122. */
  2123. #if __STD_C
  2124. static Void_t*  sYSMALLOc(INTERNAL_SIZE_T, mstate);
  2125. static int      sYSTRIm(size_t, mstate);
  2126. #if 0
  2127. static Void_t** iALLOc(size_t, size_t*, int, Void_t**);
  2128. #endif
  2129. static void     malloc_consolidate(mstate);
  2130. #else
  2131. static Void_t*  sYSMALLOc();
  2132. static int      sYSTRIm();
  2133. static void     malloc_consolidate();
  2134. static Void_t** iALLOc();
  2135. #endif
  2136. /*
  2137.   Debugging support
  2138.   These routines make a number of assertions about the states
  2139.   of data structures that should be true at all times. If any
  2140.   are not true, it's very likely that a user program has somehow
  2141.   trashed memory. (It's also possible that there is a coding error
  2142.   in malloc. In which case, please report it!)
  2143. */
  2144. #if ! DEBUG
  2145. #define check_chunk(P)
  2146. #define check_free_chunk(P)
  2147. #define check_inuse_chunk(P)
  2148. #define check_remalloced_chunk(P,N)
  2149. #define check_malloced_chunk(P,N)
  2150. #define check_malloc_state()
  2151. #else
  2152. #define check_chunk(P)              do_check_chunk(P)
  2153. #define check_free_chunk(P)         do_check_free_chunk(P)
  2154. #define check_inuse_chunk(P)        do_check_inuse_chunk(P)
  2155. #define check_remalloced_chunk(P,N) do_check_remalloced_chunk(P,N)
  2156. #define check_malloced_chunk(P,N)   do_check_malloced_chunk(P,N)
  2157. #define check_malloc_state()        do_check_malloc_state()
  2158. /*
  2159.   Properties of all chunks
  2160. */
  2161. #if __STD_C
  2162. static void do_check_chunk(mchunkptr p)
  2163. #else
  2164. static void do_check_chunk(p) mchunkptr p;
  2165. #endif
  2166. {
  2167.   mstate av = get_malloc_state();
  2168.   CHUNK_SIZE_T  sz = chunksize(p);
  2169.   /* min and max possible addresses assuming contiguous allocation */
  2170.   char* max_address = (char*)(av->top) + chunksize(av->top);
  2171.   char* min_address = max_address - av->sbrked_mem;
  2172.   if (!chunk_is_mmapped(p)) {
  2173.     
  2174.     /* Has legal address ... */
  2175.     if (p != av->top) {
  2176.       if (contiguous(av)) {
  2177.         assert(((char*)p) >= min_address);
  2178.         assert(((char*)p + sz) <= ((char*)(av->top)));
  2179.       }
  2180.     }
  2181.     else {
  2182.       /* top size is always at least MINSIZE */
  2183.       assert((CHUNK_SIZE_T)(sz) >= MINSIZE);
  2184.       /* top predecessor always marked inuse */
  2185.       assert(prev_inuse(p));
  2186.     }
  2187.       
  2188.   }
  2189.   else {
  2190. #if HAVE_MMAP
  2191.     /* address is outside main heap  */
  2192.     if (contiguous(av) && av->top != initial_top(av)) {
  2193.       assert(((char*)p) < min_address || ((char*)p) > max_address);
  2194.     }
  2195.     /* chunk is page-aligned */
  2196.     assert(((p->prev_size + sz) & (av->pagesize-1)) == 0);
  2197.     /* mem is aligned */
  2198.     assert(aligned_OK(chunk2mem(p)));
  2199. #else
  2200.     /* force an appropriate assert violation if debug set */
  2201.     assert(!chunk_is_mmapped(p));
  2202. #endif
  2203.   }
  2204. }
  2205. /*
  2206.   Properties of free chunks
  2207. */
  2208. #if __STD_C
  2209. static void do_check_free_chunk(mchunkptr p)
  2210. #else
  2211. static void do_check_free_chunk(p) mchunkptr p;
  2212. #endif
  2213. {
  2214.   mstate av = get_malloc_state();
  2215.   INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
  2216.   mchunkptr next = chunk_at_offset(p, sz);
  2217.   do_check_chunk(p);
  2218.   /* Chunk must claim to be free ... */
  2219.   assert(!inuse(p));
  2220.   assert (!chunk_is_mmapped(p));
  2221.   /* Unless a special marker, must have OK fields */
  2222.   if ((CHUNK_SIZE_T)(sz) >= MINSIZE)
  2223.   {
  2224.     assert((sz & MALLOC_ALIGN_MASK) == 0);
  2225.     assert(aligned_OK(chunk2mem(p)));
  2226.     /* ... matching footer field */
  2227.     assert(next->prev_size == sz);
  2228.     /* ... and is fully consolidated */
  2229.     assert(prev_inuse(p));
  2230.     assert (next == av->top || inuse(next));
  2231.     /* ... and has minimally sane links */
  2232.     assert(p->fd->bk == p);
  2233.     assert(p->bk->fd == p);
  2234.   }
  2235.   else /* markers are always of size SIZE_SZ */
  2236.     assert(sz == SIZE_SZ);
  2237. }
  2238. /*
  2239.   Properties of inuse chunks
  2240. */
  2241. #if __STD_C
  2242. static void do_check_inuse_chunk(mchunkptr p)
  2243. #else
  2244. static void do_check_inuse_chunk(p) mchunkptr p;
  2245. #endif
  2246. {
  2247.   mstate av = get_malloc_state();
  2248.   mchunkptr next;
  2249.   do_check_chunk(p);
  2250.   if (chunk_is_mmapped(p))
  2251.     return; /* mmapped chunks have no next/prev */
  2252.   /* Check whether it claims to be in use ... */
  2253.   assert(inuse(p));
  2254.   next = next_chunk(p);
  2255.   /* ... and is surrounded by OK chunks.
  2256.     Since more things can be checked with free chunks than inuse ones,
  2257.     if an inuse chunk borders them and debug is on, it's worth doing them.
  2258.   */
  2259.   if (!prev_inuse(p))  {
  2260.     /* Note that we cannot even look at prev unless it is not inuse */
  2261.     mchunkptr prv = prev_chunk(p);
  2262.     assert(next_chunk(prv) == p);
  2263.     do_check_free_chunk(prv);
  2264.   }
  2265.   if (next == av->top) {
  2266.     assert(prev_inuse(next));
  2267.     assert(chunksize(next) >= MINSIZE);
  2268.   }
  2269.   else if (!inuse(next))
  2270.     do_check_free_chunk(next);
  2271. }
  2272. /*
  2273.   Properties of chunks recycled from fastbins
  2274. */
  2275. #if __STD_C
  2276. static void do_check_remalloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
  2277. #else
  2278. static void do_check_remalloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
  2279. #endif
  2280. {
  2281.   INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
  2282.   do_check_inuse_chunk(p);
  2283.   /* Legal size ... */
  2284.   assert((sz & MALLOC_ALIGN_MASK) == 0);
  2285.   assert((CHUNK_SIZE_T)(sz) >= MINSIZE);
  2286.   /* ... and alignment */
  2287.   assert(aligned_OK(chunk2mem(p)));
  2288.   /* chunk is less than MINSIZE more than request */
  2289.   assert((long)(sz) - (long)(s) >= 0);
  2290.   assert((long)(sz) - (long)(s + MINSIZE) < 0);
  2291. }
  2292. /*
  2293.   Properties of nonrecycled chunks at the point they are malloced
  2294. */
  2295. #if __STD_C
  2296. static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
  2297. #else
  2298. static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;