SDL  2.0
Data Structures | Macros | Typedefs | Functions | Variables
SDL_malloc.c File Reference
#include "../SDL_internal.h"
#include "SDL_stdinc.h"
#include "SDL_atomic.h"
#include "SDL_error.h"
#include <windows.h>
+ Include dependency graph for SDL_malloc.c:

Go to the source code of this file.

Data Structures

struct  mallinfo
struct  sbinptr
struct  tbinptr
struct  msegmentptr
struct  mstate
struct  malloc_params

Macros

#define LACKS_SYS_TYPES_H
#define LACKS_STDIO_H
#define LACKS_STRINGS_H
#define LACKS_STRING_H
#define LACKS_STDLIB_H
#define ABORT
#define USE_LOCKS   1
#define USE_DL_PREFIX
#define WIN32   1
#define WIN32_LEAN_AND_MEAN
#define HAVE_MMAP   1
#define HAVE_MORECORE   0
#define LACKS_UNISTD_H
#define LACKS_SYS_PARAM_H
#define LACKS_SYS_MMAN_H
#define LACKS_STRING_H
#define LACKS_STRINGS_H
#define LACKS_SYS_TYPES_H
#define LACKS_ERRNO_H
#define LACKS_FCNTL_H
#define MALLOC_FAILURE_ACTION
#define MMAP_CLEARS   0 /* WINCE and some others apparently don't clear */
#define MAX_SIZE_T   (~(size_t)0)
#define ONLY_MSPACES   0
#define MSPACES   0
#define MALLOC_ALIGNMENT   ((size_t)8U)
#define FOOTERS   0
#define ABORT_ON_ASSERT_FAILURE   1
#define PROCEED_ON_ERROR   0
#define INSECURE   0
#define HAVE_MREMAP   0
#define MORECORE_CONTIGUOUS   0
#define DEFAULT_GRANULARITY   ((size_t)64U * (size_t)1024U)
#define DEFAULT_TRIM_THRESHOLD   ((size_t)2U * (size_t)1024U * (size_t)1024U)
#define DEFAULT_MMAP_THRESHOLD   ((size_t)256U * (size_t)1024U)
#define USE_BUILTIN_FFS   0
#define USE_DEV_RANDOM   0
#define NO_MALLINFO   0
#define MALLINFO_FIELD_TYPE   size_t
#define memset   SDL_memset
#define memcpy   SDL_memcpy
#define M_TRIM_THRESHOLD   (-1)
#define M_GRANULARITY   (-2)
#define M_MMAP_THRESHOLD   (-3)
#define assert(x)
#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 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 IS_MMAPPED_BIT   (SIZE_T_ONE)
#define USE_MMAP_BIT   (SIZE_T_ONE)
#define CALL_MMAP(s)   win32mmap(s)
#define CALL_MUNMAP(a, s)   win32munmap((a), (s))
#define DIRECT_MMAP(s)   win32direct_mmap(s)
#define CALL_MREMAP(addr, osz, nsz, mv)   MFAIL
#define CALL_MORECORE(S)   MFAIL
#define USE_NONCONTIGUOUS_BIT   (4U)
#define EXTERN_BIT   (8U)
#define MLOCK_T   long
#define INITIAL_LOCK(l)   *(l)=0
#define ACQUIRE_LOCK(l)   win32_acquire_lock(l)
#define RELEASE_LOCK(l)   win32_release_lock(l)
#define USE_LOCK_BIT   (2U)
#define ACQUIRE_MORECORE_LOCK()
#define RELEASE_MORECORE_LOCK()
#define ACQUIRE_MAGIC_INIT_LOCK()   ACQUIRE_LOCK(&magic_init_mutex);
#define RELEASE_MAGIC_INIT_LOCK()   RELEASE_LOCK(&magic_init_mutex);
#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 INUSE_BITS   (PINUSE_BIT|CINUSE_BIT)
#define FENCEPOST_HEAD   (INUSE_BITS|SIZE_T_SIZE)
#define cinuse(p)   ((p)->head & CINUSE_BIT)
#define pinuse(p)   ((p)->head & PINUSE_BIT)
#define chunksize(p)   ((p)->head & ~(INUSE_BITS))
#define clear_pinuse(p)   ((p)->head &= ~PINUSE_BIT)
#define clear_cinuse(p)   ((p)->head &= ~CINUSE_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 & ~INUSE_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 is_mmapped(p)   (!((p)->head & PINUSE_BIT) && ((p)->prev_foot & IS_MMAPPED_BIT))
#define overhead_for(p)   (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD)
#define calloc_must_clear(p)   (1)
#define leftmost_child(t)   ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])
#define is_mmapped_segment(S)   ((S)->sflags & IS_MMAPPED_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 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)   ((M)->mflags &= ~USE_LOCK_BIT)
#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)) & ~(mparams.page_size - SIZE_T_ONE))
#define granularity_align(S)   (((S) + (mparams.granularity)) & ~(mparams.granularity - SIZE_T_ONE))
#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)   ((s) > (M)->trim_check)
#define TOP_FOOT_SIZE   (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE)
#define GLOBALLY_INITIALIZE()   (mparams.page_size == 0 && init_mparams())
#define PREACTION(M)   ((GLOBALLY_INITIALIZE() || use_lock(M))? ACQUIRE_LOCK(&(M)->mutex) : 0)
#define POSTACTION(M)   { if (use_lock(M)) RELEASE_LOCK(&(M)->mutex); }
#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)   ((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 compute_bit2idx(X, I)
#define least_bit(x)   ((x) & -(x))
#define left_bits(x)   ((x<<1) | -(x<<1))
#define same_or_left_bits(x)   ((x) | -(x))
#define ok_address(M, a)   ((char*)(a) >= (M)->least_addr)
#define ok_next(p, n)   ((char*)(p) < (char*)(n))
#define ok_cinuse(p)   cinuse(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
#define real_malloc   dlmalloc
#define real_calloc   dlcalloc
#define real_realloc   dlrealloc
#define real_free   dlfree

Typedefs

typedef size_t bindex_t
typedef unsigned int binmap_t
typedef unsigned int flag_t

Functions

void * dlmalloc (size_t)
void dlfree (void *)
void * dlcalloc (size_t, size_t)
void * dlrealloc (void *, size_t)
void * dlmemalign (size_t, size_t)
void * dlvalloc (size_t)
int dlmallopt (int, int)
size_t dlmalloc_footprint (void)
size_t dlmalloc_max_footprint (void)
struct mallinfo dlmallinfo (void)
void ** dlindependent_calloc (size_t, size_t, void **)
void ** dlindependent_comalloc (size_t, size_t *, void **)
void * dlpvalloc (size_t)
int dlmalloc_trim (size_t)
size_t dlmalloc_usable_size (void *)
void dlmalloc_stats (void)
static void * win32mmap (size_t size)
static void * win32direct_mmap (size_t size)
static int win32munmap (void *ptr, size_t size)
static int win32_acquire_lock (MLOCK_T *sl)
static void win32_release_lock (MLOCK_T *sl)
static msegmentptr segment_holding (mstate m, char *addr)
static int has_segment_link (mstate m, msegmentptr ss)
static int init_mparams (void)
static int change_mparam (int param_number, int value)
static struct mallinfo internal_mallinfo (mstate m)
static void internal_malloc_stats (mstate m)
static void * mmap_alloc (mstate m, size_t nb)
static mchunkptr mmap_resize (mstate m, mchunkptr oldp, size_t nb)
static void init_top (mstate m, mchunkptr p, size_t psize)
static void init_bins (mstate m)
static void * prepend_alloc (mstate m, char *newbase, char *oldbase, size_t nb)
static void add_segment (mstate m, char *tbase, size_t tsize, flag_t mmapped)
static void * sys_alloc (mstate m, size_t nb)
static size_t release_unused_segments (mstate m)
static int sys_trim (mstate m, size_t pad)
static void * tmalloc_large (mstate m, size_t nb)
static void * tmalloc_small (mstate m, size_t nb)
static void * internal_realloc (mstate m, void *oldmem, size_t bytes)
static void * internal_memalign (mstate m, size_t alignment, size_t bytes)
static void ** ialloc (mstate m, size_t n_elements, size_t *sizes, int opts, void *chunks[])
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[])
void SDL_GetMemoryFunctions (SDL_malloc_func *malloc_func, SDL_calloc_func *calloc_func, SDL_realloc_func *realloc_func, SDL_free_func *free_func)
 Get the current set of SDL memory functions.
int SDL_SetMemoryFunctions (SDL_malloc_func malloc_func, SDL_calloc_func calloc_func, SDL_realloc_func realloc_func, SDL_free_func free_func)
 Replace SDL's memory allocation functions with a custom set.
int SDL_GetNumAllocations (void)
 Get the number of outstanding (unfreed) allocations.
void * SDL_malloc (size_t size)
void * SDL_calloc (size_t nmemb, size_t size)
void * SDL_realloc (void *ptr, size_t size)
void SDL_free (void *ptr)

Variables

static MLOCK_T magic_init_mutex
static struct malloc_params mparams
static struct malloc_state _gm_
struct {
   SDL_malloc_func   malloc_func
   SDL_calloc_func   calloc_func
   SDL_realloc_func   realloc_func
   SDL_free_func   free_func
   SDL_atomic_t   num_allocations
} s_mem

Macro Definition Documentation

#define ABORT

Definition at line 39 of file SDL_malloc.c.

Referenced by init_mparams().

#define ABORT_ON_ASSERT_FAILURE   1

Definition at line 540 of file SDL_malloc.c.

#define ACQUIRE_LOCK (   l)    win32_acquire_lock(l)

Definition at line 1494 of file SDL_malloc.c.

#define ACQUIRE_MAGIC_INIT_LOCK ( )    ACQUIRE_LOCK(&magic_init_mutex);

Definition at line 1517 of file SDL_malloc.c.

Referenced by init_mparams().

#define ACQUIRE_MORECORE_LOCK ( )

Definition at line 1512 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

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

Definition at line 1700 of file SDL_malloc.c.

Referenced by internal_mallinfo(), internal_malloc_stats(), prepend_alloc(), and release_unused_segments().

#define align_offset (   A)
Value:
((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\
((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK))

Definition at line 1317 of file SDL_malloc.c.

Referenced by add_segment(), init_top(), and mmap_alloc().

#define assert (   x)

Definition at line 1219 of file SDL_malloc.c.

Referenced by add_segment(), dlmalloc(), ialloc(), internal_memalign(), mmap_alloc(), prepend_alloc(), release_unused_segments(), tmalloc_large(), and tmalloc_small().

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

Definition at line 2310 of file SDL_malloc.c.

#define CALL_MMAP (   s)    win32mmap(s)

Definition at line 1408 of file SDL_malloc.c.

Referenced by sys_alloc().

#define CALL_MORECORE (   S)    MFAIL

Definition at line 1423 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

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

Definition at line 1417 of file SDL_malloc.c.

Referenced by mmap_resize(), and sys_trim().

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

Definition at line 1409 of file SDL_malloc.c.

Referenced by dlfree(), release_unused_segments(), and sys_trim().

#define calloc_must_clear (   p)    (1)

Definition at line 1774 of file SDL_malloc.c.

Referenced by dlcalloc().

#define check_free_chunk (   M,
  P 
)

Definition at line 2234 of file SDL_malloc.c.

Referenced by dlfree(), and prepend_alloc().

#define check_inuse_chunk (   M,
  P 
)

Definition at line 2235 of file SDL_malloc.c.

Referenced by dlfree(), ialloc(), internal_memalign(), and internal_realloc().

#define check_malloc_state (   M)

Definition at line 2238 of file SDL_malloc.c.

Referenced by internal_mallinfo(), and internal_malloc_stats().

#define check_malloced_chunk (   M,
  P,
  N 
)

Definition at line 2236 of file SDL_malloc.c.

Referenced by dlmalloc(), prepend_alloc(), and sys_alloc().

#define check_mmapped_chunk (   M,
  P 
)

Definition at line 2237 of file SDL_malloc.c.

Referenced by mmap_alloc(), and mmap_resize().

#define check_top_chunk (   M,
  P 
)

Definition at line 2239 of file SDL_malloc.c.

Referenced by add_segment(), dlmalloc(), prepend_alloc(), sys_alloc(), and sys_trim().

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

Definition at line 1697 of file SDL_malloc.c.

