/*

  $Id: malloc-private.h,v 1.4 2006/03/31 12:56:52 wg Exp $

  Private header file for ptmalloc3, created by Wolfram Gloger

  and released to the public domain, as explained at

  http://creativecommons.org/licenses/publicdomain. 

*/

/* The following file is replicated from malloc.c */

#ifndef MALLOC_PRIVATE_H

#define MALLOC_PRIVATE_H

#ifndef MALLOC_ALIGNMENT

# define MALLOC_ALIGNMENT  ((size_t)8U)

#endif

#ifndef USE_LOCKS

# define USE_LOCKS 0

#endif

/* The bit mask value corresponding to MALLOC_ALIGNMENT */

#define CHUNK_ALIGN_MASK    (MALLOC_ALIGNMENT - SIZE_T_ONE)

/* the number of bytes to offset an address to align it */

#define align_offset(A)\

 ((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\

  ((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK))

#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)

#define MAP_ANONYMOUS        MAP_ANON

#endif /* MAP_ANON */

#ifdef MAP_ANONYMOUS

#define MMAP_FLAGS        (MAP_PRIVATE|MAP_ANONYMOUS)

#define CALL_MMAP(s)      mmap(0, (s), PROT_READ|PROT_WRITE, MMAP_FLAGS, -1, 0)

#else /* MAP_ANONYMOUS */

/*

   Nearly all versions of mmap support MAP_ANONYMOUS, so the following

   is unlikely to be needed, but is supplied just in case.

*/

#include <fcntl.h> /* for O_RDWR */

#define MMAP_FLAGS           (MAP_PRIVATE)

static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */

#define CALL_MMAP(s) ((dev_zero_fd < 0) ? \

           (dev_zero_fd = open("/dev/zero", O_RDWR), \

            mmap(0, (s), PROT_READ|PROT_WRITE, MMAP_FLAGS, dev_zero_fd, 0)) : \

            mmap(0, (s), PROT_READ|PROT_WRITE, MMAP_FLAGS, dev_zero_fd, 0))

#endif /* MAP_ANONYMOUS */

#define CALL_MUNMAP(a, s) munmap((a), (s))

struct malloc_chunk {

  size_t               prev_foot;  /* Size of previous chunk (if free).  */

  size_t               head;       /* Size and inuse bits. */

  struct malloc_chunk* fd;         /* double links -- used only if free. */

  struct malloc_chunk* bk;

};

typedef struct malloc_chunk  mchunk;

typedef struct malloc_chunk* mchunkptr;

typedef unsigned int binmap_t;

typedef unsigned int flag_t;

struct malloc_tree_chunk;

typedef struct malloc_tree_chunk* tbinptr;

struct malloc_segment {

  char*        base;             /* base address */

  size_t       size;             /* allocated size */

  struct malloc_segment* next;   /* ptr to next segment */

  flag_t       sflags;           /* mmap and extern flag */

};

typedef struct malloc_segment  msegment;

#define NSMALLBINS        (32U)

#define NTREEBINS         (32U)

struct malloc_state {

  binmap_t   smallmap;

  binmap_t   treemap;

  size_t     dvsize;

  size_t     topsize;

  char*      least_addr;

  mchunkptr  dv;

  mchunkptr  top;

  size_t     trim_check;

  size_t     release_checks;

  size_t     magic;

  mchunkptr  smallbins[(NSMALLBINS+1)*2];

  tbinptr    treebins[NTREEBINS];

  size_t     footprint;

  size_t     max_footprint;

  flag_t     mflags;

#if USE_LOCKS

  MLOCK_T    mutex;

#endif /* USE_LOCKS */

  msegment   seg;

  void*      extp;

  size_t     exts;

};

/*

  TOP_FOOT_SIZE is padding at the end of a segment, including space

  that may be needed to place segment records and fenceposts when new

  noncontiguous segments are added.

*/

#define TOP_FOOT_SIZE\

  (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE)

/* ------------------- Chunks sizes and alignments ----------------------- */

#define MCHUNK_SIZE         (sizeof(mchunk))

#define CHUNK_OVERHEAD      (SIZE_T_SIZE)

/* MMapped chunks need a second word of overhead ... */

#define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)

/* ... and additional padding for fake next-chunk at foot */

#define MMAP_FOOT_PAD       (FOUR_SIZE_T_SIZES)

/* The smallest size we can malloc is an aligned minimal chunk */

#define MIN_CHUNK_SIZE\

  ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

/* conversion from malloc headers to user pointers, and back */

#define chunk2mem(p)        ((void*)((char*)(p)       + TWO_SIZE_T_SIZES))

#define mem2chunk(mem)      ((mchunkptr)((char*)(mem) - TWO_SIZE_T_SIZES))

/* chunk associated with aligned address A */

#define align_as_chunk(A)   (mchunkptr)((A) + align_offset(chunk2mem(A)))

/* pad request bytes into a usable size */

#define pad_request(req) \

   (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

/* The byte and bit size of a size_t */

#define SIZE_T_SIZE         (sizeof(size_t))

#define SIZE_T_BITSIZE      (sizeof(size_t) << 3)

/* Some constants coerced to size_t */

/* Annoying but necessary to avoid errors on some platforms */

#define SIZE_T_ZERO         ((size_t)0)

#define SIZE_T_ONE          ((size_t)1)

#define SIZE_T_TWO          ((size_t)2)

#define SIZE_T_FOUR         ((size_t)4)

#define TWO_SIZE_T_SIZES    (SIZE_T_SIZE<<1)

#define FOUR_SIZE_T_SIZES   (SIZE_T_SIZE<<2)

#define SIX_SIZE_T_SIZES    (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)

#define HALF_MAX_SIZE_T     (MAX_SIZE_T / 2U)

#define IS_MMAPPED_BIT      (SIZE_T_ONE)

#define PINUSE_BIT          (SIZE_T_ONE)

#define CINUSE_BIT          (SIZE_T_TWO)

#define FLAG_BITS           (PINUSE_BIT|CINUSE_BIT|SIZE_T_FOUR)

/* head field is or'ed with NON_MAIN_ARENA if the chunk was obtained

   from a non-main arena.  This is only set immediately before handing

   the chunk to the user, if necessary.  */

#define NON_MAIN_ARENA      (SIZE_T_FOUR)

#define cinuse(p)           ((p)->head & CINUSE_BIT)

#define pinuse(p)           ((p)->head & PINUSE_BIT)

#define chunksize(p)        ((p)->head & ~(FLAG_BITS))

#define is_mmapped(p)\

  (!((p)->head & PINUSE_BIT) && ((p)->prev_foot & IS_MMAPPED_BIT))

/* Get the internal overhead associated with chunk p */

#define overhead_for(p)\

 (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD)

#endif /* MALLOC_PRIVATE_H */