File malloc_2_8_3.c¶

FileList > cubrid > src > heaplayers > malloc_2_8_3.c

#include <sys/types.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/param.h>

Classes¶

Type	Name
struct	mallinfo
struct	malloc_chunk
struct	malloc_params
struct	malloc_segment
struct	malloc_state
struct	malloc_tree_chunk

Public Types¶

Type	Name
typedef unsigned int	bindex_t
typedef unsigned int	binmap_t
typedef unsigned int	flag_t
typedef struct malloc_chunk	mchunk
typedef struct malloc_chunk *	mchunkptr
typedef struct malloc_segment	msegment
typedef struct malloc_segment *	msegmentptr
typedef struct malloc_state *	mstate
typedef struct malloc_chunk *	sbinptr
typedef struct malloc_tree_chunk *	tbinptr
typedef struct malloc_tree_chunk	tchunk
typedef struct malloc_tree_chunk *	tchunkptr

Public Static Attributes¶

Type	Name
struct malloc_state	_gm_
int	dev_zero_fd = `-1`
struct malloc_params	mparams

Public Functions¶

Type	Name
void *	calloc (size_t n_elements, size_t elem_size)
void	free (void * mem)
void **	independent_calloc (size_t, size_t, void **)
void **	independent_calloc (size_t n_elements, size_t elem_size, void * chunks)
void **	independent_comalloc (size_t, size_t , void* **)
void **	independent_comalloc (size_t n_elements, size_t sizes, void * chunks)
struct mallinfo	mallinfo (void)
void *	malloc (size_t bytes)
size_t	malloc_footprint (void)
size_t	malloc_max_footprint (void)
void	malloc_stats (void)
int	malloc_trim (size_t pad)
size_t	malloc_usable_size (void * mem)
int	mallopt (int param_number, int value)
void *	memalign (size_t alignment, size_t bytes)
void *	pvalloc (size_t bytes)
void *	realloc (void * oldmem, size_t bytes)
void *	valloc (size_t bytes)

Public Static Functions¶

Type	Name
void	add_segment (mstate m, char * tbase, size_t tsize, flag_t mmapped)
int	change_mparam (int param_number, int value)
int	has_segment_link (mstate m, msegmentptr ss)
void **	ialloc (mstate m, size_t n_elements, size_t * sizes, int opts, void * chunks)
void	init_bins (mstate m)
int	init_mparams (void)
void	init_top (mstate m, mchunkptr p, size_t psize)
struct mallinfo	internal_mallinfo (mstate m)
void	internal_malloc_stats (mstate m)
void *	internal_memalign (mstate m, size_t alignment, size_t bytes)
void *	internal_realloc (mstate m, void * oldmem, size_t bytes)
void *	mmap_alloc (mstate m, size_t nb)
mchunkptr	mmap_resize (mstate m, mchunkptr oldp, size_t nb)
void *	prepend_alloc (mstate m, char * newbase, char * oldbase, size_t nb)
size_t	release_unused_segments (mstate m)
msegmentptr	segment_holding (mstate m, char * addr)
void *	sys_alloc (mstate m, size_t nb)
int	sys_trim (mstate m, size_t pad)
void *	tmalloc_large (mstate m, size_t nb)
void *	tmalloc_small (mstate m, size_t nb)

Macros¶