Referenced by add_segment(), dlmalloc(), ialloc(), init_top(), internal_memalign(), internal_realloc(), mmap_alloc(), prepend_alloc(), sys_alloc(), tmalloc_large(), and tmalloc_small().

#define CHUNK_ALIGN_MASK   (MALLOC_ALIGNMENT - SIZE_T_ONE)

Definition at line 1311 of file SDL_malloc.c.

Referenced by add_segment(), mmap_alloc(), and mmap_resize().

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

Definition at line 1742 of file SDL_malloc.c.

Referenced by dlfree().

#define CHUNK_OVERHEAD   (SIZE_T_SIZE)

Definition at line 1684 of file SDL_malloc.c.

Referenced by ialloc(), and internal_memalign().

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

Definition at line 1741 of file SDL_malloc.c.

Referenced by add_segment(), dlfree(), dlmalloc(), ialloc(), init_top(), internal_memalign(), internal_realloc(), mmap_alloc(), mmap_resize(), prepend_alloc(), sys_alloc(), tmalloc_large(), and tmalloc_small().

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

Definition at line 1735 of file SDL_malloc.c.

Referenced by dlfree(), dlmalloc(), dlmalloc_usable_size(), ialloc(), internal_mallinfo(), internal_malloc_stats(), internal_memalign(), internal_realloc(), mmap_resize(), prepend_alloc(), release_unused_segments(), tmalloc_large(), and tmalloc_small().

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

Definition at line 1733 of file SDL_malloc.c.

Referenced by dlfree(), dlmalloc_usable_size(), internal_mallinfo(), internal_malloc_stats(), prepend_alloc(), and release_unused_segments().

#define CINUSE_BIT   (SIZE_T_TWO)

Definition at line 1726 of file SDL_malloc.c.

Referenced by internal_memalign(), mmap_alloc(), and mmap_resize().

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

Definition at line 1738 of file SDL_malloc.c.

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

Definition at line 1737 of file SDL_malloc.c.

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

Definition at line 2331 of file SDL_malloc.c.

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

Definition at line 2335 of file SDL_malloc.c.

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

Definition at line 1332 of file SDL_malloc.c.

Referenced by mmap_alloc(), mmap_resize(), sys_alloc(), and sys_trim().

#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);\
}

Definition at line 2353 of file SDL_malloc.c.

Referenced by dlmalloc(), tmalloc_large(), and tmalloc_small().

#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));\
}\
}

Definition at line 2290 of file SDL_malloc.c.

Referenced by tmalloc_large().

#define CORRUPTION_ERROR_ACTION (   m)    ABORT

Definition at line 2221 of file SDL_malloc.c.

Referenced by tmalloc_large(), and tmalloc_small().

#define DEFAULT_GRANULARITY   ((size_t)64U * (size_t)1024U)

Definition at line 588 of file SDL_malloc.c.

Referenced by init_mparams().

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

Definition at line 600 of file SDL_malloc.c.

Referenced by init_mparams().

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

Definition at line 593 of file SDL_malloc.c.

Referenced by init_mparams().

#define DIRECT_MMAP (   s)    win32direct_mmap(s)

Definition at line 1410 of file SDL_malloc.c.

Referenced by mmap_alloc().

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

Definition at line 2107 of file SDL_malloc.c.

Referenced by sys_alloc().

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

Definition at line 2100 of file SDL_malloc.c.

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

Definition at line 2104 of file SDL_malloc.c.

Referenced by ialloc().

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

Definition at line 2099 of file SDL_malloc.c.

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

Definition at line 2103 of file SDL_malloc.c.

Referenced by ialloc().

#define EXTERN_BIT   (8U)

Definition at line 1430 of file SDL_malloc.c.

#define FENCEPOST_HEAD   (INUSE_BITS|SIZE_T_SIZE)

Definition at line 1730 of file SDL_malloc.c.

Referenced by add_segment(), internal_mallinfo(), internal_malloc_stats(), mmap_alloc(), and mmap_resize().

#define fm   gm

Referenced by dlfree().

#define FOOTERS   0

Definition at line 534 of file SDL_malloc.c.

#define FOUR_SIZE_T_SIZES   (SIZE_T_SIZE<<2)

Definition at line 1306 of file SDL_malloc.c.

Referenced by add_segment().

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

Definition at line 1752 of file SDL_malloc.c.

#define GLOBALLY_INITIALIZE ( )    (mparams.page_size == 0 && init_mparams())

Definition at line 2183 of file SDL_malloc.c.

#define gm   (&_gm_)

Definition at line 2090 of file SDL_malloc.c.

Referenced by dlindependent_calloc(), dlindependent_comalloc(), dlmallinfo(), dlmalloc(), dlmalloc_footprint(), dlmalloc_max_footprint(), dlmalloc_stats(), dlmalloc_trim(), dlmemalign(), dlrealloc(), and init_mparams().

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

Definition at line 2119 of file SDL_malloc.c.

Referenced by mmap_alloc(), mmap_resize(), and sys_alloc().

#define HALF_MAX_SIZE_T   (MAX_SIZE_T / 2U)

Definition at line 1308 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

#define HAVE_MMAP   1

Definition at line 491 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

#define HAVE_MORECORE   0

Definition at line 492 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

#define HAVE_MREMAP   0

Definition at line 561 of file SDL_malloc.c.

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

Definition at line 2327 of file SDL_malloc.c.

Referenced by dlmalloc(), and tmalloc_large().

#define INITIAL_LOCK (   l)    *(l)=0

Definition at line 1493 of file SDL_malloc.c.

Referenced by init_mparams().

#define INSECURE   0

Definition at line 549 of file SDL_malloc.c.

#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); }

Definition at line 3186 of file SDL_malloc.c.

Referenced by add_segment(), dlfree(), prepend_alloc(), and tmalloc_large().

#define insert_large_chunk (   M,
  X,
  S 
)

Definition at line 3045 of file SDL_malloc.c.

Referenced by release_unused_segments().

#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;\
}

Definition at line 2974 of file SDL_malloc.c.

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

Definition at line 3208 of file SDL_malloc.c.

Referenced by internal_memalign(), and internal_realloc().

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

Definition at line 3207 of file SDL_malloc.c.

Referenced by ialloc(), internal_memalign(), and internal_realloc().

#define INUSE_BITS   (PINUSE_BIT|CINUSE_BIT)

Definition at line 1727 of file SDL_malloc.c.

Referenced by dlfree().

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

Definition at line 1314 of file SDL_malloc.c.

Referenced by add_segment(), and mmap_alloc().

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

Definition at line 1954 of file SDL_malloc.c.

Referenced by release_unused_segments(), sys_alloc(), and sys_trim().

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

Definition at line 2091 of file SDL_malloc.c.

Referenced by sys_alloc().

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

Definition at line 2124 of file SDL_malloc.c.

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

Definition at line 2092 of file SDL_malloc.c.

Referenced by internal_mallinfo(), internal_malloc_stats(), sys_alloc(), and sys_trim().

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

Definition at line 1763 of file SDL_malloc.c.

Referenced by ialloc(), internal_memalign(), and internal_realloc().

#define IS_MMAPPED_BIT   (SIZE_T_ONE)

Definition at line 1342 of file SDL_malloc.c.

Referenced by dlfree(), mmap_alloc(), mmap_resize(), and sys_alloc().

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

Definition at line 1953 of file SDL_malloc.c.

Referenced by release_unused_segments(), and sys_trim().

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

Definition at line 2122 of file SDL_malloc.c.

Referenced by sys_alloc().

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

Definition at line 2265 of file SDL_malloc.c.

Referenced by mmap_resize().

#define LACKS_ERRNO_H

Definition at line 499 of file SDL_malloc.c.

#define LACKS_FCNTL_H

Definition at line 500 of file SDL_malloc.c.

#define LACKS_STDIO_H

Definition at line 35 of file SDL_malloc.c.

#define LACKS_STDLIB_H

Definition at line 38 of file SDL_malloc.c.

#define LACKS_STRING_H

Definition at line 496 of file SDL_malloc.c.

#define LACKS_STRING_H

Definition at line 496 of file SDL_malloc.c.

#define LACKS_STRINGS_H

Definition at line 497 of file SDL_malloc.c.

#define LACKS_STRINGS_H

Definition at line 497 of file SDL_malloc.c.

#define LACKS_SYS_MMAN_H

Definition at line 495 of file SDL_malloc.c.

#define LACKS_SYS_PARAM_H

Definition at line 494 of file SDL_malloc.c.

#define LACKS_SYS_TYPES_H

Definition at line 498 of file SDL_malloc.c.

#define LACKS_SYS_TYPES_H

Definition at line 498 of file SDL_malloc.c.

#define LACKS_UNISTD_H

Definition at line 493 of file SDL_malloc.c.

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

Definition at line 2368 of file SDL_malloc.c.

Referenced by dlmalloc(), tmalloc_large(), and tmalloc_small().

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

Definition at line 2371 of file SDL_malloc.c.

Referenced by dlmalloc(), and tmalloc_large().

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

Definition at line 1886 of file SDL_malloc.c.

Referenced by tmalloc_large(), and tmalloc_small().

#define leftshift_for_tree_index (   i)
Value:
((i == NTREEBINS-1)? 0 : \
((SIZE_T_BITSIZE-SIZE_T_ONE) - (((i) >> 1) + TREEBIN_SHIFT - 2)))

Definition at line 2314 of file SDL_malloc.c.

Referenced by tmalloc_large().

#define M_GRANULARITY   (-2)

Definition at line 633 of file SDL_malloc.c.

Referenced by change_mparam().

#define M_MMAP_THRESHOLD   (-3)

Definition at line 634 of file SDL_malloc.c.

Referenced by change_mparam().

#define M_TRIM_THRESHOLD   (-1)

Definition at line 632 of file SDL_malloc.c.

Referenced by change_mparam().

#define MALLINFO_FIELD_TYPE   size_t

Definition at line 615 of file SDL_malloc.c.

#define MALLOC_ALIGNMENT   ((size_t)8U)

Definition at line 531 of file SDL_malloc.c.

Referenced by init_mparams(), internal_memalign(), and sys_alloc().

#define MALLOC_FAILURE_ACTION

Definition at line 501 of file SDL_malloc.c.

Referenced by internal_memalign(), internal_realloc(), and sys_alloc().

#define mark_inuse_foot (   M,
  p,
  s 
)

Definition at line 2445 of file SDL_malloc.c.

Referenced by mmap_alloc(), and mmap_resize().

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

Definition at line 2330 of file SDL_malloc.c.

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

Definition at line 2334 of file SDL_malloc.c.

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

Definition at line 1703 of file SDL_malloc.c.

Referenced by dlmalloc(), internal_memalign(), internal_realloc(), and sys_trim().

#define MAX_SIZE_T   (~(size_t)0)

Definition at line 518 of file SDL_malloc.c.

Referenced by dlcalloc(), dlmalloc(), init_mparams(), and sys_trim().

#define MAX_SMALL_REQUEST   (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)

Definition at line 2042 of file SDL_malloc.c.

Referenced by dlmalloc().

#define MAX_SMALL_SIZE   (MIN_LARGE_SIZE - SIZE_T_ONE)

Definition at line 2041 of file SDL_malloc.c.

#define MCHUNK_SIZE   (sizeof(mchunk))

Definition at line 1679 of file SDL_malloc.c.

Referenced by init_mparams().

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

Definition at line 1698 of file SDL_malloc.c.

Referenced by dlcalloc(), dlfree(), dlmalloc_usable_size(), dlrealloc(), ialloc(), internal_memalign(), internal_realloc(), and sys_alloc().

#define memcpy   SDL_memcpy

Definition at line 622 of file SDL_malloc.c.

Referenced by SDL_BWin::DirectConnected(), internal_realloc(), and SDL_memcpy().

#define memset   SDL_memset

Definition at line 619 of file SDL_malloc.c.

Referenced by dlcalloc(), ialloc(), main(), and SDL_memset().

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

Definition at line 1331 of file SDL_malloc.c.

Referenced by sys_trim(), win32direct_mmap(), and win32mmap().

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

Definition at line 1693 of file SDL_malloc.c.

Referenced by add_segment(), dlmalloc(), init_mparams(), internal_memalign(), internal_realloc(), prepend_alloc(), tmalloc_large(), and tmalloc_small().

#define MIN_LARGE_SIZE   (SIZE_T_ONE << TREEBIN_SHIFT)

