#include <stdint.h>
#include <string.h>

Include dependency graph for dlmalloc.c:

Classes
struct	malloc_chunk

struct	malloc_tree_chunk

struct	malloc_segment

struct	malloc_state

struct	malloc_params

Macros
#define	LACKS_UNISTD_H

#define	LACKS_FCNTL_H

#define	LACKS_SYS_PARAM_H

#define	stderr 0

#define	HAVE_MORECORE 1

#define	MORECORE au_request_page

#define	MORECORE_CONTIGUOUS 1

#define	MORECORE_CANNOT_TRIM 0

#define	USE_DL_PREFIX

#define	LACKS_TIME_H

#define	USE_LOCKS 0

#define	MALLOC_FAILURE_ACTION

#define	CALL_MMAP(size) au_request_page(size)

#define	CALL_MUNMAP(ptr, size) au_free_page(ptr, size)

#define	HAVE_MMAP 1

#define	HAVE_MREMAP 0

#define	NO_MALLINFO 1

#define	NO_MALLOC_STATS 1

#define	DEFAULT_GRANULARITY 64

#define	DLMALLOC_VERSION 20806

#define	DLMALLOC_EXPORT extern

#define	MORECORE_CONTIGUOUS 0

#define	HAVE_MMAP 0

#define	HAVE_MREMAP 0

#define	LACKS_UNISTD_H 1

#define	LACKS_SYS_TYPES_H 1

#define	LACKS_SYS_MMAN_H 1

#define	LACKS_FCNTL_H 1

#define	LACKS_TIME_H 1

#define	ABORT for(;;);

#define	LACKS_STDLIB_H 1

#define	LACKS_STRING_H 1

#define	LACKS_WINDOWS_H 1

#define	LACKS_ERRNO_H 1

#define	NO_MALLOC_STATS 1

#define	EINVAL 22

#define	ENOMEM 12

#define	ENOTSUP 95

#define	errno _kernel_errno

#define	errno 0

#define	MORECORE_FAILURE ((void*)(-1))

#define	MAX_SIZE_T (~(size_t)0)

#define	USE_SPIN_LOCKS 0

#define	ONLY_MSPACES 0

#define	MSPACES 0

#define	MALLOC_ALIGNMENT ((size_t)(2 * sizeof(void *)))

#define	FOOTERS 0

#define	ABORT_ON_ASSERT_FAILURE 1

#define	PROCEED_ON_ERROR 0

#define	INSECURE 0

#define	MALLOC_INSPECT_ALL 0

#define	MMAP_CLEARS 1

#define	MORECORE_DEFAULT sbrk

#define	DEFAULT_TRIM_THRESHOLD MAX_SIZE_T

#define	DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)

#define	MAX_RELEASE_CHECK_RATE 4095

#define	USE_BUILTIN_FFS 0

#define	USE_DEV_RANDOM 0

#define	MALLINFO_FIELD_TYPE size_t

#define	NO_SEGMENT_TRAVERSAL 0

#define	M_TRIM_THRESHOLD (-1)

#define	M_GRANULARITY (-2)

#define	M_MMAP_THRESHOLD (-3)

#define	NOINLINE

#define	FORCEINLINE

#define	assert(x)

#define	DEBUG 0

#define	LOCK_AT_FORK 0

#define	malloc_getpagesize ((size_t)4096U)

#define	SIZE_T_SIZE (sizeof(size_t))

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

#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	CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE)

#define	is_aligned(A) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0)

#define	align_offset(A)

#define	MFAIL ((void*)(MAX_SIZE_T))

#define	CMFAIL ((char)(MFAIL)) / defined for convenience */

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

#define	MMAP_PROT (PROT_READ\|PROT_WRITE)

#define	MMAP_FLAGS (MAP_PRIVATE)

#define	MMAP_DEFAULT(s)

#define	DIRECT_MMAP_DEFAULT(s) MMAP_DEFAULT(s)

#define	CALL_MORECORE(S) MORECORE(S)

#define	USE_MMAP_BIT (SIZE_T_ONE)

#define	CALL_MMAP(s) MMAP_DEFAULT(s)

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

#define	CALL_DIRECT_MMAP(s) DIRECT_MMAP_DEFAULT(s)

#define	CALL_MREMAP(addr, osz, nsz, mv) MFAIL

#define	USE_NONCONTIGUOUS_BIT (4U)

#define	EXTERN_BIT (8U)

#define	USE_LOCK_BIT (0U)

#define	INITIAL_LOCK(l) (0)

#define	DESTROY_LOCK(l) (0)

#define	ACQUIRE_MALLOC_GLOBAL_LOCK()

#define	RELEASE_MALLOC_GLOBAL_LOCK()

#define	MCHUNK_SIZE (sizeof(mchunk))

#define	CHUNK_OVERHEAD (SIZE_T_SIZE)

#define	MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)

#define	MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES)

#define	MIN_CHUNK_SIZE ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

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

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

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

#define	MAX_REQUEST ((-MIN_CHUNK_SIZE) << 2)

#define	MIN_REQUEST (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)

#define	pad_request(req) (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

#define	request2size(req) (((req) < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(req))

#define	PINUSE_BIT (SIZE_T_ONE)

#define	CINUSE_BIT (SIZE_T_TWO)

#define	FLAG4_BIT (SIZE_T_FOUR)

#define	INUSE_BITS (PINUSE_BIT\|CINUSE_BIT)

#define	FLAG_BITS (PINUSE_BIT\|CINUSE_BIT\|FLAG4_BIT)

#define	FENCEPOST_HEAD (INUSE_BITS\|SIZE_T_SIZE)

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

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

#define	flag4inuse(p) ((p)->head & FLAG4_BIT)

#define	is_inuse(p) (((p)->head & INUSE_BITS) != PINUSE_BIT)

#define	is_mmapped(p) (((p)->head & INUSE_BITS) == 0)

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

#define	clear_pinuse(p) ((p)->head &= ~PINUSE_BIT)

#define	set_flag4(p) ((p)->head \|= FLAG4_BIT)