Type	Name
define	ABORT `abort()`
define	ABORT_ON_ASSERT_FAILURE `1`
define	ACQUIRE_MAGIC_INIT_LOCK ()
define	ACQUIRE_MORECORE_LOCK ()
define	CALL_MMAP (s) `/* multi line expression */`
define	CALL_MORECORE (S) `[MORECORE](malloc__2__8__3_8c.md#define-morecore)(S)`
define	CALL_MREMAP (addr, osz, nsz, mv) `[MFAIL](malloc__2__8__3_8c.md#define-mfail)`
define	CALL_MUNMAP (a, s) `[munmap](broker__monitor_8c.md#function-timeout)(([a](broker__monitor_8c.md#function-timeout)), (s))`
define	CHUNK_ALIGN_MASK `([MALLOC\_ALIGNMENT](malloc__2__8__3_8c.md#define-malloc_alignment) - [SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one))`
define	CHUNK_OVERHEAD `([SIZE\_T\_SIZE](malloc__2__8__3_8c.md#define-size_t_size))`
define	CINUSE_BIT `([SIZE\_T\_TWO](malloc__2__8__3_8c.md#define-size_t_two))`
define	CMFAIL `(([char](broker__monitor_8c.md#function-timeout)\)([MFAIL](malloc__2__8__3_8c.md#define-mfail))) /\ [defined](broker__monitor_8c.md#function-timeout) [for](dynamic__load_8c.md#function-for) [convenience](broker__monitor_8c.md#function-timeout) \*/`
define	CORRUPTION_ERROR_ACTION (m) `[ABORT](malloc__2__8__3_8c.md#define-abort)`
define	DEFAULT_GRANULARITY `(0) /\* 0 [means](broker__monitor_8c.md#function-timeout) to [compute](broker__monitor_8c.md#function-timeout) in [init\_mparams](malloc__2__8__3_8c.md#function-init_mparams) \*/`
define	DEFAULT_MMAP_THRESHOLD `(([size\_t](broker__monitor_8c.md#function-timeout))256[U](broker__monitor_8c.md#function-timeout) \* ([size\_t](broker__monitor_8c.md#function-timeout))1024[U](broker__monitor_8c.md#function-timeout))`
define	DEFAULT_TRIM_THRESHOLD `(([size\_t](broker__monitor_8c.md#function-timeout))2[U](broker__monitor_8c.md#function-timeout) \* ([size\_t](broker__monitor_8c.md#function-timeout))1024[U](broker__monitor_8c.md#function-timeout) \* ([size\_t](broker__monitor_8c.md#function-timeout))1024[U](broker__monitor_8c.md#function-timeout))`
define	DIRECT_MMAP (s) `[CALL\_MMAP](malloc__2__8__3_8c.md#define-call_mmap)(s)`
define	EXTERN_BIT `(8[U](broker__monitor_8c.md#function-timeout))`
define	FENCEPOST_HEAD `([INUSE\_BITS](malloc__2__8__3_8c.md#define-inuse_bits)\\|[SIZE\_T\_SIZE](malloc__2__8__3_8c.md#define-size_t_size))`
define	FOOTERS `0`
define	FOUR_SIZE_T_SIZES `([SIZE\_T\_SIZE](malloc__2__8__3_8c.md#define-size_t_size)<<2)`
define	HALF_MAX_SIZE_T `([MAX\_SIZE\_T](malloc__2__8__3_8c.md#define-max_size_t) / 2[U](broker__monitor_8c.md#function-timeout))`
define	HAVE_MMAP `1`
define	HAVE_MORECORE `1`
define	HAVE_MREMAP `0`
define	INITIAL_LOCK (l)
define	INSECURE `0`
define	INUSE_BITS `([PINUSE\_BIT](malloc__2__8__3_8c.md#define-pinuse_bit)\\|[CINUSE\_BIT](malloc__2__8__3_8c.md#define-cinuse_bit))`
define	IS_MMAPPED_BIT `([SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one))`
define	MALLINFO_FIELD_TYPE `[size\_t](broker__monitor_8c.md#function-timeout)`
define	MALLOC_ALIGNMENT `(([size\_t](broker__monitor_8c.md#function-timeout))8[U](broker__monitor_8c.md#function-timeout))`
define	MALLOC_FAILURE_ACTION `[errno](broker__monitor_8c.md#function-timeout) = [ENOMEM](broker__monitor_8c.md#function-timeout);`
define	MAX_REQUEST `((-[MIN\_CHUNK\_SIZE](malloc__2__8__3_8c.md#define-min_chunk_size)) << 2)`
define	MAX_SIZE_T `(~([size\_t](broker__monitor_8c.md#function-timeout))0)`
define	MAX_SMALL_REQUEST `([MAX\_SMALL\_SIZE](malloc__2__8__3_8c.md#define-max_small_size) - [CHUNK\_ALIGN\_MASK](malloc__2__8__3_8c.md#define-chunk_align_mask) - [CHUNK\_OVERHEAD](malloc__2__8__3_8c.md#define-chunk_overhead))`
define	MAX_SMALL_SIZE `([MIN\_LARGE\_SIZE](malloc__2__8__3_8c.md#define-min_large_size) - [SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one))`
define	MCHUNK_SIZE `([sizeof](broker__monitor_8c.md#function-timeout)([mchunk](malloc__2__8__3_8c.md#typedef-mchunk)))`
define	MFAIL `(([void](broker__monitor_8c.md#function-timeout)\)([MAX\_SIZE\_T*](malloc__2__8__3_8c.md#define-max_size_t)))`
define	MIN_CHUNK_SIZE `(([MCHUNK\_SIZE](malloc__2__8__3_8c.md#define-mchunk_size) + [CHUNK\_ALIGN\_MASK](malloc__2__8__3_8c.md#define-chunk_align_mask)) & ~[CHUNK\_ALIGN\_MASK](malloc__2__8__3_8c.md#define-chunk_align_mask))`
define	MIN_LARGE_SIZE `([SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one) << [TREEBIN\_SHIFT](malloc__2__8__3_8c.md#define-treebin_shift))`
define	MIN_REQUEST `([MIN\_CHUNK\_SIZE](malloc__2__8__3_8c.md#define-min_chunk_size) - [CHUNK\_OVERHEAD](malloc__2__8__3_8c.md#define-chunk_overhead) - [SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one))`
define	MIN_SMALL_INDEX `([small\_index](malloc__2__8__3_8c.md#define-small_index)([MIN\_CHUNK\_SIZE](malloc__2__8__3_8c.md#define-min_chunk_size)))`
define	MMAP_CHUNK_OVERHEAD `([TWO\_SIZE\_T\_SIZES](malloc__2__8__3_8c.md#define-two_size_t_sizes))`
define	MMAP_CLEARS `1`
define	MMAP_FLAGS `([MAP\_PRIVATE](broker__monitor_8c.md#function-timeout))`
define	MMAP_FOOT_PAD `([FOUR\_SIZE\_T\_SIZES](malloc__2__8__3_8c.md#define-four_size_t_sizes))`
define	MMAP_PROT `([PROT\_READ](broker__monitor_8c.md#function-timeout)\\|[PROT\_WRITE](broker__monitor_8c.md#function-timeout))`
define	MORECORE `[sbrk](broker__monitor_8c.md#function-timeout)`
define	MORECORE_CONTIGUOUS `1`
define	MSPACES `0`
define	M_GRANULARITY `(-2)`
define	M_MMAP_THRESHOLD `(-3)`
define	M_TRIM_THRESHOLD `(-1)`
define	NO_MALLINFO `0`
define	NSMALLBINS `(32[U](broker__monitor_8c.md#function-timeout))`
define	NTREEBINS `(32[U](broker__monitor_8c.md#function-timeout))`
define	ONLY_MSPACES `0`
define	PINUSE_BIT `([SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one))`
define	POSTACTION (M)
define	PREACTION (M) `(0)`
define	PROCEED_ON_ERROR `0`
define	RELEASE_MAGIC_INIT_LOCK ()
define	RELEASE_MORECORE_LOCK ()
define	RTCHECK (e) `[\_\_builtin\_expect](broker__monitor_8c.md#function-timeout)([e](broker__monitor_8c.md#function-timeout), 1)`
define	SIX_SIZE_T_SIZES `([FOUR\_SIZE\_T\_SIZES](malloc__2__8__3_8c.md#define-four_size_t_sizes)+[TWO\_SIZE\_T\_SIZES](malloc__2__8__3_8c.md#define-two_size_t_sizes))`
define	SIZE_T_BITSIZE `([sizeof](broker__monitor_8c.md#function-timeout)([size\_t](broker__monitor_8c.md#function-timeout)) << 3)`
define	SIZE_T_ONE `(([size\_t](broker__monitor_8c.md#function-timeout))1)`
define	SIZE_T_SIZE `([sizeof](broker__monitor_8c.md#function-timeout)([size\_t](broker__monitor_8c.md#function-timeout)))`
define	SIZE_T_TWO `(([size\_t](broker__monitor_8c.md#function-timeout))2)`
define	SIZE_T_ZERO `(([size\_t](broker__monitor_8c.md#function-timeout))0)`
define	SMALLBIN_SHIFT `(3[U](broker__monitor_8c.md#function-timeout))`
define	SMALLBIN_WIDTH `([SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one) << [SMALLBIN\_SHIFT](malloc__2__8__3_8c.md#define-smallbin_shift))`
define	TOP_FOOT_SIZE `([align\_offset](malloc__2__8__3_8c.md#define-align_offset)([chunk2mem](malloc__2__8__3_8c.md#define-chunk2mem)(0))+[pad\_request](malloc__2__8__3_8c.md#define-pad_request)([sizeof](broker__monitor_8c.md#function-timeout)([struct](broker__monitor_8c.md#function-timeout) [malloc\_segment](structmalloc__segment.md)))+[MIN\_CHUNK\_SIZE](malloc__2__8__3_8c.md#define-min_chunk_size))`
define	TREEBIN_SHIFT `(8[U](broker__monitor_8c.md#function-timeout))`
define	TWO_SIZE_T_SIZES `([SIZE\_T\_SIZE](malloc__2__8__3_8c.md#define-size_t_size)<<1)`
define	USAGE_ERROR_ACTION (m, p) `[ABORT](malloc__2__8__3_8c.md#define-abort)`
define	USE_BUILTIN_FFS `0`
define	USE_DEV_RANDOM `0`
define	USE_LOCKS `0`
define	USE_LOCK_BIT `(0U)`
define	USE_MALLOC_INSTEAD `0`
define	USE_MMAP_BIT `([SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one))`
define	USE_NONCONTIGUOUS_BIT `(4[U](broker__monitor_8c.md#function-timeout))`
define	align_as_chunk (A) `([mchunkptr](malloc__2__8__3_8c.md#typedef-mchunkptr))(([A](broker__monitor_8c.md#function-timeout)) + [align\_offset](malloc__2__8__3_8c.md#define-align_offset)([chunk2mem](malloc__2__8__3_8c.md#define-chunk2mem)([A](broker__monitor_8c.md#function-timeout))))`
define	align_offset (A) `/* multi line expression */`
define	assert (x)
define	bit_for_tree_index (i) `([i](dynamic__load_8c.md#variable-i) == [NTREEBINS](malloc__2__8__3_8c.md#define-ntreebins)-1)? ([SIZE\_T\_BITSIZE](malloc__2__8__3_8c.md#define-size_t_bitsize)-1) : ((([i](dynamic__load_8c.md#variable-i)) >> 1) + [TREEBIN\_SHIFT](malloc__2__8__3_8c.md#define-treebin_shift) - 2)`
define	calloc_must_clear (p) `(![is\_mmapped](malloc__2__8__3_8c.md#define-is_mmapped)([p](dynamic__load_8c.md#variable-p)))`
define	check_free_chunk (M, P)
define	check_inuse_chunk (M, P)
define	check_malloc_state (M)
define	check_malloced_chunk (M, P, N)
define	check_mmapped_chunk (M, P)
define	check_top_chunk (M, P)
define	chunk2mem (p) `(([void](broker__monitor_8c.md#function-timeout)\)(([char](broker__monitor_8c.md#function-timeout)\)([p](dynamic__load_8c.md#variable-p)) + [TWO\_SIZE\_T\_SIZES](malloc__2__8__3_8c.md#define-two_size_t_sizes)))`
define	chunk_minus_offset (p, s) `(([mchunkptr](malloc__2__8__3_8c.md#typedef-mchunkptr))((([char](broker__monitor_8c.md#function-timeout)\)([p*](dynamic__load_8c.md#variable-p))) - (s)))`
define	chunk_plus_offset (p, s) `(([mchunkptr](malloc__2__8__3_8c.md#typedef-mchunkptr))((([char](broker__monitor_8c.md#function-timeout)\)([p*](dynamic__load_8c.md#variable-p))) + (s)))`
define	chunksize (p) `(([p](dynamic__load_8c.md#variable-p))->head & ~([INUSE\_BITS](malloc__2__8__3_8c.md#define-inuse_bits)))`
define	cinuse (p) `(([p](dynamic__load_8c.md#variable-p))->head & [CINUSE\_BIT](malloc__2__8__3_8c.md#define-cinuse_bit))`
define	clear_cinuse (p) `(([p](dynamic__load_8c.md#variable-p))->head &= ~[CINUSE\_BIT](malloc__2__8__3_8c.md#define-cinuse_bit))`
define	clear_pinuse (p) `(([p](dynamic__load_8c.md#variable-p))->head &= ~[PINUSE\_BIT](malloc__2__8__3_8c.md#define-pinuse_bit))`
define	clear_smallmap (M, i) `((M)->smallmap &= ~[idx2bit](malloc__2__8__3_8c.md#define-idx2bit)([i](dynamic__load_8c.md#variable-i)))`
define	clear_treemap (M, i) `((M)->treemap &= ~[idx2bit](malloc__2__8__3_8c.md#define-idx2bit)([i](dynamic__load_8c.md#variable-i)))`
define	compute_bit2idx (X, I) `/* multi line expression */`
define	compute_tree_index (S, I) `/* multi line expression */`
define	disable_contiguous (M) `((M)->mflags \\|= [USE\_NONCONTIGUOUS\_BIT](malloc__2__8__3_8c.md#define-use_noncontiguous_bit))`
define	disable_lock (M) `((M)->mflags &= ~[USE\_LOCK\_BIT](malloc__2__8__3_8c.md#define-use_lock_bit))`
define	disable_mmap (M) `((M)->mflags &= ~[USE\_MMAP\_BIT](malloc__2__8__3_8c.md#define-use_mmap_bit))`
define	dlcalloc `[calloc](memory__cwrapper_8h.md#define-calloc)`
define	dlfree `[free](memory__cwrapper_8h.md#define-free)`
define	dlindependent_calloc `[independent\_calloc](malloc__2__8__3_8c.md#function-independent_calloc)`
define	dlindependent_comalloc `[independent\_comalloc](malloc__2__8__3_8c.md#function-independent_comalloc)`
define	dlmallinfo `[mallinfo](structmallinfo.md)`
define	dlmalloc `[malloc](memory__cwrapper_8h.md#define-malloc)`
define	dlmalloc_footprint `[malloc\_footprint](malloc__2__8__3_8c.md#function-malloc_footprint)`
define	dlmalloc_max_footprint `[malloc\_max\_footprint](malloc__2__8__3_8c.md#function-malloc_max_footprint)`
define	dlmalloc_stats `[malloc\_stats](malloc__2__8__3_8c.md#function-malloc_stats)`
define	dlmalloc_trim `[malloc\_trim](malloc__2__8__3_8c.md#function-malloc_trim)`
define	dlmalloc_usable_size `[malloc\_usable\_size](malloc__2__8__3_8c.md#function-malloc_usable_size)`
define	dlmallopt `[mallopt](malloc__2__8__3_8c.md#function-mallopt)`
define	dlmemalign `[memalign](malloc__2__8__3_8c.md#function-memalign)`
define	dlpvalloc `[pvalloc](malloc__2__8__3_8c.md#function-pvalloc)`
define	dlrealloc `[realloc](memory__cwrapper_8h.md#define-realloc)`
define	dlvalloc `[valloc](malloc__2__8__3_8c.md#function-valloc)`
define	enable_lock (M) `((M)->mflags \\|= [USE\_LOCK\_BIT](malloc__2__8__3_8c.md#define-use_lock_bit))`
define	enable_mmap (M) `((M)->mflags \\|= [USE\_MMAP\_BIT](malloc__2__8__3_8c.md#define-use_mmap_bit))`
define	fm `[gm](malloc__2__8__3_8c.md#define-gm)`
define	get_foot (p, s) `((([mchunkptr](malloc__2__8__3_8c.md#typedef-mchunkptr))(([char](broker__monitor_8c.md#function-timeout)\)([p*](dynamic__load_8c.md#variable-p)) + (s)))->prev\_foot)`
define	gm `(&[\_gm\_](malloc__2__8__3_8c.md#variable-_gm_))`
define	granularity_align (S) `(((S) + (mparams.granularity)) & ~(mparams.granularity - [SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one)))`
define	idx2bit (i) `(([binmap\_t](malloc__2__8__3_8c.md#typedef-binmap_t))(1) << ([i](dynamic__load_8c.md#variable-i)))`
define	insert_chunk (M, P, S) `/* multi line expression */`
define	insert_large_chunk (M, X, S)
define	insert_small_chunk (M, P, S) `/* multi line expression */`
define	internal_free (m, mem) `[dlfree](malloc__2__8__3_8c.md#define-dlfree)(mem)`
define	internal_malloc (m, b) `[dlmalloc](malloc__2__8__3_8c.md#define-dlmalloc)(b)`
define	is_aligned (A) `((([size\_t](broker__monitor_8c.md#function-timeout))(([A](broker__monitor_8c.md#function-timeout))) & ([CHUNK\_ALIGN\_MASK](malloc__2__8__3_8c.md#define-chunk_align_mask))) == 0)`
define	is_extern_segment (S) `((S)->sflags & [EXTERN\_BIT](malloc__2__8__3_8c.md#define-extern_bit))`
define	is_global (M) `((M) == &[\_gm\_](malloc__2__8__3_8c.md#variable-_gm_))`
define	is_granularity_aligned (S) `((([size\_t](broker__monitor_8c.md#function-timeout))(S) & (mparams.granularity - [SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one))) == 0)`
define	is_initialized (M) `((M)->top != 0)`
define	is_mmapped (p) `(!(([p](dynamic__load_8c.md#variable-p))->head & [PINUSE\_BIT](malloc__2__8__3_8c.md#define-pinuse_bit)) && (([p](dynamic__load_8c.md#variable-p))->prev\_foot & [IS\_MMAPPED\_BIT](malloc__2__8__3_8c.md#define-is_mmapped_bit)))`
define	is_mmapped_segment (S) `((S)->sflags & [IS\_MMAPPED\_BIT](malloc__2__8__3_8c.md#define-is_mmapped_bit))`
define	is_page_aligned (S) `((([size\_t](broker__monitor_8c.md#function-timeout))(S) & ([mparams.page\_size](unloaddb_8c.md#variable-page_size) - [SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one))) == 0)`
define	is_small (s) `(((s) >> [SMALLBIN\_SHIFT](malloc__2__8__3_8c.md#define-smallbin_shift)) < [NSMALLBINS](malloc__2__8__3_8c.md#define-nsmallbins))`
define	least_bit (x) `(([x](broker__monitor_8c.md#function-timeout)) & -([x](broker__monitor_8c.md#function-timeout)))`
define	left_bits (x) `(([x](broker__monitor_8c.md#function-timeout)<<1) \\| -([x](broker__monitor_8c.md#function-timeout)<<1))`
define	leftmost_child (t) `(([t](broker__monitor_8c.md#function-timeout))->child[0] != 0? ([t](broker__monitor_8c.md#function-timeout))->child[0] : ([t](broker__monitor_8c.md#function-timeout))->child[1])`
define	leftshift_for_tree_index (i) `/* multi line expression */`
define	malloc_getpagesize `(([size\_t](broker__monitor_8c.md#function-timeout))4096[U](broker__monitor_8c.md#function-timeout))`
define	mark_inuse_foot (M, p, s)
define	mark_smallmap (M, i) `((M)->smallmap \\|= [idx2bit](malloc__2__8__3_8c.md#define-idx2bit)([i](dynamic__load_8c.md#variable-i)))`
define	mark_treemap (M, i) `((M)->treemap \\|= [idx2bit](malloc__2__8__3_8c.md#define-idx2bit)([i](dynamic__load_8c.md#variable-i)))`
define	mem2chunk (mem) `(([mchunkptr](malloc__2__8__3_8c.md#typedef-mchunkptr))(([char](broker__monitor_8c.md#function-timeout)\)(mem) - [TWO\_SIZE\_T\_SIZES*](malloc__2__8__3_8c.md#define-two_size_t_sizes)))`
define	minsize_for_tree_index (i) `/* multi line expression */`
define	next_chunk (p) `(([mchunkptr](malloc__2__8__3_8c.md#typedef-mchunkptr))( (([char](broker__monitor_8c.md#function-timeout)\)([p](dynamic__load_8c.md#variable-p))) + (([p](dynamic__load_8c.md#variable-p))->head & ~[INUSE\_BITS*](malloc__2__8__3_8c.md#define-inuse_bits))))`
define	next_pinuse (p) `(([next\_chunk](malloc__2__8__3_8c.md#define-next_chunk)([p](dynamic__load_8c.md#variable-p))->head) & [PINUSE\_BIT](malloc__2__8__3_8c.md#define-pinuse_bit))`
define	ok_address (M, a) `(([char](broker__monitor_8c.md#function-timeout)\)([a*](broker__monitor_8c.md#function-timeout)) >= (M)->least\_addr)`
define	ok_cinuse (p) `[cinuse](malloc__2__8__3_8c.md#define-cinuse)([p](dynamic__load_8c.md#variable-p))`
define	ok_magic (M) `(1)`
define	ok_next (p, n) `(([char](broker__monitor_8c.md#function-timeout)\)([p](dynamic__load_8c.md#variable-p)) < ([char](broker__monitor_8c.md#function-timeout)\)(n))`
define	ok_pinuse (p) `[pinuse](malloc__2__8__3_8c.md#define-pinuse)([p](dynamic__load_8c.md#variable-p))`
define	overhead_for (p) `([is\_mmapped](malloc__2__8__3_8c.md#define-is_mmapped)([p](dynamic__load_8c.md#variable-p))? [MMAP\_CHUNK\_OVERHEAD](malloc__2__8__3_8c.md#define-mmap_chunk_overhead) : [CHUNK\_OVERHEAD](malloc__2__8__3_8c.md#define-chunk_overhead))`
define	pad_request (req) `((([req](broker__monitor_8c.md#function-timeout)) + [CHUNK\_OVERHEAD](malloc__2__8__3_8c.md#define-chunk_overhead) + [CHUNK\_ALIGN\_MASK](malloc__2__8__3_8c.md#define-chunk_align_mask)) & ~[CHUNK\_ALIGN\_MASK](malloc__2__8__3_8c.md#define-chunk_align_mask))`
define	page_align (S) `(((S) + ([mparams.page\_size](unloaddb_8c.md#variable-page_size))) & ~([mparams.page\_size](unloaddb_8c.md#variable-page_size) - [SIZE\_T\_ONE](malloc__2__8__3_8c.md#define-size_t_one)))`
define	pinuse (p) `(([p](dynamic__load_8c.md#variable-p))->head & [PINUSE\_BIT](malloc__2__8__3_8c.md#define-pinuse_bit))`
define	prev_chunk (p) `(([mchunkptr](malloc__2__8__3_8c.md#typedef-mchunkptr))( (([char](broker__monitor_8c.md#function-timeout)\)([p](dynamic__load_8c.md#variable-p))) - (([p*](dynamic__load_8c.md#variable-p))->prev\_foot) ))`
define	replace_dv (M, P, S) `/* multi line expression */`
define	request2size (req) `((([req](broker__monitor_8c.md#function-timeout)) < [MIN\_REQUEST](malloc__2__8__3_8c.md#define-min_request))? [MIN\_CHUNK\_SIZE](malloc__2__8__3_8c.md#define-min_chunk_size) : [pad\_request](malloc__2__8__3_8c.md#define-pad_request)([req](broker__monitor_8c.md#function-timeout)))`
define	same_or_left_bits (x) `(([x](broker__monitor_8c.md#function-timeout)) \\| -([x](broker__monitor_8c.md#function-timeout)))`
define	segment_holds (S, A) `(([char](broker__monitor_8c.md#function-timeout)\)([A](broker__monitor_8c.md#function-timeout)) >= S->base && ([char](broker__monitor_8c.md#function-timeout)\)([A](broker__monitor_8c.md#function-timeout)) < S->base + S->size)`
define	set_foot (p, s) `((([mchunkptr](malloc__2__8__3_8c.md#typedef-mchunkptr))(([char](broker__monitor_8c.md#function-timeout)\)([p*](dynamic__load_8c.md#variable-p)) + (s)))->prev\_foot = (s))`
define	set_free_with_pinuse (p, s, n) `([clear\_pinuse](malloc__2__8__3_8c.md#define-clear_pinuse)(n), [set\_size\_and\_pinuse\_of\_free\_chunk](malloc__2__8__3_8c.md#define-set_size_and_pinuse_of_free_chunk)([p](dynamic__load_8c.md#variable-p), s))`
define	set_inuse (M, p, s) `/* multi line expression */`
define	set_inuse_and_pinuse (M, p, s) `/* multi line expression */`
define	set_lock (M, L) `/* multi line expression */`
define	set_size_and_pinuse_of_free_chunk (p, s) `(([p](dynamic__load_8c.md#variable-p))->head = (s\\|[PINUSE\_BIT](malloc__2__8__3_8c.md#define-pinuse_bit)), [set\_foot](malloc__2__8__3_8c.md#define-set_foot)([p](dynamic__load_8c.md#variable-p), s))`
define	set_size_and_pinuse_of_inuse_chunk (M, p, s) `(([p](dynamic__load_8c.md#variable-p))->head = (s\\|[PINUSE\_BIT](malloc__2__8__3_8c.md#define-pinuse_bit)\\|[CINUSE\_BIT](malloc__2__8__3_8c.md#define-cinuse_bit)))`
define	should_trim (M, s) `((s) > (M)->trim\_check)`
define	small_index (s) `((s) >> [SMALLBIN\_SHIFT](malloc__2__8__3_8c.md#define-smallbin_shift))`
define	small_index2size (i) `(([i](dynamic__load_8c.md#variable-i)) << [SMALLBIN\_SHIFT](malloc__2__8__3_8c.md#define-smallbin_shift))`
define	smallbin_at (M, i) `(([sbinptr](malloc__2__8__3_8c.md#typedef-sbinptr))(([char](broker__monitor_8c.md#function-timeout)\)&((M)->smallbins[([i*](dynamic__load_8c.md#variable-i))<<1])))`
define	smallmap_is_marked (M, i) `((M)->smallmap & [idx2bit](malloc__2__8__3_8c.md#define-idx2bit)([i](dynamic__load_8c.md#variable-i)))`
define	treebin_at (M, i) `(&((M)->treebins[[i](dynamic__load_8c.md#variable-i)]))`
define	treemap_is_marked (M, i) `((M)->treemap & [idx2bit](malloc__2__8__3_8c.md#define-idx2bit)([i](dynamic__load_8c.md#variable-i)))`
define	unlink_chunk (M, P, S) `/* multi line expression */`
define	unlink_first_small_chunk (M, B, P, I) `/* multi line expression */`
define	unlink_large_chunk (M, X)
define	unlink_small_chunk (M, P, S) `/* multi line expression */`
define	use_lock (M) `((M)->mflags & [USE\_LOCK\_BIT](malloc__2__8__3_8c.md#define-use_lock_bit))`
define	use_mmap (M) `((M)->mflags & [USE\_MMAP\_BIT](malloc__2__8__3_8c.md#define-use_mmap_bit))`
define	use_noncontiguous (M) `((M)->mflags & [USE\_NONCONTIGUOUS\_BIT](malloc__2__8__3_8c.md#define-use_noncontiguous_bit))`