Definition at line 2040 of file SDL_malloc.c.

#define MIN_REQUEST   (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)

Definition at line 1704 of file SDL_malloc.c.

Referenced by dlmalloc().

#define MIN_SMALL_INDEX   (small_index(MIN_CHUNK_SIZE))

Definition at line 2268 of file SDL_malloc.c.

#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)))

Definition at line 2319 of file SDL_malloc.c.

#define MLOCK_T   long

Definition at line 1471 of file SDL_malloc.c.

#define MMAP_CHUNK_OVERHEAD   (TWO_SIZE_T_SIZES)

Definition at line 1688 of file SDL_malloc.c.

#define MMAP_CLEARS   0 /* WINCE and some others apparently don't clear */

Definition at line 502 of file SDL_malloc.c.

#define MMAP_FOOT_PAD   (FOUR_SIZE_T_SIZES)

Definition at line 1690 of file SDL_malloc.c.

Referenced by dlfree(), mmap_alloc(), and mmap_resize().

#define MORECORE_CONTIGUOUS   0

Definition at line 575 of file SDL_malloc.c.

Referenced by sys_alloc().

#define MSPACES   0

Definition at line 527 of file SDL_malloc.c.

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

Definition at line 1745 of file SDL_malloc.c.

Referenced by internal_mallinfo(), internal_malloc_stats(), and sys_alloc().

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

Definition at line 1749 of file SDL_malloc.c.

#define NO_MALLINFO   0

Definition at line 612 of file SDL_malloc.c.

#define NSMALLBINS   (32U)

Definition at line 2035 of file SDL_malloc.c.

Referenced by init_bins().

#define NTREEBINS   (32U)

Definition at line 2036 of file SDL_malloc.c.

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

Definition at line 2407 of file SDL_malloc.c.

Referenced by dlfree(), internal_realloc(), tmalloc_large(), and tmalloc_small().

#define ok_cinuse (   p)    cinuse(p)

Definition at line 2411 of file SDL_malloc.c.

Referenced by dlfree(), and internal_realloc().

#define ok_magic (   M)    (1)

Definition at line 2426 of file SDL_malloc.c.

Referenced by dlfree(), and dlrealloc().

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

Definition at line 2409 of file SDL_malloc.c.

Referenced by dlfree(), internal_realloc(), tmalloc_large(), and tmalloc_small().

#define ok_pinuse (   p)    pinuse(p)

Definition at line 2413 of file SDL_malloc.c.

Referenced by dlfree(), and internal_realloc().

#define ONLY_MSPACES   0

Definition at line 521 of file SDL_malloc.c.

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

Definition at line 1767 of file SDL_malloc.c.

Referenced by dlmalloc_usable_size(), and internal_realloc().

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

Definition at line 1707 of file SDL_malloc.c.

Referenced by add_segment(), and dlmalloc().

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

Definition at line 2115 of file SDL_malloc.c.

Referenced by sys_alloc().

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

Definition at line 1734 of file SDL_malloc.c.

Referenced by dlfree(), and prepend_alloc().

#define PINUSE_BIT   (SIZE_T_ONE)

Definition at line 1725 of file SDL_malloc.c.

Referenced by dlfree(), dlmalloc(), init_top(), internal_realloc(), prepend_alloc(), and sys_alloc().

#define POSTACTION (   M)    { if (use_lock(M)) RELEASE_LOCK(&(M)->mutex); }

Definition at line 2186 of file SDL_malloc.c.

Referenced by dlfree(), dlmalloc(), dlmalloc_trim(), ialloc(), internal_mallinfo(), internal_malloc_stats(), internal_memalign(), and internal_realloc().

#define PREACTION (   M)    ((GLOBALLY_INITIALIZE() || use_lock(M))? ACQUIRE_LOCK(&(M)->mutex) : 0)

Definition at line 2185 of file SDL_malloc.c.

Referenced by dlfree(), dlmalloc(), dlmalloc_trim(), ialloc(), internal_mallinfo(), internal_malloc_stats(), internal_memalign(), and internal_realloc().

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

Definition at line 1746 of file SDL_malloc.c.

#define PROCEED_ON_ERROR   0

Definition at line 543 of file SDL_malloc.c.

#define real_calloc   dlcalloc

Definition at line 5254 of file SDL_malloc.c.

#define real_free   dlfree

Definition at line 5256 of file SDL_malloc.c.

#define real_malloc   dlmalloc

Definition at line 5253 of file SDL_malloc.c.

#define real_realloc   dlrealloc

Definition at line 5255 of file SDL_malloc.c.

#define RELEASE_LOCK (   l)    win32_release_lock(l)

Definition at line 1495 of file SDL_malloc.c.

#define RELEASE_MAGIC_INIT_LOCK ( )    RELEASE_LOCK(&magic_init_mutex);

Definition at line 1518 of file SDL_malloc.c.

Referenced by init_mparams().

#define RELEASE_MORECORE_LOCK ( )

Definition at line 1513 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

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

Definition at line 3031 of file SDL_malloc.c.

Referenced by dlmalloc(), and tmalloc_small().

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

Definition at line 1711 of file SDL_malloc.c.

Referenced by ialloc(), internal_memalign(), and internal_realloc().

#define RTCHECK (   e)    (e)

Definition at line 2435 of file SDL_malloc.c.

Referenced by dlfree(), internal_realloc(), tmalloc_large(), and tmalloc_small().

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

Definition at line 2374 of file SDL_malloc.c.

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

Definition at line 2128 of file SDL_malloc.c.

Referenced by internal_mallinfo(), internal_malloc_stats(), release_unused_segments(), and sys_alloc().

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

Definition at line 1753 of file SDL_malloc.c.

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

Definition at line 1760 of file SDL_malloc.c.

Referenced by add_segment(), dlfree(), and prepend_alloc().

#define set_inuse (   M,
  p,
  s 
)
Value:
((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\
((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)

Definition at line 2448 of file SDL_malloc.c.

Referenced by internal_memalign(), and internal_realloc().

#define set_inuse_and_pinuse (   M,
  p,
  s 
)
Value:
((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\
((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)

Definition at line 2453 of file SDL_malloc.c.

Referenced by dlmalloc(), tmalloc_large(), and tmalloc_small().

#define set_lock (   M,
  L 
)
Value:
((M)->mflags = (L)?\
((M)->mflags | USE_LOCK_BIT) :\
((M)->mflags & ~USE_LOCK_BIT))

Definition at line 2109 of file SDL_malloc.c.

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

Definition at line 1756 of file SDL_malloc.c.

Referenced by dlfree(), dlmalloc(), prepend_alloc(), tmalloc_large(), and tmalloc_small().

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

Definition at line 2458 of file SDL_malloc.c.

Referenced by add_segment(), dlmalloc(), ialloc(), prepend_alloc(), sys_alloc(), tmalloc_large(), and tmalloc_small().

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

Definition at line 2158 of file SDL_malloc.c.

Referenced by dlfree().

#define SIX_SIZE_T_SIZES   (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)

Definition at line 1307 of file SDL_malloc.c.

Referenced by mmap_alloc(), and mmap_resize().

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

Definition at line 1298 of file SDL_malloc.c.

Referenced by tmalloc_large().

#define SIZE_T_ONE   ((size_t)1)

Definition at line 1303 of file SDL_malloc.c.

Referenced by dlpvalloc(), init_mparams(), internal_mallinfo(), internal_memalign(), sys_alloc(), sys_trim(), and tmalloc_large().

#define SIZE_T_SIZE   (sizeof(size_t))

Definition at line 1297 of file SDL_malloc.c.

Referenced by add_segment(), dlmalloc(), ialloc(), mmap_alloc(), and mmap_resize().

#define SIZE_T_TWO   ((size_t)2)

Definition at line 1304 of file SDL_malloc.c.

#define SIZE_T_ZERO   ((size_t)0)

Definition at line 1302 of file SDL_malloc.c.

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

Definition at line 2266 of file SDL_malloc.c.

Referenced by dlmalloc().

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

Definition at line 2267 of file SDL_malloc.c.

Referenced by dlmalloc().

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

Definition at line 2271 of file SDL_malloc.c.

Referenced by dlmalloc(), and init_bins().

#define SMALLBIN_SHIFT   (3U)

Definition at line 2037 of file SDL_malloc.c.

#define SMALLBIN_WIDTH   (SIZE_T_ONE << SMALLBIN_SHIFT)

Definition at line 2038 of file SDL_malloc.c.

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

Definition at line 2332 of file SDL_malloc.c.

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

Definition at line 2168 of file SDL_malloc.c.

Referenced by add_segment(), init_top(), internal_mallinfo(), internal_malloc_stats(), release_unused_segments(), sys_alloc(), and sys_trim().

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

Definition at line 2272 of file SDL_malloc.c.

Referenced by tmalloc_large(), and tmalloc_small().

#define TREEBIN_SHIFT   (8U)

Definition at line 2039 of file SDL_malloc.c.

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

Definition at line 2336 of file SDL_malloc.c.

#define TWO_SIZE_T_SIZES   (SIZE_T_SIZE<<1)

Definition at line 1305 of file SDL_malloc.c.

#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); }

Definition at line 3190 of file SDL_malloc.c.

Referenced by dlfree(), and prepend_alloc().

#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))) {\
B->fd = F;\
F->bk = B;\
}\
else {\
CORRUPTION_ERROR_ACTION(M);\
}\
}

Definition at line 3013 of file SDL_malloc.c.

Referenced by dlmalloc().

#define unlink_large_chunk (   M,
  X 
)

Definition at line 3113 of file SDL_malloc.c.

Referenced by release_unused_segments(), tmalloc_large(), and tmalloc_small().

#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 (F == B)\
clear_smallmap(M, I);\
else if (RTCHECK((F == smallbin_at(M,I) || ok_address(M, F)) &&\
(B == smallbin_at(M,I) || ok_address(M, B)))) {\
F->bk = B;\
B->fd = F;\
}\
else {\
CORRUPTION_ERROR_ACTION(M);\
}\
}

Definition at line 2993 of file SDL_malloc.c.

#define USAGE_ERROR_ACTION (   m,
  p 
)    ABORT

Definition at line 2225 of file SDL_malloc.c.

Referenced by dlfree(), dlrealloc(), and internal_realloc().

#define USE_BUILTIN_FFS   0

Definition at line 606 of file SDL_malloc.c.

#define USE_DEV_RANDOM   0

Definition at line 609 of file SDL_malloc.c.

#define USE_DL_PREFIX

Definition at line 41 of file SDL_malloc.c.

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

Definition at line 2098 of file SDL_malloc.c.

#define USE_LOCK_BIT   (2U)

Definition at line 1502 of file SDL_malloc.c.

Referenced by init_mparams().

#define USE_LOCKS   1

Definition at line 40 of file SDL_malloc.c.

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

Definition at line 2102 of file SDL_malloc.c.

Referenced by ialloc(), and sys_alloc().

#define USE_MMAP_BIT   (SIZE_T_ONE)

Definition at line 1343 of file SDL_malloc.c.

Referenced by init_mparams().

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

Definition at line 2106 of file SDL_malloc.c.

Referenced by sys_alloc().

#define USE_NONCONTIGUOUS_BIT   (4U)

Definition at line 1427 of file SDL_malloc.c.

Referenced by init_mparams().

#define WIN32   1

Definition at line 485 of file SDL_malloc.c.

#define WIN32_LEAN_AND_MEAN

Definition at line 489 of file SDL_malloc.c.

Typedef Documentation

typedef size_t bindex_t

Definition at line 1673 of file SDL_malloc.c.

typedef unsigned int binmap_t

Definition at line 1674 of file SDL_malloc.c.

typedef unsigned int flag_t

Definition at line 1675 of file SDL_malloc.c.

Function Documentation

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

Definition at line 3387 of file SDL_malloc.c.

References align_offset, assert, check_top_chunk, chunk2mem, CHUNK_ALIGN_MASK, chunk_plus_offset, FENCEPOST_HEAD, FOUR_SIZE_T_SIZES, init_top(), insert_chunk, is_aligned, MIN_CHUNK_SIZE, pad_request, segment_holding(), set_free_with_pinuse, set_size_and_pinuse_of_inuse_chunk, SIZE_T_SIZE, and TOP_FOOT_SIZE.

Referenced by sys_alloc().