#define	clear_flag4(p) ((p)->head &= ~FLAG4_BIT)

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

#define	chunk_minus_offset(p, s) ((mchunkptr)(((char*)(p)) - (s)))

#define	next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->head & ~FLAG_BITS)))

#define	prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_foot) ))

#define	next_pinuse(p) ((next_chunk(p)->head) & PINUSE_BIT)

#define	get_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot)

#define	set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot = (s))

#define	set_size_and_pinuse_of_free_chunk(p, s) ((p)->head = (s\|PINUSE_BIT), set_foot(p, s))

#define	set_free_with_pinuse(p, s, n) (clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s))

#define	overhead_for(p) (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD)

#define	calloc_must_clear(p) (!is_mmapped(p))

#define	leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])

#define	is_mmapped_segment(S) ((S)->sflags & USE_MMAP_BIT)

#define	is_extern_segment(S) ((S)->sflags & EXTERN_BIT)

#define	NSMALLBINS (32U)

#define	NTREEBINS (32U)

#define	SMALLBIN_SHIFT (3U)

#define	SMALLBIN_WIDTH (SIZE_T_ONE << SMALLBIN_SHIFT)

#define	TREEBIN_SHIFT (8U)

#define	MIN_LARGE_SIZE (SIZE_T_ONE << TREEBIN_SHIFT)

#define	MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE)

#define	MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)

#define	ensure_initialization() (void)(mparams.magic != 0 \|\| init_mparams())

#define	gm (&_gm_)

#define	is_global(M) ((M) == &_gm_)

#define	is_initialized(M) ((M)->top != 0)

#define	use_lock(M) ((M)->mflags & USE_LOCK_BIT)

#define	enable_lock(M) ((M)->mflags \|= USE_LOCK_BIT)

#define	disable_lock(M)

#define	use_mmap(M) ((M)->mflags & USE_MMAP_BIT)

#define	enable_mmap(M) ((M)->mflags \|= USE_MMAP_BIT)

#define	disable_mmap(M) ((M)->mflags &= ~USE_MMAP_BIT)

#define	use_noncontiguous(M) ((M)->mflags & USE_NONCONTIGUOUS_BIT)

#define	disable_contiguous(M) ((M)->mflags \|= USE_NONCONTIGUOUS_BIT)

#define	set_lock(M, L)

#define	page_align(S) (((S) + (mparams.page_size - SIZE_T_ONE)) & ~(mparams.page_size - SIZE_T_ONE))

#define	granularity_align(S)

#define	mmap_align(S) page_align(S)

#define	SYS_ALLOC_PADDING (TOP_FOOT_SIZE + MALLOC_ALIGNMENT)

#define	is_page_aligned(S) (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0)

#define	is_granularity_aligned(S) (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0)

#define	segment_holds(S, A) ((char)(A) >= S->base && (char)(A) < S->base + S->size)

#define	should_trim(M, s) (0)

#define	TOP_FOOT_SIZE (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE)

#define	PREACTION(M) (0)

#define	POSTACTION(M)

#define	CORRUPTION_ERROR_ACTION(m) ABORT

#define	USAGE_ERROR_ACTION(m, p) ABORT

#define	check_free_chunk(M, P)

#define	check_inuse_chunk(M, P)

#define	check_malloced_chunk(M, P, N)

#define	check_mmapped_chunk(M, P)

#define	check_malloc_state(M)

#define	check_top_chunk(M, P)

#define	is_small(s) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS)

#define	small_index(s) (bindex_t)((s) >> SMALLBIN_SHIFT)

#define	small_index2size(i) ((i) << SMALLBIN_SHIFT)

#define	MIN_SMALL_INDEX (small_index(MIN_CHUNK_SIZE))

#define	smallbin_at(M, i) ((sbinptr)((char*)&((M)->smallbins[(i)<<1])))

#define	treebin_at(M, i) (&((M)->treebins[i]))

#define	compute_tree_index(S, I)

#define	bit_for_tree_index(i) (i == NTREEBINS-1)? (SIZE_T_BITSIZE-1) : (((i) >> 1) + TREEBIN_SHIFT - 2)

#define	leftshift_for_tree_index(i)

#define	minsize_for_tree_index(i)

#define	idx2bit(i) ((binmap_t)(1) << (i))

#define	mark_smallmap(M, i) ((M)->smallmap \|= idx2bit(i))

#define	clear_smallmap(M, i) ((M)->smallmap &= ~idx2bit(i))

#define	smallmap_is_marked(M, i) ((M)->smallmap & idx2bit(i))

#define	mark_treemap(M, i) ((M)->treemap \|= idx2bit(i))

#define	clear_treemap(M, i) ((M)->treemap &= ~idx2bit(i))

#define	treemap_is_marked(M, i) ((M)->treemap & idx2bit(i))

#define	least_bit(x) ((x) & -(x))

#define	left_bits(x) ((x<<1) \| -(x<<1))

#define	same_or_left_bits(x) ((x) \| -(x))

#define	compute_bit2idx(X, I)

#define	ok_address(M, a) ((char*)(a) >= (M)->least_addr)

#define	ok_next(p, n) ((char)(p) < (char)(n))

#define	ok_inuse(p) is_inuse(p)

#define	ok_pinuse(p) pinuse(p)

#define	ok_magic(M) (1)

#define	RTCHECK(e) (e)

#define	mark_inuse_foot(M, p, s)

#define	set_inuse(M, p, s)

#define	set_inuse_and_pinuse(M, p, s)

#define	set_size_and_pinuse_of_inuse_chunk(M, p, s) ((p)->head = (s\|PINUSE_BIT\|CINUSE_BIT))

#define	insert_small_chunk(M, P, S)

#define	unlink_small_chunk(M, P, S)

#define	unlink_first_small_chunk(M, B, P, I)

#define	replace_dv(M, P, S)

#define	insert_large_chunk(M, X, S)

#define	unlink_large_chunk(M, X)

#define	insert_chunk(M, P, S)

#define	unlink_chunk(M, P, S)