Public Types Documentation¶

typedef bindex_t¶

typedef unsigned int bindex_t;

typedef binmap_t¶

typedef unsigned int binmap_t;

typedef flag_t¶

typedef unsigned int flag_t;

typedef mchunk¶

typedef struct malloc_chunk mchunk;

typedef mchunkptr¶

typedef struct malloc_chunk* mchunkptr;

typedef msegment¶

typedef struct malloc_segment msegment;

typedef msegmentptr¶

typedef struct malloc_segment* msegmentptr;

typedef mstate¶

typedef struct malloc_state* mstate;

typedef sbinptr¶

typedef struct malloc_chunk* sbinptr;

typedef tbinptr¶

typedef struct malloc_tree_chunk* tbinptr;

typedef tchunk¶

typedef struct malloc_tree_chunk tchunk;

typedef tchunkptr¶

typedef struct malloc_tree_chunk* tchunkptr;

Public Static Attributes Documentation¶

variable _gm_¶

struct malloc_state _gm_;

variable dev_zero_fd¶

int dev_zero_fd;

variable mparams¶

struct malloc_params mparams;

Public Functions Documentation¶

function calloc¶

void * calloc (
    size_t n_elements,
    size_t elem_size
)

function free¶

void free (
    void * mem
)

function independent_calloc¶