{
/* Determine locations and sizes of segment, fenceposts, old top */
char *old_top = (char *) m->top;
msegmentptr oldsp = segment_holding(m, old_top);
char *old_end = oldsp->base + oldsp->size;
size_t ssize = pad_request(sizeof(struct malloc_segment));
char *rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
size_t offset = align_offset(chunk2mem(rawsp));
char *asp = rawsp + offset;
char *csp = (asp < (old_top + MIN_CHUNK_SIZE)) ? old_top : asp;
mchunkptr sp = (mchunkptr) csp;
msegmentptr ss = (msegmentptr) (chunk2mem(sp));
mchunkptr tnext = chunk_plus_offset(sp, ssize);
mchunkptr p = tnext;
int nfences = 0;
/* reset top to new space */
init_top(m, (mchunkptr) tbase, tsize - TOP_FOOT_SIZE);
/* Set up segment record */
assert(is_aligned(ss));
set_size_and_pinuse_of_inuse_chunk(m, sp, ssize);
*ss = m->seg; /* Push current record */
m->seg.base = tbase;
m->seg.size = tsize;
m->seg.sflags = mmapped;
m->seg.next = ss;
/* Insert trailing fenceposts */
for (;;) {
mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE);
p->head = FENCEPOST_HEAD;
++nfences;
if ((char *) (&(nextp->head)) < old_end)
p = nextp;
else
break;
}
assert(nfences >= 2);
/* Insert the rest of old top into a bin as an ordinary free chunk */
if (csp != old_top) {
mchunkptr q = (mchunkptr) old_top;
size_t psize = csp - old_top;
mchunkptr tn = chunk_plus_offset(q, psize);
set_free_with_pinuse(q, psize, tn);
insert_chunk(m, q, psize);
}
check_top_chunk(m, m->top);
}
static int change_mparam ( int  param_number,
int  value 
)
static

Definition at line 2569 of file SDL_malloc.c.

References malloc_params::granularity, init_mparams(), M_GRANULARITY, M_MMAP_THRESHOLD, M_TRIM_THRESHOLD, malloc_params::mmap_threshold, mparams, malloc_params::page_size, and malloc_params::trim_threshold.

Referenced by dlmallopt().

{
size_t val = (size_t) value;
init_mparams();
switch (param_number) {
case M_TRIM_THRESHOLD:
mparams.trim_threshold = val;
return 1;
case M_GRANULARITY:
if (val >= mparams.page_size && ((val & (val - 1)) == 0)) {
mparams.granularity = val;
return 1;
} else
return 0;
case M_MMAP_THRESHOLD:
mparams.mmap_threshold = val;
return 1;
default:
return 0;
}
}
void * dlcalloc ( size_t  n_elements,
size_t  elem_size 
)

Definition at line 4385 of file SDL_malloc.c.

References calloc_must_clear, dlmalloc(), MAX_SIZE_T, mem2chunk, and memset.

{
void *mem;
size_t req = 0;
if (n_elements != 0) {
req = n_elements * elem_size;
if (((n_elements | elem_size) & ~(size_t) 0xffff) &&
(req / n_elements != elem_size))
req = MAX_SIZE_T; /* force downstream failure on overflow */
}
mem = dlmalloc(req);
if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
memset(mem, 0, req);
return mem;
}
void dlfree ( void *  mem)

Definition at line 4288 of file SDL_malloc.c.

References CALL_MUNMAP, check_free_chunk, check_inuse_chunk, chunk_minus_offset, chunk_plus_offset, chunksize, cinuse, fm, insert_chunk, INUSE_BITS, IS_MMAPPED_BIT, mem2chunk, MMAP_FOOT_PAD, ok_address, ok_cinuse, ok_magic, ok_next, ok_pinuse, pinuse, PINUSE_BIT, POSTACTION, PREACTION, RTCHECK, set_free_with_pinuse, set_size_and_pinuse_of_free_chunk, should_trim, sys_trim(), unlink_chunk, and USAGE_ERROR_ACTION.

Referenced by dlrealloc().

{
/*
Consolidate freed chunks with preceeding or succeeding bordering
free chunks, if they exist, and then place in a bin. Intermixed
with special cases for top, dv, mmapped chunks, and usage errors.
*/
if (mem != 0) {
mchunkptr p = mem2chunk(mem);
#if FOOTERS
mstate fm = get_mstate_for(p);
if (!ok_magic(fm)) {
USAGE_ERROR_ACTION(fm, p);
return;
}
#else /* FOOTERS */
#define fm gm
#endif /* FOOTERS */
if (!PREACTION(fm)) {
check_inuse_chunk(fm, p);
if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
size_t psize = chunksize(p);
mchunkptr next = chunk_plus_offset(p, psize);
if (!pinuse(p)) {
size_t prevsize = p->prev_foot;
if ((prevsize & IS_MMAPPED_BIT) != 0) {
prevsize &= ~IS_MMAPPED_BIT;
psize += prevsize + MMAP_FOOT_PAD;
if (CALL_MUNMAP((char *) p - prevsize, psize) == 0)
fm->footprint -= psize;
goto postaction;
} else {
mchunkptr prev = chunk_minus_offset(p, prevsize);
psize += prevsize;
p = prev;
if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
if (p != fm->dv) {
unlink_chunk(fm, p, prevsize);
} else if ((next->head & INUSE_BITS) ==
INUSE_BITS) {
fm->dvsize = psize;
set_free_with_pinuse(p, psize, next);
goto postaction;
}
} else
goto erroraction;
}
}
if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
if (!cinuse(next)) { /* consolidate forward */
if (next == fm->top) {
size_t tsize = fm->topsize += psize;
fm->top = p;
p->head = tsize | PINUSE_BIT;
if (p == fm->dv) {
fm->dv = 0;
fm->dvsize = 0;
}
if (should_trim(fm, tsize))
sys_trim(fm, 0);
goto postaction;
} else if (next == fm->dv) {
size_t dsize = fm->dvsize += psize;
fm->dv = p;
set_size_and_pinuse_of_free_chunk(p, dsize);
goto postaction;
} else {
size_t nsize = chunksize(next);
psize += nsize;
unlink_chunk(fm, next, nsize);
set_size_and_pinuse_of_free_chunk(p, psize);
if (p == fm->dv) {
fm->dvsize = psize;
goto postaction;
}
}
} else
set_free_with_pinuse(p, psize, next);
insert_chunk(fm, p, psize);
check_free_chunk(fm, p);
goto postaction;
}
}
erroraction:
USAGE_ERROR_ACTION(fm, p);
postaction:
POSTACTION(fm);
}
}
#if !FOOTERS
#undef fm
#endif /* FOOTERS */
}
void** dlindependent_calloc ( size_t  ,
size_t  ,
void **   
)
void** dlindependent_calloc ( size_t  n_elements,
size_t  elem_size,
void *  chunks[] 
)

Definition at line 4433 of file SDL_malloc.c.

References gm, and ialloc().

{
size_t sz = elem_size; /* serves as 1-element array */
return ialloc(gm, n_elements, &sz, 3, chunks);
}
void** dlindependent_comalloc ( size_t  ,
size_t *  ,
void **   
)
void** dlindependent_comalloc ( size_t  n_elements,
size_t  sizes[],
void *  chunks[] 
)

Definition at line 4440 of file SDL_malloc.c.

References gm, and ialloc().

{
return ialloc(gm, n_elements, sizes, 0, chunks);
}
struct mallinfo dlmallinfo ( void  )
read

Definition at line 4489 of file SDL_malloc.c.

References gm, and internal_mallinfo().

{
return internal_mallinfo(gm);
}
void * dlmalloc ( size_t  bytes)

Definition at line 4154 of file SDL_malloc.c.

References assert, check_malloced_chunk, check_top_chunk, chunk2mem, chunk_plus_offset, chunksize, compute_bit2idx, gm, i, idx2bit, least_bit, left_bits, MAX_REQUEST, MAX_SIZE_T, MAX_SMALL_REQUEST, MIN_CHUNK_SIZE, MIN_REQUEST, pad_request, PINUSE_BIT, POSTACTION, PREACTION, replace_dv, set_inuse_and_pinuse, set_size_and_pinuse_of_free_chunk, set_size_and_pinuse_of_inuse_chunk, SIZE_T_SIZE, small_index, small_index2size, smallbin_at, sys_alloc(), tmalloc_large(), tmalloc_small(), and unlink_first_small_chunk.

Referenced by dlcalloc(), and dlrealloc().

{
/*
Basic algorithm:
If a small request (< 256 bytes minus per-chunk overhead):
1. If one exists, use a remainderless chunk in associated smallbin.
(Remainderless means that there are too few excess bytes to
represent as a chunk.)
2. If it is big enough, use the dv chunk, which is normally the
chunk adjacent to the one used for the most recent small request.
3. If one exists, split the smallest available chunk in a bin,
saving remainder in dv.
4. If it is big enough, use the top chunk.
5. If available, get memory from system and use it
Otherwise, for a large request:
1. Find the smallest available binned chunk that fits, and use it
if it is better fitting than dv chunk, splitting if necessary.
2. If better fitting than any binned chunk, use the dv chunk.
3. If it is big enough, use the top chunk.
4. If request size >= mmap threshold, try to directly mmap this chunk.
5. If available, get memory from system and use it
The ugly goto's here ensure that postaction occurs along all paths.
*/
if (!PREACTION(gm)) {
void *mem;
size_t nb;
if (bytes <= MAX_SMALL_REQUEST) {
bindex_t idx;
binmap_t smallbits;
nb = (bytes < MIN_REQUEST) ? MIN_CHUNK_SIZE : pad_request(bytes);
idx = small_index(nb);
smallbits = gm->smallmap >> idx;
if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
mchunkptr b, p;
idx += ~smallbits & 1; /* Uses next bin if idx empty */
b = smallbin_at(gm, idx);
p = b->fd;
assert(chunksize(p) == small_index2size(idx));
unlink_first_small_chunk(gm, b, p, idx);
set_inuse_and_pinuse(gm, p, small_index2size(idx));
mem = chunk2mem(p);
check_malloced_chunk(gm, mem, nb);
goto postaction;
}
else if (nb > gm->dvsize) {
if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
mchunkptr b, p, r;
size_t rsize;
bindex_t i;
binmap_t leftbits =
(smallbits << idx) & left_bits(idx2bit(idx));
binmap_t leastbit = least_bit(leftbits);
compute_bit2idx(leastbit, i);
b = smallbin_at(gm, i);
p = b->fd;
assert(chunksize(p) == small_index2size(i));
unlink_first_small_chunk(gm, b, p, i);
rsize = small_index2size(i) - nb;
/* Fit here cannot be remainderless if 4byte sizes */
if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
set_inuse_and_pinuse(gm, p, small_index2size(i));
else {
set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
r = chunk_plus_offset(p, nb);
set_size_and_pinuse_of_free_chunk(r, rsize);
replace_dv(gm, r, rsize);
}
mem = chunk2mem(p);
check_malloced_chunk(gm, mem, nb);
goto postaction;
}
else if (gm->treemap != 0
&& (mem = tmalloc_small(gm, nb)) != 0) {
check_malloced_chunk(gm, mem, nb);
goto postaction;
}
}
} else if (bytes >= MAX_REQUEST)
nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
else {
nb = pad_request(bytes);
if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) {
check_malloced_chunk(gm, mem, nb);
goto postaction;
}
}
if (nb <= gm->dvsize) {
size_t rsize = gm->dvsize - nb;
mchunkptr p = gm->dv;
if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
gm->dvsize = rsize;
set_size_and_pinuse_of_free_chunk(r, rsize);
set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
} else { /* exhaust dv */
size_t dvs = gm->dvsize;
gm->dvsize = 0;
gm->dv = 0;
set_inuse_and_pinuse(gm, p, dvs);
}
mem = chunk2mem(p);
check_malloced_chunk(gm, mem, nb);
goto postaction;
}
else if (nb < gm->topsize) { /* Split top */
size_t rsize = gm->topsize -= nb;
mchunkptr p = gm->top;
mchunkptr r = gm->top = chunk_plus_offset(p, nb);
r->head = rsize | PINUSE_BIT;
set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
mem = chunk2mem(p);
check_top_chunk(gm, gm->top);
check_malloced_chunk(gm, mem, nb);
goto postaction;
}
mem = sys_alloc(gm, nb);
postaction:
POSTACTION(gm);
return mem;
}
return 0;
}
size_t dlmalloc_footprint ( void  )