#define	internal_malloc(m, b) dlmalloc(b)

#define	internal_free(m, mem) dlfree(mem)

#define	fm gm

Typedefs
typedef unsigned long	DWORD

typedef void *	HANDLE

typedef void *	PVOID

typedef long	LONG

typedef struct malloc_chunk	mchunk

typedef struct malloc_chunk *	mchunkptr

typedef struct malloc_chunk *	sbinptr

typedef unsigned int	bindex_t

typedef unsigned int	binmap_t

typedef unsigned int	flag_t

typedef struct malloc_tree_chunk	tchunk

typedef struct malloc_tree_chunk *	tchunkptr

typedef struct malloc_tree_chunk *	tbinptr

typedef struct malloc_segment	msegment

typedef struct malloc_segment *	msegmentptr

typedef struct malloc_state *	mstate

Functions
void *	au_request_page (int pages)

void	au_free_page (void *ptr, int pages)

DLMALLOC_EXPORT void *	dlmalloc (size_t)

DLMALLOC_EXPORT void	dlfree (void *)

DLMALLOC_EXPORT void *	dlcalloc (size_t, size_t)

DLMALLOC_EXPORT void *	dlrealloc (void *, size_t)

DLMALLOC_EXPORT void *	dlrealloc_in_place (void *, size_t)

DLMALLOC_EXPORT void *	dlmemalign (size_t, size_t)

DLMALLOC_EXPORT int	dlposix_memalign (void **, size_t, size_t)

DLMALLOC_EXPORT void *	dlvalloc (size_t)

DLMALLOC_EXPORT int	dlmallopt (int, int)

DLMALLOC_EXPORT size_t	dlmalloc_footprint (void)

DLMALLOC_EXPORT size_t	dlmalloc_max_footprint (void)

DLMALLOC_EXPORT size_t	dlmalloc_footprint_limit (void)

DLMALLOC_EXPORT size_t	dlmalloc_set_footprint_limit (size_t bytes)

DLMALLOC_EXPORT void **	dlindependent_calloc (size_t, size_t, void **)

DLMALLOC_EXPORT void **	dlindependent_comalloc (size_t, size_t , void *)

DLMALLOC_EXPORT size_t	dlbulk_free (void **, size_t n_elements)

DLMALLOC_EXPORT void *	dlpvalloc (size_t)

DLMALLOC_EXPORT int	dlmalloc_trim (size_t)

DLMALLOC_EXPORT void	dlmalloc_stats (void)

size_t	dlmalloc_usable_size (void *)

void *	sbrk (ptrdiff_t)

void **	dlindependent_calloc (size_t n_elements, size_t elem_size, void *chunks[])

void **	dlindependent_comalloc (size_t n_elements, size_t sizes[], void *chunks[])

size_t	dlbulk_free (void *array[], size_t nelem)

Macro Definition Documentation

◆ ABORT

#define ABORT for(;;);

◆ ABORT_ON_ASSERT_FAILURE

#define ABORT_ON_ASSERT_FAILURE 1

◆ ACQUIRE_MALLOC_GLOBAL_LOCK

#define ACQUIRE_MALLOC_GLOBAL_LOCK ( )

◆ align_as_chunk

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

◆ align_offset

#define align_offset ( A )

Value:

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

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

size_t

uint64_t size_t

Definition stdint.h:101

MALLOC_ALIGNMENT

#define MALLOC_ALIGNMENT

Definition dlmalloc.c:702

CHUNK_ALIGN_MASK

#define CHUNK_ALIGN_MASK

Definition dlmalloc.c:1697

◆ assert

#define assert ( x )

◆ bit_for_tree_index

#define bit_for_tree_index ( i ) (i == NTREEBINS-1)? (SIZE_T_BITSIZE-1) : (((i) >> 1) + TREEBIN_SHIFT - 2)

◆ CALL_DIRECT_MMAP

#define CALL_DIRECT_MMAP ( s ) DIRECT_MMAP_DEFAULT(s)

◆ CALL_MMAP [1/2]

#define CALL_MMAP ( s ) MMAP_DEFAULT(s)

◆ CALL_MMAP [2/2]

#define CALL_MMAP ( size ) au_request_page(size)

◆ CALL_MORECORE

#define CALL_MORECORE ( S ) MORECORE(S)

Define CALL_MORECORE

◆ CALL_MREMAP

#define CALL_MREMAP	(	addr,
		osz,
		nsz,
		mv
	)	MFAIL

Define CALL_MREMAP

◆ CALL_MUNMAP [1/2]

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

◆ CALL_MUNMAP [2/2]

#define CALL_MUNMAP	(	ptr,
		size
	)	au_free_page(ptr, size)

◆ calloc_must_clear

#define calloc_must_clear ( p ) (!is_mmapped(p))

◆ check_free_chunk

#define check_free_chunk	(	M,
		P
	)

◆ check_inuse_chunk

#define check_inuse_chunk	(	M,
		P
	)

◆ check_malloc_state

#define check_malloc_state ( M )

◆ check_malloced_chunk

#define check_malloced_chunk	(	M,
		P,
		N
	)

◆ check_mmapped_chunk

#define check_mmapped_chunk	(	M,
		P
	)

◆ check_top_chunk

#define check_top_chunk	(	M,
		P
	)

◆ chunk2mem

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

◆ CHUNK_ALIGN_MASK

#define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE)

◆ chunk_minus_offset

#define chunk_minus_offset	(	p,
		s
	)	((mchunkptr)(((char*)(p)) - (s)))

◆ CHUNK_OVERHEAD

#define CHUNK_OVERHEAD (SIZE_T_SIZE)

◆ chunk_plus_offset

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

◆ chunksize

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

◆ cinuse

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

◆ CINUSE_BIT

#define CINUSE_BIT (SIZE_T_TWO)

◆ clear_flag4

#define clear_flag4 ( p ) ((p)->head &= ~FLAG4_BIT)

◆ clear_pinuse

#define clear_pinuse ( p ) ((p)->head &= ~PINUSE_BIT)

◆ clear_smallmap