void ** independent_calloc (
    size_t,
    size_t,
    void **
)

function independent_calloc¶

void ** independent_calloc (
    size_t n_elements,
    size_t elem_size,
    void * chunks
)

function independent_comalloc¶

void ** independent_comalloc (
    size_t,
    size_t *,
    void **
)

function independent_comalloc¶

void ** independent_comalloc (
    size_t n_elements,
    size_t sizes,
    void * chunks
)

function mallinfo¶

struct  mallinfo mallinfo (
    void
)

function malloc¶

void * malloc (
    size_t bytes
)

function malloc_footprint¶

size_t malloc_footprint (
    void
)

function malloc_max_footprint¶

size_t malloc_max_footprint (
    void
)

function malloc_stats¶

void malloc_stats (
    void
)

function malloc_trim¶

int malloc_trim (
    size_t pad
)

function malloc_usable_size¶

size_t malloc_usable_size (
    void * mem
)

function mallopt¶

int mallopt (
    int param_number,
    int value
)

function memalign¶

void * memalign (
    size_t alignment,
    size_t bytes
)

function pvalloc¶

void * pvalloc (
    size_t bytes
)

function realloc¶

void * realloc (
    void * oldmem,
    size_t bytes
)

function valloc¶

void * valloc (
    size_t bytes
)