Definition at line 4476 of file SDL_malloc.c.

References gm.

{
return gm->footprint;
}
size_t dlmalloc_max_footprint ( void  )

Definition at line 4482 of file SDL_malloc.c.

References gm.

{
return gm->max_footprint;
}
void dlmalloc_stats ( void  )

Definition at line 4496 of file SDL_malloc.c.

References gm, and internal_malloc_stats().

{
internal_malloc_stats(gm);
}
int dlmalloc_trim ( size_t  pad)

Definition at line 4465 of file SDL_malloc.c.

References gm, POSTACTION, PREACTION, and sys_trim().

{
int result = 0;
if (!PREACTION(gm)) {
result = sys_trim(gm, pad);
POSTACTION(gm);
}
return result;
}
size_t dlmalloc_usable_size ( void *  mem)

Definition at line 4502 of file SDL_malloc.c.

References chunksize, cinuse, mem2chunk, and overhead_for.

{
if (mem != 0) {
mchunkptr p = mem2chunk(mem);
if (cinuse(p))
return chunksize(p) - overhead_for(p);
}
return 0;
}
int dlmallopt ( int  param_number,
int  value 
)

Definition at line 4513 of file SDL_malloc.c.

References change_mparam().

{
return change_mparam(param_number, value);
}
void * dlmemalign ( size_t  alignment,
size_t  bytes 
)

Definition at line 4427 of file SDL_malloc.c.

References gm, and internal_memalign().

Referenced by dlpvalloc(), and dlvalloc().

{
return internal_memalign(gm, alignment, bytes);
}
void * dlpvalloc ( size_t  bytes)

Definition at line 4455 of file SDL_malloc.c.

References dlmemalign(), init_mparams(), mparams, malloc_params::page_size, and SIZE_T_ONE.

{
size_t pagesz;
init_mparams();
pagesz = mparams.page_size;
return dlmemalign(pagesz,
(bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
}
void * dlrealloc ( void *  oldmem,
size_t  bytes 
)

Definition at line 4402 of file SDL_malloc.c.

References dlfree(), dlmalloc(), gm, internal_realloc(), mem2chunk, ok_magic, and USAGE_ERROR_ACTION.

{
if (oldmem == 0)
return dlmalloc(bytes);
#ifdef REALLOC_ZERO_BYTES_FREES
if (bytes == 0) {
dlfree(oldmem);
return 0;
}
#endif /* REALLOC_ZERO_BYTES_FREES */
else {
#if ! FOOTERS
mstate m = gm;
#else /* FOOTERS */
mstate m = get_mstate_for(mem2chunk(oldmem));
if (!ok_magic(m)) {
USAGE_ERROR_ACTION(m, oldmem);
return 0;
}
#endif /* FOOTERS */
return internal_realloc(m, oldmem, bytes);
}
}
void * dlvalloc ( size_t  bytes)

Definition at line 4446 of file SDL_malloc.c.

References dlmemalign(), init_mparams(), mparams, and malloc_params::page_size.

{
size_t pagesz;
init_mparams();
pagesz = mparams.page_size;
return dlmemalign(pagesz, bytes);
}
static int has_segment_link ( mstate  m,
msegmentptr  ss 
)
static

Definition at line 2146 of file SDL_malloc.c.

Referenced by sys_trim().

{
msegmentptr sp = &m->seg;
for (;;) {
if ((char *) sp >= ss->base && (char *) sp < ss->base + ss->size)
return 1;
if ((sp = sp->next) == 0)
return 0;
}
}
static void** ialloc ( mstate  m,
size_t  n_elements,
size_t *  sizes,
int  opts,
void *  chunks[] 
)
static

Definition at line 4028 of file SDL_malloc.c.

References assert, check_inuse_chunk, chunk2mem, CHUNK_OVERHEAD, chunk_plus_offset, chunksize, disable_mmap, enable_mmap, i, internal_malloc, is_mmapped, mem2chunk, memset, POSTACTION, PREACTION, request2size, set_size_and_pinuse_of_inuse_chunk, SIZE_T_SIZE, and use_mmap.

Referenced by dlindependent_calloc(), and dlindependent_comalloc().

{
/*
This provides common support for independent_X routines, handling
all of the combinations that can result.
The opts arg has:
bit 0 set if all elements are same size (using sizes[0])
bit 1 set if elements should be zeroed
*/
size_t element_size; /* chunksize of each element, if all same */
size_t contents_size; /* total size of elements */
size_t array_size; /* request size of pointer array */
void *mem; /* malloced aggregate space */
mchunkptr p; /* corresponding chunk */
size_t remainder_size; /* remaining bytes while splitting */
void **marray; /* either "chunks" or malloced ptr array */
mchunkptr array_chunk; /* chunk for malloced ptr array */
flag_t was_enabled; /* to disable mmap */
size_t size;
size_t i;
/* compute array length, if needed */
if (chunks != 0) {
if (n_elements == 0)
return chunks; /* nothing to do */
marray = chunks;
array_size = 0;
} else {
/* if empty req, must still return chunk representing empty array */
if (n_elements == 0)
return (void **) internal_malloc(m, 0);
marray = 0;
array_size = request2size(n_elements * (sizeof(void *)));
}
/* compute total element size */
if (opts & 0x1) { /* all-same-size */
element_size = request2size(*sizes);
contents_size = n_elements * element_size;
} else { /* add up all the sizes */
element_size = 0;
contents_size = 0;
for (i = 0; i != n_elements; ++i)
contents_size += request2size(sizes[i]);
}
size = contents_size + array_size;
/*
Allocate the aggregate chunk. First disable direct-mmapping so
malloc won't use it, since we would not be able to later
free/realloc space internal to a segregated mmap region.
*/
was_enabled = use_mmap(m);
disable_mmap(m);
mem = internal_malloc(m, size - CHUNK_OVERHEAD);
if (was_enabled)
enable_mmap(m);
if (mem == 0)
return 0;
if (PREACTION(m))
return 0;
p = mem2chunk(mem);
remainder_size = chunksize(p);
assert(!is_mmapped(p));
if (opts & 0x2) { /* optionally clear the elements */
memset((size_t *) mem, 0, remainder_size - SIZE_T_SIZE - array_size);
}
/* If not provided, allocate the pointer array as final part of chunk */
if (marray == 0) {
size_t array_chunk_size;
array_chunk = chunk_plus_offset(p, contents_size);
array_chunk_size = remainder_size - contents_size;
marray = (void **) (chunk2mem(array_chunk));
set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
remainder_size = contents_size;
}
/* split out elements */
for (i = 0;; ++i) {
marray[i] = chunk2mem(p);
if (i != n_elements - 1) {
if (element_size != 0)
size = element_size;
else
size = request2size(sizes[i]);
remainder_size -= size;
set_size_and_pinuse_of_inuse_chunk(m, p, size);
p = chunk_plus_offset(p, size);
} else { /* the final element absorbs any overallocation slop */
set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
break;
}
}
#if DEBUG
if (marray != chunks) {
/* final element must have exactly exhausted chunk */
if (element_size != 0) {
assert(remainder_size == element_size);
} else {
assert(remainder_size == request2size(sizes[i]));
}
check_inuse_chunk(m, mem2chunk(marray));
}
for (i = 0; i != n_elements; ++i)
check_inuse_chunk(m, mem2chunk(marray[i]));
#endif /* DEBUG */
POSTACTION(m);
return marray;
}
static void init_bins ( mstate  m)
static

Definition at line 3312 of file SDL_malloc.c.

References i, NSMALLBINS, and smallbin_at.

Referenced by sys_alloc().

{
/* Establish circular links for smallbins */
bindex_t i;
for (i = 0; i < NSMALLBINS; ++i) {
sbinptr bin = smallbin_at(m, i);
bin->fd = bin->bk = bin;
}
}
static int init_mparams ( void  )
static

Definition at line 2491 of file SDL_malloc.c.

References ABORT, ACQUIRE_MAGIC_INIT_LOCK, DEFAULT_GRANULARITY, malloc_params::default_mflags, DEFAULT_MMAP_THRESHOLD, DEFAULT_TRIM_THRESHOLD, gm, malloc_params::granularity, INITIAL_LOCK, malloc_params::magic, MALLOC_ALIGNMENT, MAX_SIZE_T, MCHUNK_SIZE, MIN_CHUNK_SIZE, malloc_params::mmap_threshold, mparams, malloc_params::page_size, RELEASE_MAGIC_INIT_LOCK, SIZE_T_ONE, malloc_params::trim_threshold, USE_LOCK_BIT, USE_MMAP_BIT, and USE_NONCONTIGUOUS_BIT.

Referenced by change_mparam(), dlpvalloc(), dlvalloc(), and sys_alloc().

{
if (mparams.page_size == 0) {
size_t s;
mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD;
#if MORECORE_CONTIGUOUS
mparams.default_mflags = USE_LOCK_BIT | USE_MMAP_BIT;
#else /* MORECORE_CONTIGUOUS */
mparams.default_mflags =
USE_LOCK_BIT | USE_MMAP_BIT | USE_NONCONTIGUOUS_BIT;
#endif /* MORECORE_CONTIGUOUS */
#if (FOOTERS && !INSECURE)
{
#if USE_DEV_RANDOM
int fd;
unsigned char buf[sizeof(size_t)];
/* Try to use /dev/urandom, else fall back on using time */
if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 &&
read(fd, buf, sizeof(buf)) == sizeof(buf)) {
s = *((size_t *) buf);
close(fd);
} else
#endif /* USE_DEV_RANDOM */
s = (size_t) (time(0) ^ (size_t) 0x55555555U);
s |= (size_t) 8U; /* ensure nonzero */
s &= ~(size_t) 7U; /* improve chances of fault for bad values */
}
#else /* (FOOTERS && !INSECURE) */
s = (size_t) 0x58585858U;
#endif /* (FOOTERS && !INSECURE) */
ACQUIRE_MAGIC_INIT_LOCK();
if (mparams.magic == 0) {
mparams.magic = s;
/* Set up lock for main malloc area */
INITIAL_LOCK(&gm->mutex);
gm->mflags = mparams.default_mflags;
}
RELEASE_MAGIC_INIT_LOCK();
#ifndef WIN32
mparams.page_size = malloc_getpagesize;
mparams.granularity = ((DEFAULT_GRANULARITY != 0) ?
DEFAULT_GRANULARITY : mparams.page_size);
#else /* WIN32 */
{
SYSTEM_INFO system_info;
GetSystemInfo(&system_info);
mparams.page_size = system_info.dwPageSize;
mparams.granularity = system_info.dwAllocationGranularity;
}
#endif /* WIN32 */
/* Sanity-check configuration:
size_t must be unsigned and as wide as pointer type.
ints must be at least 4 bytes.
alignment must be at least 8.
Alignment, min chunk size, and page size must all be powers of 2.
*/
if ((sizeof(size_t) != sizeof(char *)) ||
(MAX_SIZE_T < MIN_CHUNK_SIZE) ||
(sizeof(int) < 4) ||
(MALLOC_ALIGNMENT < (size_t) 8U) ||
((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT - SIZE_T_ONE)) != 0) ||
((MCHUNK_SIZE & (MCHUNK_SIZE - SIZE_T_ONE)) != 0) ||
((mparams.granularity & (mparams.granularity - SIZE_T_ONE)) != 0)
|| ((mparams.page_size & (mparams.page_size - SIZE_T_ONE)) != 0))
ABORT;
}
return 0;
}
static void init_top ( mstate  m,
mchunkptr  p,
size_t  psize 
)
static

Definition at line 3295 of file SDL_malloc.c.

References align_offset, chunk2mem, chunk_plus_offset, mparams, PINUSE_BIT, TOP_FOOT_SIZE, and malloc_params::trim_threshold.

Referenced by add_segment(), sys_alloc(), and sys_trim().

{
/* Ensure alignment */
size_t offset = align_offset(chunk2mem(p));
p = (mchunkptr) ((char *) p + offset);
psize -= offset;
m->top = p;
m->topsize = psize;
p->head = psize | PINUSE_BIT;
/* set size of fake trailing chunk holding overhead space only once */
chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE;
m->trim_check = mparams.trim_threshold; /* reset on each update */
}
static struct mallinfo internal_mallinfo ( mstate  m)
staticread

Definition at line 2884 of file SDL_malloc.c.