#define clear_smallmap	(	M,
		i
	)	((M)->smallmap &= ~idx2bit(i))

◆ clear_treemap

#define clear_treemap	(	M,
		i
	)	((M)->treemap &= ~idx2bit(i))

◆ CMFAIL

#define CMFAIL ((char*)(MFAIL)) /* defined for convenience */

◆ compute_bit2idx

#define compute_bit2idx	(	X,
		I
	)

Value:

{\
  unsigned int Y = X - 1;\
  unsigned int K = Y >> (16-4) & 16;\
  unsigned int N = K;        Y >>= K;\
  N += K = Y >> (8-3) &  8;  Y >>= K;\
  N += K = Y >> (4-2) &  4;  Y >>= K;\
  N += K = Y >> (2-1) &  2;  Y >>= K;\
  N += K = Y >> (1-0) &  1;  Y >>= K;\
  I = (bindex_t)(N + Y);\
}

◆ compute_tree_index

#define compute_tree_index	(	S,
		I
	)

Value:

{\
  size_t X = S >> TREEBIN_SHIFT;\
  if (X == 0)\
    I = 0;\
  else if (X > 0xFFFF)\
    I = NTREEBINS-1;\
  else {\
    unsigned int Y = (unsigned int)X;\
    unsigned int N = ((Y - 0x100) >> 16) & 8;\
    unsigned int K = (((Y <<= N) - 0x1000) >> 16) & 4;\
    N += K;\
    N += K = (((Y <<= K) - 0x4000) >> 16) & 2;\
    K = 14 - N + ((Y <<= K) >> 15);\
    I = (K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1));\
  }\
}

◆ CORRUPTION_ERROR_ACTION

#define CORRUPTION_ERROR_ACTION ( m ) ABORT

◆ DEBUG

#define DEBUG 0

◆ DEFAULT_GRANULARITY

#define DEFAULT_GRANULARITY 64

◆ DEFAULT_MMAP_THRESHOLD

#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)

◆ DEFAULT_TRIM_THRESHOLD

#define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T

◆ DESTROY_LOCK

#define DESTROY_LOCK ( l ) (0)

◆ DIRECT_MMAP_DEFAULT

#define DIRECT_MMAP_DEFAULT ( s ) MMAP_DEFAULT(s)

◆ disable_contiguous

#define disable_contiguous ( M ) ((M)->mflags |= USE_NONCONTIGUOUS_BIT)

◆ disable_lock

#define disable_lock ( M )

◆ disable_mmap

#define disable_mmap ( M ) ((M)->mflags &= ~USE_MMAP_BIT)

◆ DLMALLOC_EXPORT

#define DLMALLOC_EXPORT extern

◆ DLMALLOC_VERSION

#define DLMALLOC_VERSION 20806

◆ EINVAL

#define EINVAL 22

◆ enable_lock

#define enable_lock ( M ) ((M)->mflags |= USE_LOCK_BIT)

◆ enable_mmap

#define enable_mmap ( M ) ((M)->mflags |= USE_MMAP_BIT)

◆ ENOMEM

#define ENOMEM 12

◆ ENOTSUP

#define ENOTSUP 95

◆ ensure_initialization

#define ensure_initialization ( ) (void)(mparams.magic != 0 || init_mparams())

◆ errno [1/2]

#define errno _kernel_errno

◆ errno [2/2]

#define errno 0

◆ EXTERN_BIT

#define EXTERN_BIT (8U)

◆ FENCEPOST_HEAD

#define FENCEPOST_HEAD (INUSE_BITS|SIZE_T_SIZE)

◆ FLAG4_BIT

#define FLAG4_BIT (SIZE_T_FOUR)

◆ flag4inuse

#define flag4inuse ( p ) ((p)->head & FLAG4_BIT)

◆ FLAG_BITS

#define FLAG_BITS (PINUSE_BIT|CINUSE_BIT|FLAG4_BIT)

◆ FOOTERS

#define FOOTERS 0

◆ FORCEINLINE

#define FORCEINLINE

◆ FOUR_SIZE_T_SIZES

#define FOUR_SIZE_T_SIZES (SIZE_T_SIZE<<2)

◆ get_foot

#define get_foot	(	p,
		s
	)	(((mchunkptr)((char*)(p) + (s)))->prev_foot)

◆ granularity_align

#define granularity_align ( S )

Value:

(((S) + (mparams.granularity - SIZE_T_ONE))\

& ~(mparams.granularity - SIZE_T_ONE))

SIZE_T_ONE

#define SIZE_T_ONE

Definition dlmalloc.c:1688

malloc_params::granularity

size_t granularity

Definition dlmalloc.c:2700

◆ HALF_MAX_SIZE_T

#define HALF_MAX_SIZE_T (MAX_SIZE_T / 2U)

◆ HAVE_MMAP [1/2]

#define HAVE_MMAP 1

◆ HAVE_MMAP [2/2]

#define HAVE_MMAP 0

◆ HAVE_MORECORE

#define HAVE_MORECORE 1

◆ HAVE_MREMAP [1/2]

#define HAVE_MREMAP 0

◆ HAVE_MREMAP [2/2]

#define HAVE_MREMAP 0

◆ idx2bit

#define idx2bit ( i ) ((binmap_t)(1) << (i))

◆ INITIAL_LOCK

#define INITIAL_LOCK ( l ) (0)

◆ INSECURE

#define INSECURE 0

◆ insert_chunk

#define insert_chunk	(	M,
		P,
		S
	)

Value:

if (is_small(S)) insert_small_chunk(M, P, S)\

else { tchunkptr TP = (tchunkptr)(P); insert_large_chunk(M, TP, S); }

is_small

#define is_small(s)

Definition dlmalloc.c:2906

insert_large_chunk

#define insert_large_chunk(M, X, S)

Definition dlmalloc.c:3727

insert_small_chunk

#define insert_small_chunk(M, P, S)

Definition dlmalloc.c:3649

tchunkptr

struct malloc_tree_chunk * tchunkptr

Definition dlmalloc.c:2488