Public Static Functions Documentation¶

function add_segment¶

static void add_segment (
    mstate m,
    char * tbase,
    size_t tsize,
    flag_t mmapped
)

function change_mparam¶

static int change_mparam (
    int param_number,
    int value
)

function has_segment_link¶

static int has_segment_link (
    mstate m,
    msegmentptr ss
)

function ialloc¶

static void ** ialloc (
    mstate m,
    size_t n_elements,
    size_t * sizes,
    int opts,
    void * chunks
)

function init_bins¶

static void init_bins (
    mstate m
)

function init_mparams¶

static int init_mparams (
    void
)

function init_top¶

static void init_top (
    mstate m,
    mchunkptr p,
    size_t psize
)

function internal_mallinfo¶

static struct  mallinfo internal_mallinfo (
    mstate m
)

function internal_malloc_stats¶

static void internal_malloc_stats (
    mstate m
)

function internal_memalign¶

static void * internal_memalign (
    mstate m,
    size_t alignment,
    size_t bytes
)

function internal_realloc¶

static void * internal_realloc (
    mstate m,
    void * oldmem,
    size_t bytes
)

function mmap_alloc¶

static void * mmap_alloc (
    mstate m,
    size_t nb
)

function mmap_resize¶

static mchunkptr mmap_resize (
    mstate m,
    mchunkptr oldp,
    size_t nb
)