References align_as_chunk, mallinfo::arena, check_malloc_state, chunksize, cinuse, FENCEPOST_HEAD, mallinfo::fordblks, mallinfo::hblkhd, is_initialized, mallinfo::keepcost, next_chunk, mallinfo::ordblks, POSTACTION, PREACTION, segment_holds, SIZE_T_ONE, TOP_FOOT_SIZE, mallinfo::uordblks, and mallinfo::usmblks.

Referenced by dlmallinfo().

{
struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
if (!PREACTION(m)) {
check_malloc_state(m);
if (is_initialized(m)) {
size_t nfree = SIZE_T_ONE; /* top always free */
size_t mfree = m->topsize + TOP_FOOT_SIZE;
size_t sum = mfree;
msegmentptr s = &m->seg;
while (s != 0) {
mchunkptr q = align_as_chunk(s->base);
while (segment_holds(s, q) &&
q != m->top && q->head != FENCEPOST_HEAD) {
size_t sz = chunksize(q);
sum += sz;
if (!cinuse(q)) {
mfree += sz;
++nfree;
}
q = next_chunk(q);
}
s = s->next;
}
nm.arena = sum;
nm.ordblks = nfree;
nm.hblkhd = m->footprint - sum;
nm.usmblks = m->max_footprint;
nm.uordblks = m->footprint - mfree;
nm.fordblks = mfree;
nm.keepcost = m->topsize;
}
POSTACTION(m);
}
return nm;
}
static void internal_malloc_stats ( mstate  m)
static

Definition at line 2925 of file SDL_malloc.c.

References align_as_chunk, check_malloc_state, chunksize, cinuse, FENCEPOST_HEAD, is_initialized, next_chunk, POSTACTION, PREACTION, segment_holds, and TOP_FOOT_SIZE.

Referenced by dlmalloc_stats().

{
if (!PREACTION(m)) {
#ifndef LACKS_STDIO_H
size_t maxfp = 0;
#endif
size_t fp = 0;
size_t used = 0;
check_malloc_state(m);
if (is_initialized(m)) {
msegmentptr s = &m->seg;
#ifndef LACKS_STDIO_H
maxfp = m->max_footprint;
#endif
fp = m->footprint;
used = fp - (m->topsize + TOP_FOOT_SIZE);
while (s != 0) {
mchunkptr q = align_as_chunk(s->base);
while (segment_holds(s, q) &&
q != m->top && q->head != FENCEPOST_HEAD) {
if (!cinuse(q))
used -= chunksize(q);
q = next_chunk(q);
}
s = s->next;
}
}
#ifndef LACKS_STDIO_H
fprintf(stderr, "max system bytes = %10lu\n",
(unsigned long) (maxfp));
fprintf(stderr, "system bytes = %10lu\n", (unsigned long) (fp));
fprintf(stderr, "in use bytes = %10lu\n", (unsigned long) (used));
#endif
POSTACTION(m);
}
}
static void* internal_memalign ( mstate  m,
size_t  alignment,
size_t  bytes 
)
static

Definition at line 3938 of file SDL_malloc.c.

References assert, check_inuse_chunk, chunk2mem, CHUNK_OVERHEAD, chunk_plus_offset, chunksize, CINUSE_BIT, internal_free, internal_malloc, is_mmapped, MALLOC_ALIGNMENT, MALLOC_FAILURE_ACTION, MAX_REQUEST, mem2chunk, MIN_CHUNK_SIZE, POSTACTION, PREACTION, request2size, set_inuse, and SIZE_T_ONE.

Referenced by dlmemalign().

{
if (alignment <= MALLOC_ALIGNMENT) /* Can just use malloc */
return internal_malloc(m, bytes);
if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */
alignment = MIN_CHUNK_SIZE;
if ((alignment & (alignment - SIZE_T_ONE)) != 0) { /* Ensure a power of 2 */
size_t a = MALLOC_ALIGNMENT << 1;
while (a < alignment)
a <<= 1;
alignment = a;
}
if (bytes >= MAX_REQUEST - alignment) {
if (m != 0) { /* Test isn't needed but avoids compiler warning */
MALLOC_FAILURE_ACTION;
}
} else {
size_t nb = request2size(bytes);
size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
char *mem = (char *) internal_malloc(m, req);
if (mem != 0) {
void *leader = 0;
void *trailer = 0;
mchunkptr p = mem2chunk(mem);
if (PREACTION(m))
return 0;
if ((((size_t) (mem)) % alignment) != 0) { /* misaligned */
/*
Find an aligned spot inside chunk. Since we need to give
back leading space in a chunk of at least MIN_CHUNK_SIZE, if
the first calculation places us at a spot with less than
MIN_CHUNK_SIZE leader, we can move to the next aligned spot.
We've allocated enough total room so that this is always
possible.
*/
char *br = (char *) mem2chunk((size_t) (((size_t) (mem +
alignment -
SIZE_T_ONE))
& -alignment));
char *pos =
((size_t) (br - (char *) (p)) >=
MIN_CHUNK_SIZE) ? br : br + alignment;
mchunkptr newp = (mchunkptr) pos;
size_t leadsize = pos - (char *) (p);
size_t newsize = chunksize(p) - leadsize;
if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */
newp->prev_foot = p->prev_foot + leadsize;
newp->head = (newsize | CINUSE_BIT);
} else { /* Otherwise, give back leader, use the rest */
set_inuse(m, newp, newsize);
set_inuse(m, p, leadsize);
leader = chunk2mem(p);
}
p = newp;
}
/* Give back spare room at the end */
if (!is_mmapped(p)) {
size_t size = chunksize(p);
if (size > nb + MIN_CHUNK_SIZE) {
size_t remainder_size = size - nb;
mchunkptr remainder = chunk_plus_offset(p, nb);
set_inuse(m, p, nb);
set_inuse(m, remainder, remainder_size);
trailer = chunk2mem(remainder);
}
}
assert(chunksize(p) >= nb);
assert((((size_t) (chunk2mem(p))) % alignment) == 0);
check_inuse_chunk(m, p);
POSTACTION(m);
if (leader != 0) {
internal_free(m, leader);
}
if (trailer != 0) {
internal_free(m, trailer);
}
return chunk2mem(p);
}
}
return 0;
}
static void* internal_realloc ( mstate  m,
void *  oldmem,
size_t  bytes 
)
static

Definition at line 3868 of file SDL_malloc.c.

References check_inuse_chunk, chunk2mem, chunk_plus_offset, chunksize, internal_free, internal_malloc, is_mmapped, MALLOC_FAILURE_ACTION, MAX_REQUEST, mem2chunk, memcpy, MIN_CHUNK_SIZE, mmap_resize(), ok_address, ok_cinuse, ok_next, ok_pinuse, overhead_for, PINUSE_BIT, POSTACTION, PREACTION, request2size, RTCHECK, set_inuse, and USAGE_ERROR_ACTION.

Referenced by dlrealloc().

{
if (bytes >= MAX_REQUEST) {
MALLOC_FAILURE_ACTION;
return 0;
}
if (!PREACTION(m)) {
mchunkptr oldp = mem2chunk(oldmem);
size_t oldsize = chunksize(oldp);
mchunkptr next = chunk_plus_offset(oldp, oldsize);
mchunkptr newp = 0;
void *extra = 0;
/* Try to either shrink or extend into top. Else malloc-copy-free */
if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) &&
ok_next(oldp, next) && ok_pinuse(next))) {
size_t nb = request2size(bytes);
if (is_mmapped(oldp))
newp = mmap_resize(m, oldp, nb);
else if (oldsize >= nb) { /* already big enough */
size_t rsize = oldsize - nb;
newp = oldp;
if (rsize >= MIN_CHUNK_SIZE) {
mchunkptr remainder = chunk_plus_offset(newp, nb);
set_inuse(m, newp, nb);
set_inuse(m, remainder, rsize);
extra = chunk2mem(remainder);
}
} else if (next == m->top && oldsize + m->topsize > nb) {
/* Expand into top */
size_t newsize = oldsize + m->topsize;
size_t newtopsize = newsize - nb;
mchunkptr newtop = chunk_plus_offset(oldp, nb);
set_inuse(m, oldp, nb);
newtop->head = newtopsize | PINUSE_BIT;
m->top = newtop;
m->topsize = newtopsize;
newp = oldp;
}
} else {
USAGE_ERROR_ACTION(m, oldmem);
POSTACTION(m);
return 0;
}
POSTACTION(m);
if (newp != 0) {
if (extra != 0) {
internal_free(m, extra);
}
check_inuse_chunk(m, newp);
return chunk2mem(newp);
} else {
void *newmem = internal_malloc(m, bytes);
if (newmem != 0) {
size_t oc = oldsize - overhead_for(oldp);
memcpy(newmem, oldmem, (oc < bytes) ? oc : bytes);
internal_free(m, oldmem);
}
return newmem;
}
}
return 0;
}
static void* mmap_alloc ( mstate  m,
size_t  nb 
)
static

Definition at line 3226 of file SDL_malloc.c.

References align_offset, assert, check_mmapped_chunk, chunk2mem, CHUNK_ALIGN_MASK, chunk_plus_offset, CINUSE_BIT, CMFAIL, DIRECT_MMAP, FENCEPOST_HEAD, granularity_align, is_aligned, IS_MMAPPED_BIT, mark_inuse_foot, MMAP_FOOT_PAD, sbinptr::prev_foot, SIX_SIZE_T_SIZES, and SIZE_T_SIZE.

Referenced by sys_alloc().

{
size_t mmsize =
granularity_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
if (mmsize > nb) { /* Check for wrap around 0 */
char *mm = (char *) (DIRECT_MMAP(mmsize));
if (mm != CMFAIL) {
size_t offset = align_offset(chunk2mem(mm));
size_t psize = mmsize - offset - MMAP_FOOT_PAD;
mchunkptr p = (mchunkptr) (mm + offset);
p->prev_foot = offset | IS_MMAPPED_BIT;
(p)->head = (psize | CINUSE_BIT);
mark_inuse_foot(m, p, psize);
chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD;
chunk_plus_offset(p, psize + SIZE_T_SIZE)->head = 0;
if (mm < m->least_addr)
m->least_addr = mm;
if ((m->footprint += mmsize) > m->max_footprint)
m->max_footprint = m->footprint;
assert(is_aligned(chunk2mem(p)));
check_mmapped_chunk(m, p);
return chunk2mem(p);
}
}
return 0;
}
static mchunkptr mmap_resize ( mstate  m,
mchunkptr  oldp,
size_t  nb 
)
static

Definition at line 3256 of file SDL_malloc.c.

References CALL_MREMAP, check_mmapped_chunk, CHUNK_ALIGN_MASK, chunk_plus_offset, chunksize, CINUSE_BIT, CMFAIL, cp, FENCEPOST_HEAD, malloc_params::granularity, granularity_align, IS_MMAPPED_BIT, is_small, mark_inuse_foot, MMAP_FOOT_PAD, mparams, SIX_SIZE_T_SIZES, and SIZE_T_SIZE.

Referenced by internal_realloc().

{
size_t oldsize = chunksize(oldp);
if (is_small(nb)) /* Can't shrink mmap regions below small size */
return 0;
/* Keep old chunk if big enough but not too big */
if (oldsize >= nb + SIZE_T_SIZE &&
(oldsize - nb) <= (mparams.granularity << 1))
return oldp;
else {
size_t offset = oldp->prev_foot & ~IS_MMAPPED_BIT;
size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
size_t newmmsize = granularity_align(nb + SIX_SIZE_T_SIZES +
CHUNK_ALIGN_MASK);
char *cp = (char *) CALL_MREMAP((char *) oldp - offset,
oldmmsize, newmmsize, 1);
if (cp != CMFAIL) {
mchunkptr newp = (mchunkptr) (cp + offset);
size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
newp->head = (psize | CINUSE_BIT);
mark_inuse_foot(m, newp, psize);
chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
chunk_plus_offset(newp, psize + SIZE_T_SIZE)->head = 0;
if (cp < m->least_addr)
m->least_addr = cp;
if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint)
m->max_footprint = m->footprint;
check_mmapped_chunk(m, newp);
return newp;
}
}
return 0;
}
static void* prepend_alloc ( mstate  m,
char *  newbase,
char *  oldbase,
size_t  nb 
)
static

Definition at line 3345 of file SDL_malloc.c.