malloc_tree_chunk

Definition dlmalloc.c:2475

◆ insert_large_chunk

#define insert_large_chunk	(	M,
		X,
		S
	)

◆ insert_small_chunk

#define insert_small_chunk	(	M,
		P,
		S
	)

Value:

  {\
  bindex_t I  = small_index(S);\
  mchunkptr B = smallbin_at(M, I);\
  mchunkptr F = B;\
  assert(S >= MIN_CHUNK_SIZE);\
  if (!smallmap_is_marked(M, I))\
    mark_smallmap(M, I);\
  else if (RTCHECK(ok_address(M, B->fd)))\
    F = B->fd;\
  else {\
    CORRUPTION_ERROR_ACTION(M);\
  }\
  B->fd = P;\
  F->bk = P;\
  P->fd = F;\
  P->bk = B;\
}

◆ internal_free

#define internal_free	(	m,
		mem
	)	dlfree(mem)

◆ internal_malloc

#define internal_malloc	(	m,
		b
	)	dlmalloc(b)

◆ INUSE_BITS

#define INUSE_BITS (PINUSE_BIT|CINUSE_BIT)

◆ is_aligned

#define is_aligned ( A ) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0)

◆ is_extern_segment

#define is_extern_segment ( S ) ((S)->sflags & EXTERN_BIT)

◆ is_global

#define is_global ( M ) ((M) == &_gm_)

◆ is_granularity_aligned

#define is_granularity_aligned ( S ) (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0)

◆ is_initialized

#define is_initialized ( M ) ((M)->top != 0)

◆ is_inuse

#define is_inuse ( p ) (((p)->head & INUSE_BITS) != PINUSE_BIT)

◆ is_mmapped

#define is_mmapped ( p ) (((p)->head & INUSE_BITS) == 0)

◆ is_mmapped_segment

#define is_mmapped_segment ( S ) ((S)->sflags & USE_MMAP_BIT)

◆ is_page_aligned

#define is_page_aligned ( S ) (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0)

◆ is_small

#define is_small ( s ) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS)

◆ LACKS_ERRNO_H

#define LACKS_ERRNO_H 1

◆ LACKS_FCNTL_H [1/2]

#define LACKS_FCNTL_H

◆ LACKS_FCNTL_H [2/2]

#define LACKS_FCNTL_H 1

◆ LACKS_STDLIB_H

#define LACKS_STDLIB_H 1

◆ LACKS_STRING_H

#define LACKS_STRING_H 1

◆ LACKS_SYS_MMAN_H

#define LACKS_SYS_MMAN_H 1

◆ LACKS_SYS_PARAM_H

#define LACKS_SYS_PARAM_H

◆ LACKS_SYS_TYPES_H

#define LACKS_SYS_TYPES_H 1

◆ LACKS_TIME_H [1/2]

#define LACKS_TIME_H

◆ LACKS_TIME_H [2/2]

#define LACKS_TIME_H 1

◆ LACKS_UNISTD_H [1/2]

#define LACKS_UNISTD_H

◆ LACKS_UNISTD_H [2/2]

#define LACKS_UNISTD_H 1

◆ LACKS_WINDOWS_H

#define LACKS_WINDOWS_H 1

◆ least_bit

#define least_bit ( x ) ((x) & -(x))

◆ left_bits

#define left_bits ( x ) ((x<<1) | -(x<<1))

◆ leftmost_child

#define leftmost_child ( t ) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])

◆ leftshift_for_tree_index

#define leftshift_for_tree_index ( i )

Value:

((i == NTREEBINS-1)? 0 : \

((SIZE_T_BITSIZE-SIZE_T_ONE) - (((i) >> 1) + TREEBIN_SHIFT - 2)))

SIZE_T_BITSIZE

#define SIZE_T_BITSIZE

Definition dlmalloc.c:1683

◆ LOCK_AT_FORK

#define LOCK_AT_FORK 0

◆ M_GRANULARITY

#define M_GRANULARITY (-2)

◆ M_MMAP_THRESHOLD

#define M_MMAP_THRESHOLD (-3)

◆ M_TRIM_THRESHOLD

#define M_TRIM_THRESHOLD (-1)

◆ MALLINFO_FIELD_TYPE

#define MALLINFO_FIELD_TYPE size_t

◆ MALLOC_ALIGNMENT

#define MALLOC_ALIGNMENT ((size_t)(2 * sizeof(void *)))

◆ MALLOC_FAILURE_ACTION

#define MALLOC_FAILURE_ACTION

◆ malloc_getpagesize

#define malloc_getpagesize ((size_t)4096U)

◆ MALLOC_INSPECT_ALL

#define MALLOC_INSPECT_ALL 0

◆ mark_inuse_foot

#define mark_inuse_foot	(	M,
		p,
		s
	)

◆ mark_smallmap

#define mark_smallmap	(	M,
		i
	)	((M)->smallmap \|= idx2bit(i))

◆ mark_treemap

#define mark_treemap	(	M,
		i
	)	((M)->treemap \|= idx2bit(i))

◆ MAX_RELEASE_CHECK_RATE

#define MAX_RELEASE_CHECK_RATE 4095

◆ MAX_REQUEST

#define MAX_REQUEST ((-MIN_CHUNK_SIZE) << 2)

◆ MAX_SIZE_T

#define MAX_SIZE_T (~(size_t)0)

◆ MAX_SMALL_REQUEST

#define MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)

◆ MAX_SMALL_SIZE

#define MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE)

◆ MCHUNK_SIZE

#define MCHUNK_SIZE (sizeof(mchunk))

◆ mem2chunk

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

◆ MFAIL

#define MFAIL ((void*)(MAX_SIZE_T))

◆ MIN_CHUNK_SIZE

#define MIN_CHUNK_SIZE ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

◆ MIN_LARGE_SIZE

#define MIN_LARGE_SIZE (SIZE_T_ONE << TREEBIN_SHIFT)

◆ MIN_REQUEST

#define MIN_REQUEST (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)

◆ MIN_SMALL_INDEX

