capsule-malloc

capsule-malloc

Synopsis

#define             BINMAPSHIFT
#define             BINMAPSIZE
#define             BITSPERMAP
#define             CAN_DEBUG_ALLOCS
#define             CAPSULE_MALLOC_EXTRA_CHECKS
#define             DEBUG_MALLOC_VOODOO
#define             DEFAULT_MMAP_THRESHOLD_MAX
#define             FETCH_FPUTS
#define             HEAP_MAX_SIZE
#define             HEAP_MIN_SIZE
#define             IS_MMAPPED
#define             MALLOC_ALIGNMENT
#define             MALLOC_ALIGN_MASK
#define             MAX_FAST_SIZE
#define             MINSIZE
#define             MIN_CHUNK_SIZE
#define             NBINS
#define             NFASTBINS
#define             NONCONTIGUOUS_BIT
#define             NON_MAIN_ARENA
#define             PREV_INUSE
#define             SIZE_BITS
#define             SIZE_SZ
#define             arena_for_chunk                     (ptr)
size_t              c;
#define             chunk2mem                           (p)
#define             chunk_at_offset                     (p,
                                                         s)
#define             chunk_is_mmapped                    (p)
#define             chunk_non_main_arena                (p)
#define             chunksize                           (p)
#define             contiguous                          (M)
#define             dump_ptr                            (a,
                                                         b)
#define             fastbin                             (ar_ptr,
                                                         idx)
#define             fastbin_index                       (sz)
int                 (*fputsfunc)                        (const char *buf,
                                                         FILE *s);
#define             heap_for_ptr                        (ptr)
typedef             mchunkptr;
#define             mem2chunk                           (mem)
typedef             mfastbinptr;
typedef             mstate;
typedef             mutex_t;
#define             noncontiguous                       (M)
#define             request2size                        (req)
ssize_t             start;
unsigned long       x;

Description

Details

BINMAPSHIFT

#define BINMAPSHIFT 5


BINMAPSIZE

#define BINMAPSIZE  (NBINS / BITSPERMAP)


BITSPERMAP

#define BITSPERMAP  (1U << BINMAPSHIFT)


CAN_DEBUG_ALLOCS

#define CAN_DEBUG_ALLOCS (wf != NULL)


CAPSULE_MALLOC_EXTRA_CHECKS

#define CAPSULE_MALLOC_EXTRA_CHECKS


DEBUG_MALLOC_VOODOO

#define DEBUG_MALLOC_VOODOO 0


DEFAULT_MMAP_THRESHOLD_MAX

#  define DEFAULT_MMAP_THRESHOLD_MAX (512 * 1024)


FETCH_FPUTS

#define             FETCH_FPUTS()


HEAP_MAX_SIZE

#  define HEAP_MAX_SIZE (2 * DEFAULT_MMAP_THRESHOLD_MAX)


HEAP_MIN_SIZE

#define HEAP_MIN_SIZE (32 * 1024)


IS_MMAPPED

#define IS_MMAPPED     0x2


MALLOC_ALIGNMENT

#define             MALLOC_ALIGNMENT


MALLOC_ALIGN_MASK

#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1)


MAX_FAST_SIZE

#define MAX_FAST_SIZE  (80 * SIZE_SZ / 4)


MINSIZE

#define             MINSIZE


MIN_CHUNK_SIZE

#define MIN_CHUNK_SIZE    (offsetof(struct malloc_chunk, fd_nextsize))


NBINS

#define NBINS       128


NFASTBINS

#define NFASTBINS   (fastbin_index (request2size (MAX_FAST_SIZE)) + 1)


NONCONTIGUOUS_BIT

#define NONCONTIGUOUS_BIT (2U)


NON_MAIN_ARENA

#define NON_MAIN_ARENA 0x4


PREV_INUSE

#define PREV_INUSE     0x1


SIZE_BITS

#define SIZE_BITS    (PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)


SIZE_SZ

#define SIZE_SZ (sizeof(size_t))


arena_for_chunk()

#define             arena_for_chunk(ptr)


c

        size_t c = (x >> ((((sizeof(long) * 2) - 1) - i) * 4)) & 0b01111;


chunk2mem()

#define chunk2mem(p)   ((void*)((char*)(p) + 2*SIZE_SZ))


chunk_at_offset()

#define chunk_at_offset(p, s)  ((mchunkptr) (((char *) (p)) + (s)))


chunk_is_mmapped()

#define chunk_is_mmapped(p)     ((p)->size & IS_MMAPPED)


chunk_non_main_arena()

#define chunk_non_main_arena(p) ((p)->size & NON_MAIN_ARENA)


chunksize()

#define chunksize(p) ((p)->size & ~(SIZE_BITS))


contiguous()

#define contiguous(M)     (((M)->flags & NONCONTIGUOUS_BIT) == 0)


dump_ptr()

#define dump_ptr(a,b)


fastbin()

#define fastbin(ar_ptr, idx) ((ar_ptr)->fastbinsY[idx])


fastbin_index()

#define             fastbin_index(sz)


fputsfunc ()

int                 (*fputsfunc)                        (const char *buf,
                                                         FILE *s);


heap_for_ptr()

#define             heap_for_ptr(ptr)


mchunkptr

typedef struct malloc_chunk* mchunkptr;


mem2chunk()

#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ))


mfastbinptr

typedef struct malloc_chunk *mfastbinptr;


mstate

typedef struct malloc_state *mstate;


mutex_t

typedef int mutex_t;


noncontiguous()

#define noncontiguous(M)  (((M)->flags & NONCONTIGUOUS_BIT) != 0)


request2size()

#define             request2size(req)


start

    ssize_t start = sizeof(long) * 2;


x

    unsigned long x = (unsigned long) ptr;