References align_as_chunk, assert, check_free_chunk, check_malloced_chunk, check_top_chunk, chunk2mem, chunk_plus_offset, chunksize, cinuse, insert_chunk, MIN_CHUNK_SIZE, pinuse, PINUSE_BIT, set_free_with_pinuse, set_size_and_pinuse_of_free_chunk, set_size_and_pinuse_of_inuse_chunk, and unlink_chunk.

Referenced by sys_alloc().

{
mchunkptr p = align_as_chunk(newbase);
mchunkptr oldfirst = align_as_chunk(oldbase);
size_t psize = (char *) oldfirst - (char *) p;
mchunkptr q = chunk_plus_offset(p, nb);
size_t qsize = psize - nb;
set_size_and_pinuse_of_inuse_chunk(m, p, nb);
assert((char *) oldfirst > (char *) q);
assert(pinuse(oldfirst));
assert(qsize >= MIN_CHUNK_SIZE);
/* consolidate remainder with first chunk of old base */
if (oldfirst == m->top) {
size_t tsize = m->topsize += qsize;
m->top = q;
q->head = tsize | PINUSE_BIT;
check_top_chunk(m, q);
} else if (oldfirst == m->dv) {
size_t dsize = m->dvsize += qsize;
m->dv = q;
set_size_and_pinuse_of_free_chunk(q, dsize);
} else {
if (!cinuse(oldfirst)) {
size_t nsize = chunksize(oldfirst);
unlink_chunk(m, oldfirst, nsize);
oldfirst = chunk_plus_offset(oldfirst, nsize);
qsize += nsize;
}
set_free_with_pinuse(q, qsize, oldfirst);
insert_chunk(m, q, qsize);
check_free_chunk(m, q);
}
check_malloced_chunk(m, chunk2mem(p), nb);
return chunk2mem(p);
}
static size_t release_unused_segments ( mstate  m)
static

Definition at line 3644 of file SDL_malloc.c.

References align_as_chunk, assert, msegmentptr::base, CALL_MUNMAP, chunksize, cinuse, insert_large_chunk, is_extern_segment, is_mmapped_segment, msegmentptr::next, segment_holds, TOP_FOOT_SIZE, and unlink_large_chunk.

Referenced by sys_trim().

{
size_t released = 0;
msegmentptr pred = &m->seg;
msegmentptr sp = pred->next;
while (sp != 0) {
char *base = sp->base;
size_t size = sp->size;
msegmentptr next = sp->next;
if (is_mmapped_segment(sp) && !is_extern_segment(sp)) {
mchunkptr p = align_as_chunk(base);
size_t psize = chunksize(p);
/* Can unmap if first chunk holds entire segment and not pinned */
if (!cinuse(p)
&& (char *) p + psize >= base + size - TOP_FOOT_SIZE) {
tchunkptr tp = (tchunkptr) p;
assert(segment_holds(sp, (char *) sp));
if (p == m->dv) {
m->dv = 0;
m->dvsize = 0;
} else {
unlink_large_chunk(m, tp);
}
if (CALL_MUNMAP(base, size) == 0) {
released += size;
m->footprint -= size;
/* unlink obsoleted record */
sp = pred;
sp->next = next;
} else { /* back out if cannot unmap */
insert_large_chunk(m, tp, psize);
}
}
}
pred = sp;
sp = next;
}
return released;
}
void* SDL_calloc ( size_t  nmemb,
size_t  size 
)

Definition at line 5335 of file SDL_malloc.c.

References s_mem, and SDL_AtomicIncRef.

{
void *mem;
if (!nmemb || !size) {
nmemb = 1;
size = 1;
}
mem = s_mem.calloc_func(nmemb, size);
if (mem) {
SDL_AtomicIncRef(&s_mem.num_allocations);
}
return mem;
}
void SDL_free ( void *  ptr)

Definition at line 5366 of file SDL_malloc.c.

References s_mem, SDL_AtomicDecRef, and void.

{
if (!ptr) {
return;
}
s_mem.free_func(ptr);
(void)SDL_AtomicDecRef(&s_mem.num_allocations);
}
void SDL_GetMemoryFunctions ( SDL_malloc_func *  malloc_func,
SDL_calloc_func *  calloc_func,
SDL_realloc_func *  realloc_func,
SDL_free_func *  free_func 
)

Get the current set of SDL memory functions.

Definition at line 5271 of file SDL_malloc.c.

References s_mem.

{
if (malloc_func) {
*malloc_func = s_mem.malloc_func;
}
if (calloc_func) {
*calloc_func = s_mem.calloc_func;
}
if (realloc_func) {
*realloc_func = s_mem.realloc_func;
}
if (free_func) {
*free_func = s_mem.free_func;
}
}
int SDL_GetNumAllocations ( void  )

Get the number of outstanding (unfreed) allocations.

Definition at line 5315 of file SDL_malloc.c.

References s_mem, and SDL_AtomicGet.

{
return SDL_AtomicGet(&s_mem.num_allocations);
}
void* SDL_malloc ( size_t  size)

Definition at line 5320 of file SDL_malloc.c.

References s_mem, and SDL_AtomicIncRef.

{
void *mem;
if (!size) {
size = 1;
}
mem = s_mem.malloc_func(size);
if (mem) {
SDL_AtomicIncRef(&s_mem.num_allocations);
}
return mem;
}
void* SDL_realloc ( void *  ptr,
size_t  size 
)

Definition at line 5351 of file SDL_malloc.c.

References s_mem, and SDL_AtomicIncRef.

{
void *mem;
if (!ptr && !size) {
size = 1;
}
mem = s_mem.realloc_func(ptr, size);
if (mem && !ptr) {
SDL_AtomicIncRef(&s_mem.num_allocations);
}
return mem;
}
int SDL_SetMemoryFunctions ( SDL_malloc_func  malloc_func,
SDL_calloc_func  calloc_func,
SDL_realloc_func  realloc_func,
SDL_free_func  free_func 
)

Replace SDL's memory allocation functions with a custom set.

Note
If you are replacing SDL's memory functions, you should call SDL_GetNumAllocations() and be very careful if it returns non-zero. That means that your free function will be called with memory allocated by the previous memory allocation functions.

Definition at line 5290 of file SDL_malloc.c.

References calloc_func, free_func, malloc_func, realloc_func, s_mem, and SDL_InvalidParamError.

{
if (!malloc_func) {
return SDL_InvalidParamError("malloc_func");
}
if (!calloc_func) {
return SDL_InvalidParamError("calloc_func");
}
if (!realloc_func) {
return SDL_InvalidParamError("realloc_func");
}
if (!free_func) {
return SDL_InvalidParamError("free_func");
}
s_mem.malloc_func = malloc_func;
s_mem.calloc_func = calloc_func;
s_mem.realloc_func = realloc_func;
s_mem.free_func = free_func;
return 0;
}
static msegmentptr segment_holding ( mstate  m,
char *  addr 
)
static

Definition at line 2133 of file SDL_malloc.c.

Referenced by add_segment(), sys_alloc(), and sys_trim().

{
msegmentptr sp = &m->seg;
for (;;) {
if (addr >= sp->base && addr < sp->base + sp->size)
return sp;
if ((sp = sp->next) == 0)
return 0;
}
}
static void* sys_alloc ( mstate  m,
size_t  nb 
)
static

Definition at line 3444 of file SDL_malloc.c.

References ACQUIRE_MORECORE_LOCK, add_segment(), CALL_MMAP, CALL_MORECORE, check_malloced_chunk, check_top_chunk, chunk2mem, chunk_plus_offset, CMFAIL, disable_contiguous, granularity_align, HALF_MAX_SIZE_T, HAVE_MMAP, HAVE_MORECORE, init_bins(), init_mparams(), init_top(), is_extern_segment, is_global, is_initialized, IS_MMAPPED_BIT, is_page_aligned, malloc_params::magic, MALLOC_ALIGNMENT, MALLOC_FAILURE_ACTION, mem2chunk, mmap_alloc(), malloc_params::mmap_threshold, MORECORE_CONTIGUOUS, mparams, msegmentptr::next, next_chunk, page_align, PINUSE_BIT, prepend_alloc(), RELEASE_MORECORE_LOCK, segment_holding(), segment_holds, set_size_and_pinuse_of_inuse_chunk, msegmentptr::size, SIZE_T_ONE, TOP_FOOT_SIZE, use_mmap, and use_noncontiguous.

Referenced by dlmalloc().

{
char *tbase = CMFAIL;
size_t tsize = 0;
flag_t mmap_flag = 0;
init_mparams();
/* Directly map large chunks */
if (use_mmap(m) && nb >= mparams.mmap_threshold) {
void *mem = mmap_alloc(m, nb);
if (mem != 0)
return mem;
}
/*
Try getting memory in any of three ways (in most-preferred to
least-preferred order):
1. A call to MORECORE that can normally contiguously extend memory.
(disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or
or main space is mmapped or a previous contiguous call failed)
2. A call to MMAP new space (disabled if not HAVE_MMAP).
Note that under the default settings, if MORECORE is unable to
fulfill a request, and HAVE_MMAP is true, then mmap is
used as a noncontiguous system allocator. This is a useful backup
strategy for systems with holes in address spaces -- in this case
sbrk cannot contiguously expand the heap, but mmap may be able to
find space.
3. A call to MORECORE that cannot usually contiguously extend memory.
(disabled if not HAVE_MORECORE)
*/
if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) {
char *br = CMFAIL;
msegmentptr ss =
(m->top == 0) ? 0 : segment_holding(m, (char *) m->top);
size_t asize = 0;
ACQUIRE_MORECORE_LOCK();
if (ss == 0) { /* First time through or recovery */
char *base = (char *) CALL_MORECORE(0);
if (base != CMFAIL) {
asize =
granularity_align(nb + TOP_FOOT_SIZE + MALLOC_ALIGNMENT +
SIZE_T_ONE);
/* Adjust to end on a page boundary */
if (!is_page_aligned(base))
asize += (page_align((size_t) base) - (size_t) base);
/* Can't call MORECORE if size is negative when treated as signed */
if (asize < HALF_MAX_SIZE_T &&
(br = (char *) (CALL_MORECORE(asize))) == base) {
tbase = base;
tsize = asize;
}
}
} else {
/* Subtract out existing available top space from MORECORE request. */
asize =
granularity_align(nb - m->topsize + TOP_FOOT_SIZE +
MALLOC_ALIGNMENT + SIZE_T_ONE);
/* Use mem here only if it did continuously extend old space */
if (asize < HALF_MAX_SIZE_T &&
(br =
(char *) (CALL_MORECORE(asize))) == ss->base + ss->size) {
tbase = br;
tsize = asize;
}
}
if (tbase == CMFAIL) { /* Cope with partial failure */
if (br != CMFAIL) { /* Try to use/extend the space we did get */
if (asize < HALF_MAX_SIZE_T &&
asize < nb + TOP_FOOT_SIZE + SIZE_T_ONE) {
size_t esize =
granularity_align(nb + TOP_FOOT_SIZE +
MALLOC_ALIGNMENT + SIZE_T_ONE -
asize);
if (esize < HALF_MAX_SIZE_T) {
char *end = (char *) CALL_MORECORE(esize);
if (end != CMFAIL)
asize += esize;
else { /* Can't use; try to release */
end = (char *) CALL_MORECORE(-asize);
br = CMFAIL;
}
}
}
}
if (br != CMFAIL) { /* Use the space we did get */
tbase = br;
tsize = asize;
} else
disable_contiguous(m); /* Don't try contiguous path in the future */
}
RELEASE_MORECORE_LOCK();
}
if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */
size_t req = nb + TOP_FOOT_SIZE + MALLOC_ALIGNMENT + SIZE_T_ONE;
size_t rsize = granularity_align(req);
if (rsize > nb) { /* Fail if wraps around zero */
char *mp = (char *) (CALL_MMAP(rsize));
if (mp != CMFAIL) {
tbase = mp;
tsize = rsize;
mmap_flag = IS_MMAPPED_BIT;
}
}
}
if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */
size_t asize =
granularity_align(nb + TOP_FOOT_SIZE + MALLOC_ALIGNMENT +
SIZE_T_ONE);
if (asize < HALF_MAX_SIZE_T) {
char *br = CMFAIL;
char *end = CMFAIL;
ACQUIRE_MORECORE_LOCK();
br = (char *) (CALL_MORECORE(asize));
end = (char *) (CALL_MORECORE(0));
RELEASE_MORECORE_LOCK();
if (br != CMFAIL && end != CMFAIL && br < end) {
size_t ssize = end - br;
if (ssize > nb + TOP_FOOT_SIZE) {
tbase = br;
tsize = ssize;
}
}
}
}
if (tbase != CMFAIL) {
if ((m->footprint += tsize) > m->max_footprint)
m->max_footprint = m->footprint;
if (!is_initialized(m)) { /* first-time initialization */
m->seg.base = m->least_addr = tbase;
m->seg.size = tsize;
m->seg.sflags = mmap_flag;
m->magic = mparams.magic;
init_bins(m);
if (is_global(m))
init_top(m, (mchunkptr) tbase, tsize - TOP_FOOT_SIZE);
else {
/* Offset top by embedded malloc_state */
mchunkptr mn = next_chunk(mem2chunk(m));
init_top(m, mn,
(size_t) ((tbase + tsize) - (char *) mn) -
TOP_FOOT_SIZE);
}
}
else {
/* Try to merge with an existing segment */
msegmentptr sp = &m->seg;
while (sp != 0 && tbase != sp->base + sp->size)
sp = sp->next;
if (sp != 0 && !is_extern_segment(sp) && (sp->sflags & IS_MMAPPED_BIT) == mmap_flag && segment_holds(sp, m->top)) { /* append */
sp->size += tsize;
init_top(m, m->top, m->topsize + tsize);
} else {
if (tbase < m->least_addr)
m->least_addr = tbase;
sp = &m->seg;
while (sp != 0 && sp->base != tbase + tsize)
sp = sp->next;
if (sp != 0 &&
!is_extern_segment(sp) &&
(sp->sflags & IS_MMAPPED_BIT) == mmap_flag) {
char *oldbase = sp->base;
sp->base = tbase;
sp->size += tsize;
return prepend_alloc(m, tbase, oldbase, nb);
} else
add_segment(m, tbase, tsize, mmap_flag);
}
}
if (nb < m->topsize) { /* Allocate from new or extended top space */
size_t rsize = m->topsize -= nb;
mchunkptr p = m->top;
mchunkptr r = m->top = chunk_plus_offset(p, nb);
r->head = rsize | PINUSE_BIT;
set_size_and_pinuse_of_inuse_chunk(m, p, nb);
check_top_chunk(m, m->top);
check_malloced_chunk(m, chunk2mem(p), nb);
return chunk2mem(p);
}
}
MALLOC_FAILURE_ACTION;
return 0;
}
static int sys_trim ( mstate  m,
size_t  pad 
)
static