#define MIN_SMALL_INDEX (small_index(MIN_CHUNK_SIZE))

◆ minsize_for_tree_index

#define minsize_for_tree_index ( i )

Value:

((SIZE_T_ONE << (((i) >> 1) + TREEBIN_SHIFT)) | \

(((size_t)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1)))

◆ mmap_align

#define mmap_align ( S ) page_align(S)

◆ MMAP_CHUNK_OVERHEAD

#define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)

◆ MMAP_CLEARS

#define MMAP_CLEARS 1

◆ MMAP_DEFAULT

#define MMAP_DEFAULT ( s )

Value:

           ((dev_zero_fd < 0) ? \
           (dev_zero_fd = open("/dev/zero", O_RDWR), \
            mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \
            mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0))

◆ MMAP_FLAGS

#define MMAP_FLAGS (MAP_PRIVATE)

◆ MMAP_FOOT_PAD

#define MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES)

◆ MMAP_PROT

#define MMAP_PROT (PROT_READ|PROT_WRITE)

◆ MORECORE

#define MORECORE au_request_page

◆ MORECORE_CANNOT_TRIM

#define MORECORE_CANNOT_TRIM 0

◆ MORECORE_CONTIGUOUS [1/2]

#define MORECORE_CONTIGUOUS 1

◆ MORECORE_CONTIGUOUS [2/2]

#define MORECORE_CONTIGUOUS 0

◆ MORECORE_DEFAULT

#define MORECORE_DEFAULT sbrk

◆ MORECORE_FAILURE

#define MORECORE_FAILURE ((void*)(-1))

◆ MSPACES

#define MSPACES 0

◆ MUNMAP_DEFAULT

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

◆ next_chunk

#define next_chunk ( p ) ((mchunkptr)( ((char*)(p)) + ((p)->head & ~FLAG_BITS)))

◆ next_pinuse

#define next_pinuse ( p ) ((next_chunk(p)->head) & PINUSE_BIT)

◆ NO_MALLINFO

#define NO_MALLINFO 1

◆ NO_MALLOC_STATS [1/2]

#define NO_MALLOC_STATS 1

◆ NO_MALLOC_STATS [2/2]

#define NO_MALLOC_STATS 1

◆ NO_SEGMENT_TRAVERSAL

#define NO_SEGMENT_TRAVERSAL 0

◆ NOINLINE

#define NOINLINE

◆ NSMALLBINS

#define NSMALLBINS (32U)

◆ NTREEBINS

#define NTREEBINS (32U)

◆ ok_address

#define ok_address	(	M,
		a
	)	((char*)(a) >= (M)->least_addr)

◆ ok_inuse

#define ok_inuse ( p ) is_inuse(p)

◆ ok_magic

#define ok_magic ( M ) (1)

◆ ok_next

#define ok_next	(	p,
		n
	)	((char)(p) < (char)(n))

◆ ok_pinuse

#define ok_pinuse ( p ) pinuse(p)

◆ ONLY_MSPACES

#define ONLY_MSPACES 0

◆ overhead_for

#define overhead_for ( p ) (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD)

◆ pad_request

#define pad_request ( req ) (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

◆ page_align

#define page_align ( S ) (((S) + (mparams.page_size - SIZE_T_ONE)) & ~(mparams.page_size - SIZE_T_ONE))

◆ pinuse

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

◆ PINUSE_BIT

#define PINUSE_BIT (SIZE_T_ONE)

◆ POSTACTION

#define POSTACTION ( M )

◆ PREACTION

#define PREACTION ( M ) (0)

◆ prev_chunk

#define prev_chunk ( p ) ((mchunkptr)( ((char*)(p)) - ((p)->prev_foot) ))

◆ PROCEED_ON_ERROR

#define PROCEED_ON_ERROR 0

◆ RELEASE_MALLOC_GLOBAL_LOCK

#define RELEASE_MALLOC_GLOBAL_LOCK ( )

◆ replace_dv

#define replace_dv	(	M,
		P,
		S
	)

Value:

  {\
  size_t DVS = M->dvsize;\
  assert(is_small(DVS));\
  if (DVS != 0) {\
    mchunkptr DV = M->dv;\
    insert_small_chunk(M, DV, DVS);\
  }\
  M->dvsize = S;\
  M->dv = P;\
}

◆ request2size

#define request2size ( req ) (((req) < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(req))

◆ RTCHECK

#define RTCHECK ( e ) (e)

◆ same_or_left_bits

#define same_or_left_bits ( x ) ((x) | -(x))

◆ segment_holds

#define segment_holds	(	S,
		A
	)	((char)(A) >= S->base && (char)(A) < S->base + S->size)

◆ set_flag4

#define set_flag4 ( p ) ((p)->head |= FLAG4_BIT)

◆ set_foot

#define set_foot	(	p,
		s
	)	(((mchunkptr)((char*)(p) + (s)))->prev_foot = (s))

◆ set_free_with_pinuse

#define set_free_with_pinuse	(	p,
		s,
		n
	)	(clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s))

◆ set_inuse

#define set_inuse	(	M,
		p,
		s
	)

Value:

((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\

((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)

CINUSE_BIT

#define CINUSE_BIT

Definition dlmalloc.c:2329

PINUSE_BIT

#define PINUSE_BIT

Definition dlmalloc.c:2328

◆ set_inuse_and_pinuse

#define set_inuse_and_pinuse	(	M,
		p,
		s
	)

Value:

((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\

((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)

mchunkptr

struct malloc_chunk * mchunkptr

Definition dlmalloc.c:2274

◆ set_lock

#define set_lock	(	M,
		L
	)

Value:

 ((M)->mflags = (L)?\
  ((M)->mflags | USE_LOCK_BIT) :\
  ((M)->mflags & ~USE_LOCK_BIT))

◆ set_size_and_pinuse_of_free_chunk

#define set_size_and_pinuse_of_free_chunk	(	p,
		s
	)	((p)->head = (s\|PINUSE_BIT), set_foot(p, s))

◆ set_size_and_pinuse_of_inuse_chunk

#define set_size_and_pinuse_of_inuse_chunk	(	M,
		p,
		s
	)	((p)->head = (s\|PINUSE_BIT\|CINUSE_BIT))

◆ should_trim

#define should_trim	(	M,
		s
	)	(0)

◆ SIX_SIZE_T_SIZES

#define SIX_SIZE_T_SIZES (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)

◆ SIZE_T_BITSIZE

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

◆ SIZE_T_FOUR

#define SIZE_T_FOUR ((size_t)4)

◆ SIZE_T_ONE

#define SIZE_T_ONE ((size_t)1)

◆ SIZE_T_SIZE

#define SIZE_T_SIZE (sizeof(size_t))

◆ SIZE_T_TWO

#define SIZE_T_TWO ((size_t)2)

◆ SIZE_T_ZERO

#define SIZE_T_ZERO ((size_t)0)

◆ small_index

#define small_index ( s ) (bindex_t)((s) >> SMALLBIN_SHIFT)

◆ small_index2size

#define small_index2size ( i ) ((i) << SMALLBIN_SHIFT)

◆ smallbin_at

#define smallbin_at	(	M,
		i
	)	((sbinptr)((char*)&((M)->smallbins[(i)<<1])))

◆ SMALLBIN_SHIFT

#define SMALLBIN_SHIFT (3U)

◆ SMALLBIN_WIDTH

#define SMALLBIN_WIDTH (SIZE_T_ONE << SMALLBIN_SHIFT)

◆ smallmap_is_marked

#define smallmap_is_marked	(	M,
		i
	)	((M)->smallmap & idx2bit(i))

◆ stderr

#define stderr 0

◆ SYS_ALLOC_PADDING

#define SYS_ALLOC_PADDING (TOP_FOOT_SIZE + MALLOC_ALIGNMENT)

◆ TOP_FOOT_SIZE

#define TOP_FOOT_SIZE (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE)

◆ treebin_at

#define treebin_at	(	M,
		i
	)	(&((M)->treebins[i]))

◆ TREEBIN_SHIFT

#define TREEBIN_SHIFT (8U)

◆ treemap_is_marked

#define treemap_is_marked	(	M,
		i
	)	((M)->treemap & idx2bit(i))

◆ TWO_SIZE_T_SIZES

#define TWO_SIZE_T_SIZES (SIZE_T_SIZE<<1)

◆ unlink_chunk

#define unlink_chunk	(	M,
		P,
		S
	)

Value:

if (is_small(S)) unlink_small_chunk(M, P, S)\

else { tchunkptr TP = (tchunkptr)(P); unlink_large_chunk(M, TP); }

unlink_large_chunk

#define unlink_large_chunk(M, X)

Definition dlmalloc.c:3795

unlink_small_chunk

#define unlink_small_chunk(M, P, S)

Definition dlmalloc.c:3668

◆ unlink_first_small_chunk

#define unlink_first_small_chunk	(	M,
		B,
		P,
		I
	)

Value:

  {\
  mchunkptr F = P->fd;\
  assert(P != B);\
  assert(P != F);\
  assert(chunksize(P) == small_index2size(I));\
  if (B == F) {\
    clear_smallmap(M, I);\
  }\
  else if (RTCHECK(ok_address(M, F) && F->bk == P)) {\
    F->bk = B;\
    B->fd = F;\
  }\
  else {\
    CORRUPTION_ERROR_ACTION(M);\
  }\
}

◆ unlink_large_chunk

#define unlink_large_chunk	(	M,
		X
	)

◆ unlink_small_chunk

#define unlink_small_chunk	(	M,
		P,
		S
	)

Value:

  {\
  mchunkptr F = P->fd;\
  mchunkptr B = P->bk;\
  bindex_t I = small_index(S);\
  assert(P != B);\
  assert(P != F);\
  assert(chunksize(P) == small_index2size(I));\
  if (RTCHECK(F == smallbin_at(M,I) || (ok_address(M, F) && F->bk == P))) { \
    if (B == F) {\
      clear_smallmap(M, I);\
    }\
    else if (RTCHECK(B == smallbin_at(M,I) ||\
                     (ok_address(M, B) && B->fd == P))) {\
      F->bk = B;\
      B->fd = F;\
    }\
    else {\
      CORRUPTION_ERROR_ACTION(M);\
    }\
  }\
  else {\
    CORRUPTION_ERROR_ACTION(M);\
  }\
}

◆ USAGE_ERROR_ACTION

#define USAGE_ERROR_ACTION	(	m,
		p
	)	ABORT

◆ USE_BUILTIN_FFS

#define USE_BUILTIN_FFS 0

◆ USE_DEV_RANDOM

#define USE_DEV_RANDOM 0

◆ USE_DL_PREFIX

#define USE_DL_PREFIX

◆ use_lock

#define use_lock ( M ) ((M)->mflags & USE_LOCK_BIT)

◆ USE_LOCK_BIT

#define USE_LOCK_BIT (0U)

◆ USE_LOCKS

#define USE_LOCKS 0

◆ use_mmap

#define use_mmap ( M ) ((M)->mflags & USE_MMAP_BIT)

◆ USE_MMAP_BIT

#define USE_MMAP_BIT (SIZE_T_ONE)

Define CALL_MMAP/CALL_MUNMAP/CALL_DIRECT_MMAP

◆ use_noncontiguous

#define use_noncontiguous ( M ) ((M)->mflags & USE_NONCONTIGUOUS_BIT)

◆ USE_NONCONTIGUOUS_BIT

#define USE_NONCONTIGUOUS_BIT (4U)

◆ USE_SPIN_LOCKS

#define USE_SPIN_LOCKS 0

Typedef Documentation

◆ bindex_t

typedef unsigned int bindex_t

◆ binmap_t

typedef unsigned int binmap_t

◆ DWORD

typedef unsigned long DWORD

◆ flag_t

typedef unsigned int flag_t

◆ HANDLE

typedef void* HANDLE

◆ LONG

typedef long LONG

◆ mchunk

typedef struct malloc_chunk mchunk