function prepend_alloc¶

static void * prepend_alloc (
    mstate m,
    char * newbase,
    char * oldbase,
    size_t nb
)

function release_unused_segments¶

static size_t release_unused_segments (
    mstate m
)

function segment_holding¶

static msegmentptr segment_holding (
    mstate m,
    char * addr
)

function sys_alloc¶

static void * sys_alloc (
    mstate m,
    size_t nb
)

function sys_trim¶

static int sys_trim (
    mstate m,
    size_t pad
)

function tmalloc_large¶

static void * tmalloc_large (
    mstate m,
    size_t nb
)

function tmalloc_small¶

static void * tmalloc_small (
    mstate m,
    size_t nb
)

Macro Definition Documentation¶

define ABORT¶

#define ABORT `abort()`

define ABORT_ON_ASSERT_FAILURE¶

#define ABORT_ON_ASSERT_FAILURE `1`

define ACQUIRE_MAGIC_INIT_LOCK¶

#define ACQUIRE_MAGIC_INIT_LOCK (

)

define ACQUIRE_MORECORE_LOCK¶

#define ACQUIRE_MORECORE_LOCK (

)

define CALL_MMAP¶

#define CALL_MMAP (
    s
) `/* multi line expression */`

define CALL_MORECORE¶

#define CALL_MORECORE (
    S
) `MORECORE (S)`

define CALL_MREMAP¶

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

define CALL_MUNMAP¶

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

define CHUNK_ALIGN_MASK¶

#define CHUNK_ALIGN_MASK `( MALLOC_ALIGNMENT - SIZE_T_ONE )`

define CHUNK_OVERHEAD¶

#define CHUNK_OVERHEAD `( SIZE_T_SIZE )`

define CINUSE_BIT¶

#define CINUSE_BIT `( SIZE_T_TWO )`

define CMFAIL¶

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

define CORRUPTION_ERROR_ACTION¶

#define CORRUPTION_ERROR_ACTION (
    m
) `ABORT`

define DEFAULT_GRANULARITY¶

#define DEFAULT_GRANULARITY `(0)    /* 0 means to compute in init_mparams */`

define DEFAULT_MMAP_THRESHOLD¶

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

define DEFAULT_TRIM_THRESHOLD¶

#define DEFAULT_TRIM_THRESHOLD `(( size_t )2 U * ( size_t )1024 U * ( size_t )1024 U )`

define DIRECT_MMAP¶

#define DIRECT_MMAP (
    s
) `CALL_MMAP (s)`

define EXTERN_BIT¶

#define EXTERN_BIT `(8 U )`

define FENCEPOST_HEAD¶

#define FENCEPOST_HEAD `( INUSE_BITS | SIZE_T_SIZE )`

define FOOTERS¶

#define FOOTERS `0`

define FOUR_SIZE_T_SIZES¶