Definition at line 3685 of file SDL_malloc.c.

References ACQUIRE_MORECORE_LOCK, CALL_MORECORE, CALL_MREMAP, CALL_MUNMAP, check_top_chunk, CMFAIL, malloc_params::granularity, HALF_MAX_SIZE_T, has_segment_link(), HAVE_MMAP, HAVE_MORECORE, init_top(), is_extern_segment, is_initialized, is_mmapped_segment, MAX_REQUEST, MAX_SIZE_T, MFAIL, mparams, RELEASE_MORECORE_LOCK, release_unused_segments(), segment_holding(), SIZE_T_ONE, and TOP_FOOT_SIZE.

Referenced by dlfree(), and dlmalloc_trim().

{
size_t released = 0;
if (pad < MAX_REQUEST && is_initialized(m)) {
pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
if (m->topsize > pad) {
/* Shrink top space in granularity-size units, keeping at least one */
size_t unit = mparams.granularity;
size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
SIZE_T_ONE) * unit;
msegmentptr sp = segment_holding(m, (char *) m->top);
if (!is_extern_segment(sp)) {
if (is_mmapped_segment(sp)) {
if (HAVE_MMAP && sp->size >= extra && !has_segment_link(m, sp)) { /* can't shrink if pinned */
size_t newsize = sp->size - extra;
/* Prefer mremap, fall back to munmap */
if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) !=
MFAIL)
|| (CALL_MUNMAP(sp->base + newsize, extra) == 0)) {
released = extra;
}
}
} else if (HAVE_MORECORE) {
if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */
extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit;
ACQUIRE_MORECORE_LOCK();
{
/* Make sure end of memory is where we last set it. */
char *old_br = (char *) (CALL_MORECORE(0));
if (old_br == sp->base + sp->size) {
char *rel_br = (char *) (CALL_MORECORE(-extra));
char *new_br = (char *) (CALL_MORECORE(0));
if (rel_br != CMFAIL && new_br < old_br)
released = old_br - new_br;
}
}
RELEASE_MORECORE_LOCK();
}
}
if (released != 0) {
sp->size -= released;
m->footprint -= released;
init_top(m, m->top, m->topsize - released);
check_top_chunk(m, m->top);
}
}
/* Unmap any unused mmapped segments */
if (HAVE_MMAP)
released += release_unused_segments(m);
/* On failure, disable autotrim to avoid repeated failed future calls */
if (released == 0)
m->trim_check = MAX_SIZE_T;
}
return (released != 0) ? 1 : 0;
}
static void* tmalloc_large ( mstate  m,
size_t  nb 
)
static

Definition at line 3751 of file SDL_malloc.c.

References assert, chunk2mem, chunk_plus_offset, chunksize, compute_bit2idx, compute_tree_index, CORRUPTION_ERROR_ACTION, i, idx2bit, insert_chunk, least_bit, left_bits, leftmost_child, leftshift_for_tree_index, MIN_CHUNK_SIZE, ok_address, ok_next, RTCHECK, set_inuse_and_pinuse, set_size_and_pinuse_of_free_chunk, set_size_and_pinuse_of_inuse_chunk, SIZE_T_BITSIZE, SIZE_T_ONE, treebin_at, and unlink_large_chunk.

Referenced by dlmalloc().

{
tchunkptr v = 0;
size_t rsize = -nb; /* Unsigned negation */
tchunkptr t;
bindex_t idx;
compute_tree_index(nb, idx);
if ((t = *treebin_at(m, idx)) != 0) {
/* Traverse tree for this bin looking for node with size == nb */
size_t sizebits = nb << leftshift_for_tree_index(idx);
tchunkptr rst = 0; /* The deepest untaken right subtree */
for (;;) {
tchunkptr rt;
size_t trem = chunksize(t) - nb;
if (trem < rsize) {
v = t;
if ((rsize = trem) == 0)
break;
}
rt = t->child[1];
t = t->child[(sizebits >> (SIZE_T_BITSIZE - SIZE_T_ONE)) & 1];
if (rt != 0 && rt != t)
rst = rt;
if (t == 0) {
t = rst; /* set t to least subtree holding sizes > nb */
break;
}
sizebits <<= 1;
}
}
if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */
binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap;
if (leftbits != 0) {
bindex_t i;
binmap_t leastbit = least_bit(leftbits);
compute_bit2idx(leastbit, i);
t = *treebin_at(m, i);
}
}
while (t != 0) { /* find smallest of tree or subtree */
size_t trem = chunksize(t) - nb;
if (trem < rsize) {
rsize = trem;
v = t;
}
t = leftmost_child(t);
}
/* If dv is a better fit, return 0 so malloc will use it */
if (v != 0 && rsize < (size_t) (m->dvsize - nb)) {
if (RTCHECK(ok_address(m, v))) { /* split */
mchunkptr r = chunk_plus_offset(v, nb);
assert(chunksize(v) == rsize + nb);
if (RTCHECK(ok_next(v, r))) {
unlink_large_chunk(m, v);
if (rsize < MIN_CHUNK_SIZE)
set_inuse_and_pinuse(m, v, (rsize + nb));
else {
set_size_and_pinuse_of_inuse_chunk(m, v, nb);
set_size_and_pinuse_of_free_chunk(r, rsize);
insert_chunk(m, r, rsize);
}
return chunk2mem(v);
}
}
CORRUPTION_ERROR_ACTION(m);
}
return 0;
}
static void* tmalloc_small ( mstate  m,
size_t  nb 
)
static

Definition at line 3826 of file SDL_malloc.c.

References assert, chunk2mem, chunk_plus_offset, chunksize, compute_bit2idx, CORRUPTION_ERROR_ACTION, i, least_bit, leftmost_child, MIN_CHUNK_SIZE, ok_address, ok_next, replace_dv, RTCHECK, set_inuse_and_pinuse, set_size_and_pinuse_of_free_chunk, set_size_and_pinuse_of_inuse_chunk, treebin_at, and unlink_large_chunk.

Referenced by dlmalloc().

{
tchunkptr t, v;
size_t rsize;
bindex_t i;
binmap_t leastbit = least_bit(m->treemap);
compute_bit2idx(leastbit, i);
v = t = *treebin_at(m, i);
rsize = chunksize(t) - nb;
while ((t = leftmost_child(t)) != 0) {
size_t trem = chunksize(t) - nb;
if (trem < rsize) {
rsize = trem;
v = t;
}
}
if (RTCHECK(ok_address(m, v))) {
mchunkptr r = chunk_plus_offset(v, nb);
assert(chunksize(v) == rsize + nb);
if (RTCHECK(ok_next(v, r))) {
unlink_large_chunk(m, v);
if (rsize < MIN_CHUNK_SIZE)
set_inuse_and_pinuse(m, v, (rsize + nb));
else {
set_size_and_pinuse_of_inuse_chunk(m, v, nb);
set_size_and_pinuse_of_free_chunk(r, rsize);
replace_dv(m, r, rsize);
}
return chunk2mem(v);
}
}
CORRUPTION_ERROR_ACTION(m);
return 0;
}
static int win32_acquire_lock ( MLOCK_T *  sl)
static

Definition at line 1473 of file SDL_malloc.c.

{
for (;;) {
#ifdef InterlockedCompareExchangePointer
if (!InterlockedCompareExchange(sl, 1, 0))
return 0;
#else /* Use older void* version */
if (!InterlockedCompareExchange((void **) sl, (void *) 1, (void *) 0))
return 0;
#endif /* InterlockedCompareExchangePointer */
Sleep(0);
}
}
static void win32_release_lock ( MLOCK_T *  sl)
static

Definition at line 1488 of file SDL_malloc.c.

{
InterlockedExchange(sl, 0);
}
static void* win32direct_mmap ( size_t  size)
static

Definition at line 1381 of file SDL_malloc.c.

References MFAIL.

{
void *ptr = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
PAGE_READWRITE);
return (ptr != 0) ? ptr : MFAIL;
}
static void* win32mmap ( size_t  size)
static

Definition at line 1372 of file SDL_malloc.c.

References MFAIL.

{
void *ptr =
VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
return (ptr != 0) ? ptr : MFAIL;
}
static int win32munmap ( void *  ptr,
size_t  size 
)
static

Definition at line 1390 of file SDL_malloc.c.

{
MEMORY_BASIC_INFORMATION minfo;
char *cptr = ptr;
while (size) {
if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
return -1;
if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
minfo.State != MEM_COMMIT || minfo.RegionSize > size)
return -1;
if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
return -1;
cptr += minfo.RegionSize;
size -= minfo.RegionSize;
}
return 0;
}

Variable Documentation

struct malloc_state _gm_
static

Definition at line 2089 of file SDL_malloc.c.

SDL_calloc_func calloc_func

Definition at line 5263 of file SDL_malloc.c.

Referenced by SDL_SetMemoryFunctions().

SDL_free_func free_func

Definition at line 5265 of file SDL_malloc.c.

Referenced by SDL_SetMemoryFunctions().

MLOCK_T magic_init_mutex
static

Definition at line 1499 of file SDL_malloc.c.

SDL_malloc_func malloc_func

Definition at line 5262 of file SDL_malloc.c.

Referenced by SDL_SetMemoryFunctions().

struct malloc_params mparams
static

Definition at line 2086 of file SDL_malloc.c.

Referenced by change_mparam(), dlpvalloc(), dlvalloc(), init_mparams(), init_top(), mmap_resize(), sys_alloc(), and sys_trim().

SDL_atomic_t num_allocations

Definition at line 5266 of file SDL_malloc.c.

SDL_realloc_func realloc_func

Definition at line 5264 of file SDL_malloc.c.

Referenced by SDL_SetMemoryFunctions().

struct { ... } s_mem

Referenced by SDL_calloc(), SDL_free(), SDL_GetMemoryFunctions(), SDL_GetNumAllocations(), SDL_malloc(), SDL_realloc(), and SDL_SetMemoryFunctions().