◆ mchunkptr

typedef struct malloc_chunk* mchunkptr

◆ msegment

typedef struct malloc_segment msegment

◆ msegmentptr

typedef struct malloc_segment* msegmentptr

◆ mstate

typedef struct malloc_state* mstate

◆ PVOID

typedef void* PVOID

◆ sbinptr

typedef struct malloc_chunk* sbinptr

◆ tbinptr

typedef struct malloc_tree_chunk* tbinptr

◆ tchunk

typedef struct malloc_tree_chunk tchunk

◆ tchunkptr

typedef struct malloc_tree_chunk* tchunkptr

Function Documentation

◆ au_free_page()

void au_free_page	(	void *	ptr,
		int	pages
	)

extern

BSD 2-Clause License

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

◆ au_request_page()

void * au_request_page ( int pages )

extern

◆ dlbulk_free() [1/2]

DLMALLOC_EXPORT size_t dlbulk_free	(	void **	,
		size_t	n_elements
	)

◆ dlbulk_free() [2/2]

size_t dlbulk_free	(	void *	array[],
		size_t	nelem
	)

◆ dlcalloc()

void * dlcalloc	(	size_t	n_elements,
		size_t	elem_size
	)

◆ dlfree()

DLMALLOC_EXPORT void dlfree ( void * mem )

◆ dlindependent_calloc() [1/2]

void ** dlindependent_calloc	(	size_t	n_elements,
		size_t	elem_size,
		void *	chunks[]
	)

◆ dlindependent_calloc() [2/2]

DLMALLOC_EXPORT void ** dlindependent_calloc	(	size_t	,
		size_t	,
		void **
	)

◆ dlindependent_comalloc() [1/2]

void ** dlindependent_comalloc	(	size_t	n_elements,
		size_t	sizes[],
		void *	chunks[]
	)

◆ dlindependent_comalloc() [2/2]

DLMALLOC_EXPORT void ** dlindependent_comalloc	(	size_t	,
		size_t *	,
		void **
	)

◆ dlmalloc()

DLMALLOC_EXPORT void * dlmalloc ( size_t bytes )

◆ dlmalloc_footprint()

size_t dlmalloc_footprint ( void )

◆ dlmalloc_footprint_limit()

size_t dlmalloc_footprint_limit ( void )

◆ dlmalloc_max_footprint()

size_t dlmalloc_max_footprint ( void )

◆ dlmalloc_set_footprint_limit()

size_t dlmalloc_set_footprint_limit ( size_t bytes )

◆ dlmalloc_stats()

DLMALLOC_EXPORT void dlmalloc_stats ( void )

◆ dlmalloc_trim()

int dlmalloc_trim ( size_t pad )

◆ dlmalloc_usable_size()

size_t dlmalloc_usable_size ( void * mem )

◆ dlmallopt()

int dlmallopt	(	int	param_number,
		int	value
	)

◆ dlmemalign()

void * dlmemalign	(	size_t	alignment,
		size_t	bytes
	)

◆ dlposix_memalign()

int dlposix_memalign	(	void **	pp,
		size_t	alignment,
		size_t	bytes
	)

◆ dlpvalloc()

void * dlpvalloc ( size_t bytes )

◆ dlrealloc()

void * dlrealloc	(	void *	oldmem,
		size_t	bytes
	)

◆ dlrealloc_in_place()

void * dlrealloc_in_place	(	void *	oldmem,
		size_t	bytes
	)

◆ dlvalloc()

void * dlvalloc ( size_t bytes )

◆ sbrk()

void * sbrk ( ptrdiff_t )

extern

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ ABORT

◆ ABORT_ON_ASSERT_FAILURE

◆ ACQUIRE_MALLOC_GLOBAL_LOCK

◆ align_as_chunk

◆ align_offset

◆ assert

◆ bit_for_tree_index

◆ CALL_DIRECT_MMAP

◆ CALL_MMAP [1/2]

◆ CALL_MMAP [2/2]

◆ CALL_MORECORE

◆ CALL_MREMAP

◆ CALL_MUNMAP [1/2]

◆ CALL_MUNMAP [2/2]

◆ calloc_must_clear

◆ check_free_chunk

◆ check_inuse_chunk

◆ check_malloc_state

◆ check_malloced_chunk

◆ check_mmapped_chunk

◆ check_top_chunk

◆ chunk2mem

◆ CHUNK_ALIGN_MASK

◆ chunk_minus_offset

◆ CHUNK_OVERHEAD

◆ chunk_plus_offset

◆ chunksize

◆ cinuse

◆ CINUSE_BIT

◆ clear_flag4

◆ clear_pinuse

◆ clear_smallmap

◆ clear_treemap

◆ CMFAIL

◆ compute_bit2idx

◆ compute_tree_index

◆ CORRUPTION_ERROR_ACTION

◆ DEBUG

◆ DEFAULT_GRANULARITY

◆ DEFAULT_MMAP_THRESHOLD

◆ DEFAULT_TRIM_THRESHOLD

◆ DESTROY_LOCK

◆ DIRECT_MMAP_DEFAULT

◆ disable_contiguous

◆ disable_lock

◆ disable_mmap

◆ DLMALLOC_EXPORT

◆ DLMALLOC_VERSION

◆ EINVAL

◆ enable_lock

◆ enable_mmap

◆ ENOMEM

◆ ENOTSUP

◆ ensure_initialization

◆ errno [1/2]

◆ errno [2/2]

◆ EXTERN_BIT

◆ FENCEPOST_HEAD

◆ FLAG4_BIT

◆ flag4inuse

◆ FLAG_BITS

◆ fm

◆ FOOTERS

◆ FORCEINLINE

◆ FOUR_SIZE_T_SIZES

◆ get_foot

◆ gm

◆ granularity_align

◆ HALF_MAX_SIZE_T

◆ HAVE_MMAP [1/2]

◆ HAVE_MMAP [2/2]

◆ HAVE_MORECORE

◆ HAVE_MREMAP [1/2]

◆ HAVE_MREMAP [2/2]

◆ idx2bit