#define FOUR_SIZE_T_SIZES `( SIZE_T_SIZE <<2)`

define HALF_MAX_SIZE_T¶

#define HALF_MAX_SIZE_T `( MAX_SIZE_T / 2 U )`

define HAVE_MMAP¶

#define HAVE_MMAP `1`

define HAVE_MORECORE¶

#define HAVE_MORECORE `1`

define HAVE_MREMAP¶

#define HAVE_MREMAP `0`

define INITIAL_LOCK¶

#define INITIAL_LOCK (
    l
)

define INSECURE¶

#define INSECURE `0`

define INUSE_BITS¶

#define INUSE_BITS `( PINUSE_BIT | CINUSE_BIT )`

define IS_MMAPPED_BIT¶

#define IS_MMAPPED_BIT `( SIZE_T_ONE )`

define MALLINFO_FIELD_TYPE¶

#define MALLINFO_FIELD_TYPE `size_t`

define MALLOC_ALIGNMENT¶

#define MALLOC_ALIGNMENT `(( size_t )8 U )`

define MALLOC_FAILURE_ACTION¶

#define MALLOC_FAILURE_ACTION `errno = ENOMEM ;`

define MAX_REQUEST¶

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

define MAX_SIZE_T¶

#define MAX_SIZE_T `(~( size_t )0)`

define MAX_SMALL_REQUEST¶

#define MAX_SMALL_REQUEST `( MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD )`

define MAX_SMALL_SIZE¶

#define MAX_SMALL_SIZE `( MIN_LARGE_SIZE - SIZE_T_ONE )`

define MCHUNK_SIZE¶

#define MCHUNK_SIZE `( sizeof ( mchunk ))`

define MFAIL¶

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

define MIN_CHUNK_SIZE¶

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

define MIN_LARGE_SIZE¶

#define MIN_LARGE_SIZE `( SIZE_T_ONE << TREEBIN_SHIFT )`

define MIN_REQUEST¶

#define MIN_REQUEST `( MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE )`

define MIN_SMALL_INDEX¶

#define MIN_SMALL_INDEX `( small_index ( MIN_CHUNK_SIZE ))`

define MMAP_CHUNK_OVERHEAD¶

#define MMAP_CHUNK_OVERHEAD `( TWO_SIZE_T_SIZES )`

define MMAP_CLEARS¶

#define MMAP_CLEARS `1`

define MMAP_FLAGS¶

#define MMAP_FLAGS `( MAP_PRIVATE )`

define MMAP_FOOT_PAD¶

#define MMAP_FOOT_PAD `( FOUR_SIZE_T_SIZES )`

define MMAP_PROT¶

#define MMAP_PROT `( PROT_READ | PROT_WRITE )`

define MORECORE¶

#define MORECORE `sbrk`

define MORECORE_CONTIGUOUS¶

#define MORECORE_CONTIGUOUS `1`

define MSPACES¶

#define MSPACES `0`

define M_GRANULARITY¶

#define M_GRANULARITY `(-2)`

define M_MMAP_THRESHOLD¶

#define M_MMAP_THRESHOLD `(-3)`

define M_TRIM_THRESHOLD¶

#define M_TRIM_THRESHOLD `(-1)`

define NO_MALLINFO¶

#define NO_MALLINFO `0`

define NSMALLBINS¶

#define NSMALLBINS `(32 U )`

define NTREEBINS¶

#define NTREEBINS `(32 U )`

define ONLY_MSPACES¶

#define ONLY_MSPACES `0`

define PINUSE_BIT¶

#define PINUSE_BIT `( SIZE_T_ONE )`

define POSTACTION¶

#define POSTACTION (
    M
)

define PREACTION¶

#define PREACTION (
    M
) `(0)`

define PROCEED_ON_ERROR¶

#define PROCEED_ON_ERROR `0`

define RELEASE_MAGIC_INIT_LOCK¶

#define RELEASE_MAGIC_INIT_LOCK (

)

define RELEASE_MORECORE_LOCK¶

#define RELEASE_MORECORE_LOCK (

)

define RTCHECK¶

#define RTCHECK (
    e
) `__builtin_expect ( e , 1)`

define SIX_SIZE_T_SIZES¶

#define SIX_SIZE_T_SIZES `( FOUR_SIZE_T_SIZES + TWO_SIZE_T_SIZES )`

define SIZE_T_BITSIZE¶

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

define SIZE_T_ONE¶

#define SIZE_T_ONE `(( size_t )1)`

define SIZE_T_SIZE¶

#define SIZE_T_SIZE `( sizeof ( size_t ))`

define SIZE_T_TWO¶

#define SIZE_T_TWO `(( size_t )2)`

define SIZE_T_ZERO¶

#define SIZE_T_ZERO `(( size_t )0)`

define SMALLBIN_SHIFT¶

#define SMALLBIN_SHIFT `(3 U )`

define SMALLBIN_WIDTH¶

#define SMALLBIN_WIDTH `( SIZE_T_ONE << SMALLBIN_SHIFT )`

define TOP_FOOT_SIZE¶

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

define TREEBIN_SHIFT¶

#define TREEBIN_SHIFT `(8 U )`

define TWO_SIZE_T_SIZES¶

#define TWO_SIZE_T_SIZES `( SIZE_T_SIZE <<1)`

define USAGE_ERROR_ACTION¶

#define USAGE_ERROR_ACTION (
    m,
    p
) `ABORT`

define USE_BUILTIN_FFS¶

#define USE_BUILTIN_FFS `0`

define USE_DEV_RANDOM¶

#define USE_DEV_RANDOM `0`

define USE_LOCKS¶

#define USE_LOCKS `0`

define USE_LOCK_BIT¶

#define USE_LOCK_BIT `(0U)`

define USE_MALLOC_INSTEAD¶

#define USE_MALLOC_INSTEAD `0`

define USE_MMAP_BIT¶

#define USE_MMAP_BIT `( SIZE_T_ONE )`

define USE_NONCONTIGUOUS_BIT¶

#define USE_NONCONTIGUOUS_BIT `(4 U )`

define align_as_chunk¶

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

define align_offset¶

#define align_offset (
    A
) `/* multi line expression */`

define assert¶

#define assert (
    x
)

define bit_for_tree_index¶

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

define calloc_must_clear¶

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

define check_free_chunk¶

#define check_free_chunk (
    M,
    P
)

define check_inuse_chunk¶

#define check_inuse_chunk (
    M,
    P
)

define check_malloc_state¶

#define check_malloc_state (
    M
)

