/*  INTERNAL_SIZE_T is the word-size used for internal bookkeeping  of chunk sizes.  The default version is the same as size_t.  While not strictly necessary, it is best to define this as an  unsigned type, even if size_t is a signed type. This may avoid some  artificial size limitations on some systems.  On a 64-bit machine, you may be able to reduce malloc overhead by  defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' at the  expense of not being able to handle more than 2^32 of malloced  space. If this limitation is acceptable, you are encouraged to set  this unless you are on a platform requiring 16byte alignments. In  this case the alignment requirements turn out to negate any  potential advantages of decreasing size_t word size.  Implementors: Beware of the possible combinations of:     - INTERNAL_SIZE_T might be signed or unsigned, might be 32 or 64 bits,       and might be the same width as int or as long     - size_t might have different width and signedness as INTERNAL_SIZE_T     - int and long might be 32 or 64 bits, and might be the same width  To deal with this, most comparisons and difference computations  among INTERNAL_SIZE_Ts should cast them to CHUNK_SIZE_T, being  aware of the fact that casting an unsigned int to a wider long does  not sign-extend. (This also makes checking for negative numbers  awkward.) Some of these casts result in harmless compiler warnings  on some systems.*/#ifndef INTERNAL_SIZE_T#define INTERNAL_SIZE_T size_t#endif/* The corresponding word size */#define SIZE_SZ                (sizeof(INTERNAL_SIZE_T))/*  MALLOC_ALIGNMENT is the minimum alignment for malloc'ed chunks.  It must be a power of two at least 2 * SIZE_SZ, even on machines  for which smaller alignments would suffice. It may be defined as  larger than this though. Note however that code and data structures  are optimized for the case of 8-byte alignment.*/#ifndef MALLOC_ALIGNMENT#define MALLOC_ALIGNMENT       (2 * SIZE_SZ)#endif/* The corresponding bit mask value */#define MALLOC_ALIGN_MASK      (MALLOC_ALIGNMENT - 1)/*  REALLOC_ZERO_BYTES_FREES should be set if a call to  realloc with zero bytes should be the same as a call to free.  Some people think it should. Otherwise, since this malloc  returns a unique pointer for malloc(0), so does realloc(p, 0).*//*   #define REALLOC_ZERO_BYTES_FREES *//*  TRIM_FASTBINS controls whether free() of a very small chunk can  immediately lead to trimming. Setting to true (1) can reduce memory  footprint, but will almost always slow down programs that use a lot  of small chunks.  Define this only if you are willing to give up some speed to more  aggressively reduce system-level memory footprint when releasing  memory in programs that use many small chunks.  You can get  essentially the same effect by setting MXFAST to 0, but this can  lead to even greater slowdowns in programs using many small chunks.  TRIM_FASTBINS is an in-between compile-time option, that disables  only those chunks bordering topmost memory from being placed in  fastbins.*/#ifndef TRIM_FASTBINS#define TRIM_FASTBINS  0#endif/*  USE_DL_PREFIX will prefix all public routines with the string 'dl'.  This is necessary when you only want to use this malloc in one part   of a program, using your regular system malloc elsewhere.*//* #define USE_DL_PREFIX *//*  USE_MALLOC_LOCK causes wrapper functions to surround each  callable routine with pthread mutex lock/unlock.  USE_MALLOC_LOCK forces USE_PUBLIC_MALLOC_WRAPPERS to be defined*//* #define USE_MALLOC_LOCK *//*  If USE_PUBLIC_MALLOC_WRAPPERS is defined, every public routine is  actually a wrapper function that first calls MALLOC_PREACTION, then  calls the internal routine, and follows it with  MALLOC_POSTACTION. This is needed for locking, but you can also use  this, without USE_MALLOC_LOCK, for purposes of interception,  instrumentation, etc. It is a sad fact that using wrappers often  noticeably degrades performance of malloc-intensive programs.*/#ifdef USE_MALLOC_LOCK#define USE_PUBLIC_MALLOC_WRAPPERS#else/* #define USE_PUBLIC_MALLOC_WRAPPERS */#endif/*    Two-phase name translation.   All of the actual routines are given mangled names.   When wrappers are used, they become the public callable versions.   When DL_PREFIX is used, the callable names are prefixed.*/#ifndef USE_PUBLIC_MALLOC_WRAPPERS#define cALLOc      public_cALLOc#define fREe        public_fREe#define cFREe       public_cFREe#define mALLOc      public_mALLOc#define mEMALIGn    public_mEMALIGn#define rEALLOc     public_rEALLOc#define vALLOc      public_vALLOc#define pVALLOc     public_pVALLOc#define mALLINFo    public_mALLINFo#define mALLOPt     public_mALLOPt#define mTRIm       public_mTRIm#define mSTATs      public_mSTATs#define mUSABLe     public_mUSABLe#define iCALLOc     public_iCALLOc#define iCOMALLOc   public_iCOMALLOc#endif#ifdef USE_DL_PREFIX#define public_cALLOc    dlcalloc#define public_fREe      dlfree#define public_cFREe     dlcfree#define public_mALLOc    dlmalloc#define public_mEMALIGn  dlmemalign#define public_rEALLOc   dlrealloc#define public_vALLOc    dlvalloc#define public_pVALLOc   dlpvalloc#define public_mALLINFo  dlmallinfo#define public_mALLOPt   dlmallopt#define public_mTRIm     dlmalloc_trim#define public_mSTATs    dlmalloc_stats#define public_mUSABLe   dlmalloc_usable_size#define public_iCALLOc   dlindependent_calloc#define public_iCOMALLOc dlindependent_comalloc#else /* USE_DL_PREFIX */#define public_cALLOc    calloc#define public_fREe      free#define public_cFREe     cfree#define public_mALLOc    malloc#define public_mEMALIGn  memalign#define public_rEALLOc   realloc#define public_vALLOc    valloc#define public_pVALLOc   pvalloc#define public_mALLINFo  mallinfo#define public_mALLOPt   mallopt#define public_mTRIm     malloc_trim#define public_mSTATs    malloc_stats#define public_mUSABLe   malloc_usable_size#define public_iCALLOc   independent_calloc#define public_iCOMALLOc independent_comalloc#endif /* USE_DL_PREFIX *//*  HAVE_MEMCPY should be defined if you are not otherwise using  ANSI STD C, but still have memcpy and memset in your C library  and want to use them in calloc and realloc. Otherwise simple  macro versions are defined below.  USE_MEMCPY should be defined as 1 if you actually want to  have memset and memcpy called. People report that the macro  versions are faster than libc versions on some systems.    Even if USE_MEMCPY is set to 1, loops to copy/clear small chunks  (of <= 36 bytes) are manually unrolled in realloc and calloc.*/#define HAVE_MEMCPY#ifndef USE_MEMCPY#ifdef HAVE_MEMCPY#define USE_MEMCPY 1#else#define USE_MEMCPY 0#endif#endif#if (__STD_C || defined(HAVE_MEMCPY))#ifdef WIN32/* On Win32 memset and memcpy are already declared in windows.h */#else#if __STD_Cvoid* memset(void*, int, size_t);void* memcpy(void*, const void*, size_t);#elseVoid_t* memset();Void_t* memcpy();#endif#endif#endif/*  MALLOC_FAILURE_ACTION is the action to take before "return 0" when  malloc fails to be able to return memory, either because memory is  exhausted or because of illegal arguments.    By default, sets errno if running on STD_C platform, else does nothing.  */#ifndef MALLOC_FAILURE_ACTION#if __STD_C#define MALLOC_FAILURE_ACTION \   errno = ENOMEM;#else#define MALLOC_FAILURE_ACTION#endif#endif/*  MORECORE-related declarations. By default, rely on sbrk*/#ifdef LACKS_UNISTD_H#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)#if __STD_Cextern Void_t*     sbrk(ptrdiff_t);#elseextern Void_t*     sbrk();#endif#endif#endif/*  MORECORE is the name of the routine to call to obtain more memory  from the system.  See below for general guidance on writing  alternative MORECORE functions, as well as a version for WIN32 and a  sample version for pre-OSX macos.*/#ifndef MORECORE#define MORECORE sbrk#endif/*  MORECORE_FAILURE is the value returned upon failure of MORECORE  as well as mmap. Since it cannot be an otherwise valid memory address,  and must reflect values of standard sys calls, you probably ought not  try to redefine it.*/#ifndef MORECORE_FAILURE#define MORECORE_FAILURE (-1)#endif/*  If MORECORE_CONTIGUOUS is true, take advantage of fact that  consecutive calls to MORECORE with positive arguments always return  contiguous increasing addresses.  This is true of unix sbrk.  Even  if not defined, when regions happen to be contiguous, malloc will  permit allocations spanning regions obtained from different  calls. But defining this when applicable enables some stronger  consistency checks and space efficiencies. */#ifndef MORECORE_CONTIGUOUS#define MORECORE_CONTIGUOUS 1#endif/*  Define MORECORE_CANNOT_TRIM if your version of MORECORE  cannot release space back to the system when given negative  arguments. This is generally necessary only if you are using  a hand-crafted MORECORE function that cannot handle negative arguments.*//* #define MORECORE_CANNOT_TRIM *//*  Define HAVE_MMAP as true to optionally make malloc() use mmap() to  allocate very large blocks.  These will be returned to the  operating system immediately after a free(). Also, if mmap  is available, it is used as a backup strategy in cases where  MORECORE fails to provide space from system.  This malloc is best tuned to work with mmap for large requests.  If you do not have mmap, operations involving very large chunks (1MB  or so) may be slower than you'd like.*/#ifndef HAVE_MMAP#define HAVE_MMAP 1#endif#if HAVE_MMAP/*    Standard unix mmap using /dev/zero clears memory so calloc doesn't   need to.*/#ifndef MMAP_CLEARS#define MMAP_CLEARS 1#endif#else /* no mmap */#ifndef MMAP_CLEARS#define MMAP_CLEARS 0#endif#endif/*    MMAP_AS_MORECORE_SIZE is the minimum mmap size argument to use if   sbrk fails, and mmap is used as a backup (which is done only if   HAVE_MMAP).  The value must be a multiple of page size.  This   backup strategy generally applies only when systems have "holes" in   address space, so sbrk cannot perform contiguous expansion, but   there is still space available on system.  On systems for which   this is known to be useful (i.e. most linux kernels), this occurs   only when programs allocate huge amounts of memory.  Between this,   and the fact that mmap regions tend to be limited, the size should   be large, to avoid too many mmap calls and thus avoid running out   of kernel resources.*/#ifndef MMAP_AS_MORECORE_SIZE#define MMAP_AS_MORECORE_SIZE (1024 * 1024)#endif/*  Define HAVE_MREMAP to make realloc() use mremap() to re-allocate  large blocks.  This is currently only possible on Linux with  kernel versions newer than 1.3.77.*/#ifndef HAVE_MREMAP#ifdef linux#define HAVE_MREMAP 1#else#define HAVE_MREMAP 0#endif#endif /* HAVE_MMAP *//*  The system page size. To the extent possible, this malloc manages  memory from the system in page-size units.  Note that this value is  cached during initialization into a field of malloc_state. So even  if malloc_getpagesize is a function, it is only called once.  The following mechanics for getpagesize were adapted from bsd/gnu  getpagesize.h. If none of the system-probes here apply, a value of  4096 is used, which should be OK: If they don't apply, then using  the actual value probably doesn't impact performance.*/#ifndef malloc_getpagesize