define check_malloced_chunk¶

#define check_malloced_chunk (
    M,
    P,
    N
)

define check_mmapped_chunk¶

#define check_mmapped_chunk (
    M,
    P
)

define check_top_chunk¶

#define check_top_chunk (
    M,
    P
)

define chunk2mem¶

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

define chunk_minus_offset¶

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

define chunk_plus_offset¶

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

define chunksize¶

#define chunksize (
    p
) `(( p )->head & ~( INUSE_BITS ))`

define cinuse¶

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

define clear_cinuse¶

#define clear_cinuse (
    p
) `(( p )->head &= ~ CINUSE_BIT )`

define clear_pinuse¶

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

define clear_smallmap¶

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

define clear_treemap¶

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

define compute_bit2idx¶

#define compute_bit2idx (
    X,
    I
) `/* multi line expression */`

define compute_tree_index¶

#define compute_tree_index (
    S,
    I
) `/* multi line expression */`

define disable_contiguous¶

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

define disable_lock¶

#define disable_lock (
    M
) `((M)->mflags &= ~ USE_LOCK_BIT )`

define disable_mmap¶

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

define dlcalloc¶

#define dlcalloc `calloc`

define dlfree¶

#define dlfree `free`

define dlindependent_calloc¶

#define dlindependent_calloc `independent_calloc`

define dlindependent_comalloc¶

#define dlindependent_comalloc `independent_comalloc`

define dlmallinfo¶

#define dlmallinfo `mallinfo`

define dlmalloc¶

#define dlmalloc `malloc`

define dlmalloc_footprint¶

#define dlmalloc_footprint `malloc_footprint`

define dlmalloc_max_footprint¶

#define dlmalloc_max_footprint `malloc_max_footprint`

define dlmalloc_stats¶

#define dlmalloc_stats `malloc_stats`

define dlmalloc_trim¶

#define dlmalloc_trim `malloc_trim`

define dlmalloc_usable_size¶

#define dlmalloc_usable_size `malloc_usable_size`

define dlmallopt¶

#define dlmallopt `mallopt`

define dlmemalign¶

#define dlmemalign `memalign`

define dlpvalloc¶

#define dlpvalloc `pvalloc`

define dlrealloc¶

#define dlrealloc `realloc`

define dlvalloc¶

#define dlvalloc `valloc`

define enable_lock¶

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

define enable_mmap¶

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

define fm¶

#define fm `gm`

define get_foot¶

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

define gm¶

#define gm `(& _gm_ )`

define granularity_align¶

#define granularity_align (
    S
) `(((S) + (mparams.granularity)) & ~(mparams.granularity - SIZE_T_ONE ))`

define idx2bit¶

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

define insert_chunk¶

#define insert_chunk (
    M,
    P,
    S
) `if ( is_small (S)) insert_small_chunk (M, P, S)\ else { tchunkptr  TP = ( tchunkptr )(P); insert_large_chunk (M, TP , S); }`

define insert_large_chunk¶

#define insert_large_chunk (
    M,
    X,
    S
)

define insert_small_chunk¶

#define insert_small_chunk (
    M,
    P,
    S
) `/* multi line expression */`

define internal_free¶

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

define internal_malloc¶

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

define is_aligned¶

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

define is_extern_segment¶

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

define is_global¶

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

define is_granularity_aligned¶

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

define is_initialized¶

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

define is_mmapped¶

#define is_mmapped (
    p
) `(!(( p )->head & PINUSE_BIT ) && (( p )->prev_foot & IS_MMAPPED_BIT ))`

define is_mmapped_segment¶

#define is_mmapped_segment (
    S
) `((S)->sflags & IS_MMAPPED_BIT )`

define is_page_aligned¶

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

define is_small¶

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

define least_bit¶

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

define left_bits¶

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

define leftmost_child¶

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

define leftshift_for_tree_index¶

#define leftshift_for_tree_index (
    i
) `/* multi line expression */`

define malloc_getpagesize¶

#define malloc_getpagesize `(( size_t )4096 U )`

define mark_inuse_foot¶

#define mark_inuse_foot (
    M,
    p,
    s
)

define mark_smallmap¶

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

define mark_treemap¶

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

define mem2chunk¶

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

define minsize_for_tree_index¶

#define minsize_for_tree_index (
    i
) `/* multi line expression */`

define next_chunk¶

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

define next_pinuse¶

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

define ok_address¶

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

define ok_cinuse¶

#define ok_cinuse (
    p
) `cinuse ( p )`

define ok_magic¶

#define ok_magic (
    M
) `(1)`

define ok_next¶

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

define ok_pinuse¶

#define ok_pinuse (
    p
) `pinuse ( p )`

define overhead_for¶

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

define pad_request¶

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

define page_align¶

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

define pinuse¶

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

define prev_chunk¶

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

define replace_dv¶

#define replace_dv (
    M,
    P,
    S
) `/* multi line expression */`

define request2size¶

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

define same_or_left_bits¶

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

define segment_holds¶

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

define set_foot¶

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

define set_free_with_pinuse¶

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

define set_inuse¶

#define set_inuse (
    M,
    p,
    s
) `/* multi line expression */`

define set_inuse_and_pinuse¶

#define set_inuse_and_pinuse (
    M,
    p,
    s
) `/* multi line expression */`

define set_lock¶

#define set_lock (
    M,
    L
) `/* multi line expression */`

define 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))`

define 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 ))`

define should_trim¶

#define should_trim (
    M,
    s
) `((s) > (M)->trim_check)`

define small_index¶

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

define small_index2size¶

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

define smallbin_at¶

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

define smallmap_is_marked¶

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

define treebin_at¶

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

define treemap_is_marked¶

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

define unlink_chunk¶

#define unlink_chunk (
    M,
    P,
    S
) `if ( is_small (S)) unlink_small_chunk (M, P, S)\ else { tchunkptr  TP = ( tchunkptr )(P); unlink_large_chunk (M, TP ); }`

define unlink_first_small_chunk¶

#define unlink_first_small_chunk (
    M,
    B,
    P,
    I
) `/* multi line expression */`

define unlink_large_chunk¶

#define unlink_large_chunk (
    M,
    X
)

define unlink_small_chunk¶

#define unlink_small_chunk (
    M,
    P,
    S
) `/* multi line expression */`

define use_lock¶

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

define use_mmap¶

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

define use_noncontiguous¶

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

The documentation for this class was generated from the following file cubrid/src/heaplayers/malloc_2_8_3.c