SDL  2.0
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

voiddlmalloc (size_t)
 
void dlfree (void *)
 
voiddlcalloc (size_t, size_t)
 
voiddlrealloc (void *, size_t)
 
voiddlmemalign (size_t, size_t)
 
voiddlvalloc (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 **)
 
voiddlpvalloc (size_t)
 
int dlmalloc_trim (size_t)
 
size_t dlmalloc_usable_size (void *)
 
void dlmalloc_stats (void)
 
static voidwin32mmap (size_t size)
 
static voidwin32direct_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 voidmmap_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 voidprepend_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 voidsys_alloc (mstate m, size_t nb)
 
static size_t release_unused_segments (mstate m)
 
static int sys_trim (mstate m, size_t pad)
 
static voidtmalloc_large (mstate m, size_t nb)
 
static voidtmalloc_small (mstate m, size_t nb)
 
static voidinternal_realloc (mstate m, void *oldmem, size_t bytes)
 
static voidinternal_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. More...
 
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. More...
 
int SDL_GetNumAllocations (void)
 Get the number of outstanding (unfreed) allocations. More...
 
voidSDL_malloc (size_t size)
 
voidSDL_calloc (size_t nmemb, size_t size)
 
voidSDL_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

◆ ABORT

#define ABORT

Definition at line 39 of file SDL_malloc.c.

◆ ABORT_ON_ASSERT_FAILURE

#define ABORT_ON_ASSERT_FAILURE   1

Definition at line 540 of file SDL_malloc.c.

◆ ACQUIRE_LOCK

#define ACQUIRE_LOCK (   l)    win32_acquire_lock(l)

Definition at line 1494 of file SDL_malloc.c.

◆ ACQUIRE_MAGIC_INIT_LOCK

#define ACQUIRE_MAGIC_INIT_LOCK ( )    ACQUIRE_LOCK(&magic_init_mutex);

Definition at line 1517 of file SDL_malloc.c.

◆ ACQUIRE_MORECORE_LOCK

#define ACQUIRE_MORECORE_LOCK ( )

Definition at line 1512 of file SDL_malloc.c.

◆ align_as_chunk

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

Definition at line 1700 of file SDL_malloc.c.

◆ align_offset

#define align_offset (   A)
Value:

Definition at line 1317 of file SDL_malloc.c.

◆ assert

#define assert (   x)

Definition at line 1219 of file SDL_malloc.c.

◆ bit_for_tree_index

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

◆ CALL_MMAP

#define CALL_MMAP (   s)    win32mmap(s)

Definition at line 1408 of file SDL_malloc.c.

◆ CALL_MORECORE

#define CALL_MORECORE (   S)    MFAIL

Definition at line 1423 of file SDL_malloc.c.

◆ CALL_MREMAP

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

Definition at line 1417 of file SDL_malloc.c.

◆ CALL_MUNMAP

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

Definition at line 1409 of file SDL_malloc.c.

◆ calloc_must_clear

#define calloc_must_clear (   p)    (1)

Definition at line 1774 of file SDL_malloc.c.

◆ check_free_chunk

#define check_free_chunk (   M,
 
)

Definition at line 2234 of file SDL_malloc.c.

◆ check_inuse_chunk

#define check_inuse_chunk (   M,
 
)

Definition at line 2235 of file SDL_malloc.c.

◆ check_malloc_state

#define check_malloc_state (   M)

Definition at line 2238 of file SDL_malloc.c.

◆ check_malloced_chunk

#define check_malloced_chunk (   M,
  P,
 
)

Definition at line 2236 of file SDL_malloc.c.

◆ check_mmapped_chunk

#define check_mmapped_chunk (   M,
 
)

Definition at line 2237 of file SDL_malloc.c.

◆ check_top_chunk

#define check_top_chunk (   M,
 
)

Definition at line 2239 of file SDL_malloc.c.

◆ chunk2mem

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

Definition at line 1697 of file SDL_malloc.c.

◆ CHUNK_ALIGN_MASK

#define CHUNK_ALIGN_MASK   (MALLOC_ALIGNMENT - SIZE_T_ONE)

Definition at line 1311 of file SDL_malloc.c.

◆ chunk_minus_offset

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

Definition at line 1742 of file SDL_malloc.c.

◆ CHUNK_OVERHEAD

#define CHUNK_OVERHEAD   (SIZE_T_SIZE)

Definition at line 1684 of file SDL_malloc.c.

◆ chunk_plus_offset

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

Definition at line 1741 of file SDL_malloc.c.

◆ chunksize

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

Definition at line 1735 of file SDL_malloc.c.

◆ cinuse

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

Definition at line 1733 of file SDL_malloc.c.

◆ CINUSE_BIT

#define CINUSE_BIT   (SIZE_T_TWO)

Definition at line 1726 of file SDL_malloc.c.

◆ clear_cinuse

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

Definition at line 1738 of file SDL_malloc.c.

◆ clear_pinuse

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

Definition at line 1737 of file SDL_malloc.c.

◆ clear_smallmap

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

Definition at line 2331 of file SDL_malloc.c.

◆ clear_treemap

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

Definition at line 2335 of file SDL_malloc.c.

◆ CMFAIL

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

Definition at line 1332 of file SDL_malloc.c.

◆ compute_bit2idx

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

Definition at line 2353 of file SDL_malloc.c.

◆ compute_tree_index

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

Definition at line 2290 of file SDL_malloc.c.

◆ CORRUPTION_ERROR_ACTION

#define CORRUPTION_ERROR_ACTION (   m)    ABORT

Definition at line 2221 of file SDL_malloc.c.

◆ DEFAULT_GRANULARITY

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

Definition at line 588 of file SDL_malloc.c.

◆ DEFAULT_MMAP_THRESHOLD

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

Definition at line 600 of file SDL_malloc.c.

◆ DEFAULT_TRIM_THRESHOLD

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

Definition at line 593 of file SDL_malloc.c.

◆ DIRECT_MMAP

#define DIRECT_MMAP (   s)    win32direct_mmap(s)

Definition at line 1410 of file SDL_malloc.c.

◆ disable_contiguous

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

Definition at line 2107 of file SDL_malloc.c.

◆ disable_lock

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

Definition at line 2100 of file SDL_malloc.c.

◆ disable_mmap

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

Definition at line 2104 of file SDL_malloc.c.

◆ enable_lock

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

Definition at line 2099 of file SDL_malloc.c.

◆ enable_mmap

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

Definition at line 2103 of file SDL_malloc.c.

◆ EXTERN_BIT

#define EXTERN_BIT   (8U)

Definition at line 1430 of file SDL_malloc.c.

◆ FENCEPOST_HEAD

#define FENCEPOST_HEAD   (INUSE_BITS|SIZE_T_SIZE)

Definition at line 1730 of file SDL_malloc.c.

◆ fm

#define fm   gm

◆ FOOTERS

#define FOOTERS   0

Definition at line 534 of file SDL_malloc.c.

◆ FOUR_SIZE_T_SIZES

#define FOUR_SIZE_T_SIZES   (SIZE_T_SIZE<<2)

Definition at line 1306 of file SDL_malloc.c.

◆ get_foot

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

Definition at line 1752 of file SDL_malloc.c.

◆ GLOBALLY_INITIALIZE

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

Definition at line 2183 of file SDL_malloc.c.

◆ gm

#define gm   (&_gm_)

Definition at line 2090 of file SDL_malloc.c.

◆ granularity_align

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

Definition at line 2119 of file SDL_malloc.c.

◆ HALF_MAX_SIZE_T

#define HALF_MAX_SIZE_T   (MAX_SIZE_T / 2U)

Definition at line 1308 of file SDL_malloc.c.

◆ HAVE_MMAP

#define HAVE_MMAP   1

Definition at line 491 of file SDL_malloc.c.

◆ HAVE_MORECORE

#define HAVE_MORECORE   0

Definition at line 492 of file SDL_malloc.c.

◆ HAVE_MREMAP

#define HAVE_MREMAP   0

Definition at line 561 of file SDL_malloc.c.

◆ idx2bit

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

Definition at line 2327 of file SDL_malloc.c.

◆ INITIAL_LOCK

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

Definition at line 1493 of file SDL_malloc.c.

◆ INSECURE

#define INSECURE   0

Definition at line 549 of file SDL_malloc.c.

◆ insert_chunk

#define insert_chunk (   M,
  P,
 
)
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.

◆ insert_large_chunk

#define insert_large_chunk (   M,
  X,
 
)

Definition at line 3045 of file SDL_malloc.c.

◆ insert_small_chunk

#define insert_small_chunk (   M,
  P,
 
)
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.

◆ internal_free

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

Definition at line 3208 of file SDL_malloc.c.

◆ internal_malloc

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

Definition at line 3207 of file SDL_malloc.c.

◆ INUSE_BITS

#define INUSE_BITS   (PINUSE_BIT|CINUSE_BIT)

Definition at line 1727 of file SDL_malloc.c.

◆ is_aligned

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

Definition at line 1314 of file SDL_malloc.c.

◆ is_extern_segment

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

Definition at line 1954 of file SDL_malloc.c.

◆ is_global

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

Definition at line 2091 of file SDL_malloc.c.

◆ is_granularity_aligned

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

Definition at line 2124 of file SDL_malloc.c.

◆ is_initialized

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

Definition at line 2092 of file SDL_malloc.c.

◆ is_mmapped

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

Definition at line 1763 of file SDL_malloc.c.

◆ IS_MMAPPED_BIT

#define IS_MMAPPED_BIT   (SIZE_T_ONE)

Definition at line 1342 of file SDL_malloc.c.

◆ is_mmapped_segment

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

Definition at line 1953 of file SDL_malloc.c.

◆ is_page_aligned

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

Definition at line 2122 of file SDL_malloc.c.

◆ is_small

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

Definition at line 2265 of file SDL_malloc.c.

◆ LACKS_ERRNO_H

#define LACKS_ERRNO_H

Definition at line 499 of file SDL_malloc.c.

◆ LACKS_FCNTL_H

#define LACKS_FCNTL_H

Definition at line 500 of file SDL_malloc.c.

◆ LACKS_STDIO_H

#define LACKS_STDIO_H

Definition at line 35 of file SDL_malloc.c.

◆ LACKS_STDLIB_H

#define LACKS_STDLIB_H

Definition at line 38 of file SDL_malloc.c.

◆ LACKS_STRING_H [1/2]

#define LACKS_STRING_H

Definition at line 496 of file SDL_malloc.c.

◆ LACKS_STRING_H [2/2]

#define LACKS_STRING_H

Definition at line 496 of file SDL_malloc.c.

◆ LACKS_STRINGS_H [1/2]

#define LACKS_STRINGS_H

Definition at line 497 of file SDL_malloc.c.

◆ LACKS_STRINGS_H [2/2]

#define LACKS_STRINGS_H

Definition at line 497 of file SDL_malloc.c.

◆ LACKS_SYS_MMAN_H

#define LACKS_SYS_MMAN_H

Definition at line 495 of file SDL_malloc.c.

◆ LACKS_SYS_PARAM_H

#define LACKS_SYS_PARAM_H

Definition at line 494 of file SDL_malloc.c.

◆ LACKS_SYS_TYPES_H [1/2]

#define LACKS_SYS_TYPES_H

Definition at line 498 of file SDL_malloc.c.

◆ LACKS_SYS_TYPES_H [2/2]

#define LACKS_SYS_TYPES_H

Definition at line 498 of file SDL_malloc.c.

◆ LACKS_UNISTD_H

#define LACKS_UNISTD_H

Definition at line 493 of file SDL_malloc.c.

◆ least_bit

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

Definition at line 2368 of file SDL_malloc.c.

◆ left_bits

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

Definition at line 2371 of file SDL_malloc.c.

◆ leftmost_child

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

Definition at line 1886 of file SDL_malloc.c.

◆ leftshift_for_tree_index

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

Definition at line 2314 of file SDL_malloc.c.

◆ M_GRANULARITY

#define M_GRANULARITY   (-2)

Definition at line 633 of file SDL_malloc.c.

◆ M_MMAP_THRESHOLD

#define M_MMAP_THRESHOLD   (-3)

Definition at line 634 of file SDL_malloc.c.

◆ M_TRIM_THRESHOLD

#define M_TRIM_THRESHOLD   (-1)

Definition at line 632 of file SDL_malloc.c.

◆ MALLINFO_FIELD_TYPE

#define MALLINFO_FIELD_TYPE   size_t

Definition at line 615 of file SDL_malloc.c.

◆ MALLOC_ALIGNMENT

#define MALLOC_ALIGNMENT   ((size_t)8U)

Definition at line 531 of file SDL_malloc.c.

◆ MALLOC_FAILURE_ACTION

#define MALLOC_FAILURE_ACTION

Definition at line 501 of file SDL_malloc.c.

◆ mark_inuse_foot

#define mark_inuse_foot (   M,
  p,
  s 
)

Definition at line 2445 of file SDL_malloc.c.

◆ mark_smallmap

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

Definition at line 2330 of file SDL_malloc.c.

◆ mark_treemap

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

Definition at line 2334 of file SDL_malloc.c.

◆ MAX_REQUEST

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

Definition at line 1703 of file SDL_malloc.c.

◆ MAX_SIZE_T

#define MAX_SIZE_T   (~(size_t)0)

Definition at line 518 of file SDL_malloc.c.

◆ MAX_SMALL_REQUEST

#define MAX_SMALL_REQUEST   (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)

Definition at line 2042 of file SDL_malloc.c.

◆ MAX_SMALL_SIZE

#define MAX_SMALL_SIZE   (MIN_LARGE_SIZE - SIZE_T_ONE)

Definition at line 2041 of file SDL_malloc.c.

◆ MCHUNK_SIZE

#define MCHUNK_SIZE   (sizeof(mchunk))

Definition at line 1679 of file SDL_malloc.c.

◆ mem2chunk

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

Definition at line 1698 of file SDL_malloc.c.

◆ memcpy

#define memcpy   SDL_memcpy

Definition at line 622 of file SDL_malloc.c.

◆ memset

#define memset   SDL_memset

Definition at line 619 of file SDL_malloc.c.

◆ MFAIL

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

Definition at line 1331 of file SDL_malloc.c.

◆ MIN_CHUNK_SIZE

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

Definition at line 1693 of file SDL_malloc.c.

◆ MIN_LARGE_SIZE

#define MIN_LARGE_SIZE   (SIZE_T_ONE << TREEBIN_SHIFT)

Definition at line 2040 of file SDL_malloc.c.

◆ MIN_REQUEST

#define MIN_REQUEST   (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)

Definition at line 1704 of file SDL_malloc.c.

◆ MIN_SMALL_INDEX

#define MIN_SMALL_INDEX   (small_index(MIN_CHUNK_SIZE))

Definition at line 2268 of file SDL_malloc.c.

◆ minsize_for_tree_index

#define minsize_for_tree_index (   i)
Value:
((SIZE_T_ONE << (((i) >> 1) + TREEBIN_SHIFT)) | \
(((size_t)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1)))

Definition at line 2319 of file SDL_malloc.c.

◆ MLOCK_T

#define MLOCK_T   long

Definition at line 1471 of file SDL_malloc.c.

◆ MMAP_CHUNK_OVERHEAD

#define MMAP_CHUNK_OVERHEAD   (TWO_SIZE_T_SIZES)

Definition at line 1688 of file SDL_malloc.c.

◆ MMAP_CLEARS

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

Definition at line 502 of file SDL_malloc.c.

◆ MMAP_FOOT_PAD

#define MMAP_FOOT_PAD   (FOUR_SIZE_T_SIZES)

Definition at line 1690 of file SDL_malloc.c.

◆ MORECORE_CONTIGUOUS

#define MORECORE_CONTIGUOUS   0

Definition at line 575 of file SDL_malloc.c.

◆ MSPACES

#define MSPACES   0

Definition at line 527 of file SDL_malloc.c.

◆ next_chunk

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

Definition at line 1745 of file SDL_malloc.c.

◆ next_pinuse

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

Definition at line 1749 of file SDL_malloc.c.

◆ NO_MALLINFO

#define NO_MALLINFO   0

Definition at line 612 of file SDL_malloc.c.

◆ NSMALLBINS

#define NSMALLBINS   (32U)

Definition at line 2035 of file SDL_malloc.c.

◆ NTREEBINS

#define NTREEBINS   (32U)

Definition at line 2036 of file SDL_malloc.c.

◆ ok_address

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

Definition at line 2407 of file SDL_malloc.c.

◆ ok_cinuse

#define ok_cinuse (   p)    cinuse(p)

Definition at line 2411 of file SDL_malloc.c.

◆ ok_magic

#define ok_magic (   M)    (1)

Definition at line 2426 of file SDL_malloc.c.

◆ ok_next

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

Definition at line 2409 of file SDL_malloc.c.

◆ ok_pinuse

#define ok_pinuse (   p)    pinuse(p)

Definition at line 2413 of file SDL_malloc.c.

◆ ONLY_MSPACES

#define ONLY_MSPACES   0

Definition at line 521 of file SDL_malloc.c.

◆ overhead_for

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

Definition at line 1767 of file SDL_malloc.c.

◆ pad_request

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

Definition at line 1707 of file SDL_malloc.c.

◆ page_align

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

Definition at line 2115 of file SDL_malloc.c.

◆ pinuse

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

Definition at line 1734 of file SDL_malloc.c.

◆ PINUSE_BIT

#define PINUSE_BIT   (SIZE_T_ONE)

Definition at line 1725 of file SDL_malloc.c.

◆ POSTACTION

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

Definition at line 2186 of file SDL_malloc.c.

◆ PREACTION

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

Definition at line 2185 of file SDL_malloc.c.

◆ prev_chunk

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

Definition at line 1746 of file SDL_malloc.c.

◆ PROCEED_ON_ERROR

#define PROCEED_ON_ERROR   0

Definition at line 543 of file SDL_malloc.c.

◆ real_calloc

#define real_calloc   dlcalloc

Definition at line 5254 of file SDL_malloc.c.

◆ real_free

#define real_free   dlfree

Definition at line 5256 of file SDL_malloc.c.

◆ real_malloc

#define real_malloc   dlmalloc

Definition at line 5253 of file SDL_malloc.c.

◆ real_realloc

#define real_realloc   dlrealloc

Definition at line 5255 of file SDL_malloc.c.

◆ RELEASE_LOCK

#define RELEASE_LOCK (   l)    win32_release_lock(l)

Definition at line 1495 of file SDL_malloc.c.

◆ RELEASE_MAGIC_INIT_LOCK

#define RELEASE_MAGIC_INIT_LOCK ( )    RELEASE_LOCK(&magic_init_mutex);

Definition at line 1518 of file SDL_malloc.c.

◆ RELEASE_MORECORE_LOCK

#define RELEASE_MORECORE_LOCK ( )

Definition at line 1513 of file SDL_malloc.c.

◆ replace_dv

#define replace_dv (   M,
  P,
 
)
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.

◆ request2size

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

Definition at line 1711 of file SDL_malloc.c.

◆ RTCHECK

#define RTCHECK (   e)    (e)

Definition at line 2435 of file SDL_malloc.c.

◆ same_or_left_bits

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

Definition at line 2374 of file SDL_malloc.c.

◆ segment_holds

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

Definition at line 2128 of file SDL_malloc.c.

◆ set_foot

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

Definition at line 1753 of file SDL_malloc.c.

◆ set_free_with_pinuse

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

◆ set_inuse

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

Definition at line 2448 of file SDL_malloc.c.

◆ set_inuse_and_pinuse

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

Definition at line 2453 of file SDL_malloc.c.

◆ set_lock

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

Definition at line 2109 of file SDL_malloc.c.

◆ set_size_and_pinuse_of_free_chunk

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

Definition at line 1756 of file SDL_malloc.c.

◆ set_size_and_pinuse_of_inuse_chunk

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

Definition at line 2458 of file SDL_malloc.c.

◆ should_trim

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

Definition at line 2158 of file SDL_malloc.c.

◆ SIX_SIZE_T_SIZES

#define SIX_SIZE_T_SIZES   (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)

Definition at line 1307 of file SDL_malloc.c.

◆ SIZE_T_BITSIZE

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

Definition at line 1298 of file SDL_malloc.c.

◆ SIZE_T_ONE

#define SIZE_T_ONE   ((size_t)1)

Definition at line 1303 of file SDL_malloc.c.

◆ SIZE_T_SIZE

#define SIZE_T_SIZE   (sizeof(size_t))

Definition at line 1297 of file SDL_malloc.c.

◆ SIZE_T_TWO

#define SIZE_T_TWO   ((size_t)2)

Definition at line 1304 of file SDL_malloc.c.

◆ SIZE_T_ZERO

#define SIZE_T_ZERO   ((size_t)0)

Definition at line 1302 of file SDL_malloc.c.

◆ small_index

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

Definition at line 2266 of file SDL_malloc.c.

◆ small_index2size

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

Definition at line 2267 of file SDL_malloc.c.

◆ smallbin_at

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

Definition at line 2271 of file SDL_malloc.c.

◆ SMALLBIN_SHIFT

#define SMALLBIN_SHIFT   (3U)

Definition at line 2037 of file SDL_malloc.c.

◆ SMALLBIN_WIDTH

#define SMALLBIN_WIDTH   (SIZE_T_ONE << SMALLBIN_SHIFT)

Definition at line 2038 of file SDL_malloc.c.

◆ smallmap_is_marked

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

Definition at line 2332 of file SDL_malloc.c.

◆ TOP_FOOT_SIZE

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

◆ treebin_at

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

Definition at line 2272 of file SDL_malloc.c.

◆ TREEBIN_SHIFT

#define TREEBIN_SHIFT   (8U)

Definition at line 2039 of file SDL_malloc.c.

◆ treemap_is_marked

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

Definition at line 2336 of file SDL_malloc.c.

◆ TWO_SIZE_T_SIZES

#define TWO_SIZE_T_SIZES   (SIZE_T_SIZE<<1)

Definition at line 1305 of file SDL_malloc.c.

◆ unlink_chunk

#define unlink_chunk (   M,
  P,
 
)
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.

◆ unlink_first_small_chunk

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

Definition at line 3013 of file SDL_malloc.c.

◆ unlink_large_chunk

#define unlink_large_chunk (   M,
 
)

Definition at line 3113 of file SDL_malloc.c.

◆ unlink_small_chunk

#define unlink_small_chunk (   M,
  P,
 
)
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.

◆ USAGE_ERROR_ACTION

#define USAGE_ERROR_ACTION (   m,
  p 
)    ABORT

Definition at line 2225 of file SDL_malloc.c.

◆ USE_BUILTIN_FFS

#define USE_BUILTIN_FFS   0

Definition at line 606 of file SDL_malloc.c.

◆ USE_DEV_RANDOM

#define USE_DEV_RANDOM   0

Definition at line 609 of file SDL_malloc.c.

◆ USE_DL_PREFIX

#define USE_DL_PREFIX

Definition at line 41 of file SDL_malloc.c.

◆ use_lock

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

Definition at line 2098 of file SDL_malloc.c.

◆ USE_LOCK_BIT

#define USE_LOCK_BIT   (2U)

Definition at line 1502 of file SDL_malloc.c.

◆ USE_LOCKS

#define USE_LOCKS   1

Definition at line 40 of file SDL_malloc.c.

◆ use_mmap

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

Definition at line 2102 of file SDL_malloc.c.

◆ USE_MMAP_BIT

#define USE_MMAP_BIT   (SIZE_T_ONE)

Definition at line 1343 of file SDL_malloc.c.

◆ use_noncontiguous

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

Definition at line 2106 of file SDL_malloc.c.

◆ USE_NONCONTIGUOUS_BIT

#define USE_NONCONTIGUOUS_BIT   (4U)

Definition at line 1427 of file SDL_malloc.c.

◆ WIN32

#define WIN32   1

Definition at line 485 of file SDL_malloc.c.

◆ WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 489 of file SDL_malloc.c.

Typedef Documentation

◆ bindex_t

typedef size_t bindex_t

Definition at line 1673 of file SDL_malloc.c.

◆ binmap_t

typedef unsigned int binmap_t

Definition at line 1674 of file SDL_malloc.c.

◆ flag_t

typedef unsigned int flag_t

Definition at line 1675 of file SDL_malloc.c.

Function Documentation

◆ add_segment()

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

Definition at line 3387 of file SDL_malloc.c.

3388 {
3389  /* Determine locations and sizes of segment, fenceposts, old top */
3390  char *old_top = (char *) m->top;
3391  msegmentptr oldsp = segment_holding(m, old_top);
3392  char *old_end = oldsp->base + oldsp->size;
3393  size_t ssize = pad_request(sizeof(struct malloc_segment));
3394  char *rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
3395  size_t offset = align_offset(chunk2mem(rawsp));
3396  char *asp = rawsp + offset;
3397  char *csp = (asp < (old_top + MIN_CHUNK_SIZE)) ? old_top : asp;
3398  mchunkptr sp = (mchunkptr) csp;
3399  msegmentptr ss = (msegmentptr) (chunk2mem(sp));
3400  mchunkptr tnext = chunk_plus_offset(sp, ssize);
3401  mchunkptr p = tnext;
3402  int nfences = 0;
3403 
3404  /* reset top to new space */
3405  init_top(m, (mchunkptr) tbase, tsize - TOP_FOOT_SIZE);
3406 
3407  /* Set up segment record */
3408  assert(is_aligned(ss));
3410  *ss = m->seg; /* Push current record */
3411  m->seg.base = tbase;
3412  m->seg.size = tsize;
3413  m->seg.sflags = mmapped;
3414  m->seg.next = ss;
3415 
3416  /* Insert trailing fenceposts */
3417  for (;;) {
3418  mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE);
3419  p->head = FENCEPOST_HEAD;
3420  ++nfences;
3421  if ((char *) (&(nextp->head)) < old_end)
3422  p = nextp;
3423  else
3424  break;
3425  }
3426  assert(nfences >= 2);
3427 
3428  /* Insert the rest of old top into a bin as an ordinary free chunk */
3429  if (csp != old_top) {
3430  mchunkptr q = (mchunkptr) old_top;
3431  size_t psize = csp - old_top;
3432  mchunkptr tn = chunk_plus_offset(q, psize);
3433  set_free_with_pinuse(q, psize, tn);
3434  insert_chunk(m, q, psize);
3435  }
3436 
3437  check_top_chunk(m, m->top);
3438 }

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().

◆ change_mparam()

static int change_mparam ( int  param_number,
int  value 
)
static

Definition at line 2569 of file SDL_malloc.c.

2570 {
2571  size_t val = (size_t) value;
2572  init_mparams();
2573  switch (param_number) {
2574  case M_TRIM_THRESHOLD:
2576  return 1;
2577  case M_GRANULARITY:
2578  if (val >= mparams.page_size && ((val & (val - 1)) == 0)) {
2580  return 1;
2581  } else
2582  return 0;
2583  case M_MMAP_THRESHOLD:
2585  return 1;
2586  default:
2587  return 0;
2588  }
2589 }

Referenced by dlmallopt().

◆ dlcalloc()

void * dlcalloc ( size_t  n_elements,
size_t  elem_size 
)

Definition at line 4385 of file SDL_malloc.c.

4386 {
4387  void *mem;
4388  size_t req = 0;
4389  if (n_elements != 0) {
4390  req = n_elements * elem_size;
4391  if (((n_elements | elem_size) & ~(size_t) 0xffff) &&
4392  (req / n_elements != elem_size))
4393  req = MAX_SIZE_T; /* force downstream failure on overflow */
4394  }
4395  mem = dlmalloc(req);
4396  if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
4397  memset(mem, 0, req);
4398  return mem;
4399 }

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

◆ dlfree()

void dlfree ( void mem)

Definition at line 4288 of file SDL_malloc.c.

4289 {
4290  /*
4291  Consolidate freed chunks with preceeding or succeeding bordering
4292  free chunks, if they exist, and then place in a bin. Intermixed
4293  with special cases for top, dv, mmapped chunks, and usage errors.
4294  */
4295 
4296  if (mem != 0) {
4297  mchunkptr p = mem2chunk(mem);
4298 #if FOOTERS
4299  mstate fm = get_mstate_for(p);
4300  if (!ok_magic(fm)) {
4302  return;
4303  }
4304 #else /* FOOTERS */
4305 #define fm gm
4306 #endif /* FOOTERS */
4307  if (!PREACTION(fm)) {
4309  if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) {
4310  size_t psize = chunksize(p);
4311  mchunkptr next = chunk_plus_offset(p, psize);
4312  if (!pinuse(p)) {
4313  size_t prevsize = p->prev_foot;
4314  if ((prevsize & IS_MMAPPED_BIT) != 0) {
4315  prevsize &= ~IS_MMAPPED_BIT;
4316  psize += prevsize + MMAP_FOOT_PAD;
4317  if (CALL_MUNMAP((char *) p - prevsize, psize) == 0)
4318  fm->footprint -= psize;
4319  goto postaction;
4320  } else {
4321  mchunkptr prev = chunk_minus_offset(p, prevsize);
4322  psize += prevsize;
4323  p = prev;
4324  if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
4325  if (p != fm->dv) {
4326  unlink_chunk(fm, p, prevsize);
4327  } else if ((next->head & INUSE_BITS) ==
4328  INUSE_BITS) {
4329  fm->dvsize = psize;
4330  set_free_with_pinuse(p, psize, next);
4331  goto postaction;
4332  }
4333  } else
4334  goto erroraction;
4335  }
4336  }
4337 
4338  if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
4339  if (!cinuse(next)) { /* consolidate forward */
4340  if (next == fm->top) {
4341  size_t tsize = fm->topsize += psize;
4342  fm->top = p;
4343  p->head = tsize | PINUSE_BIT;
4344  if (p == fm->dv) {
4345  fm->dv = 0;
4346  fm->dvsize = 0;
4347  }
4348  if (should_trim(fm, tsize))
4349  sys_trim(fm, 0);
4350  goto postaction;
4351  } else if (next == fm->dv) {
4352  size_t dsize = fm->dvsize += psize;
4353  fm->dv = p;
4355  goto postaction;
4356  } else {
4357  size_t nsize = chunksize(next);
4358  psize += nsize;
4359  unlink_chunk(fm, next, nsize);
4361  if (p == fm->dv) {
4362  fm->dvsize = psize;
4363  goto postaction;
4364  }
4365  }
4366  } else
4367  set_free_with_pinuse(p, psize, next);
4368  insert_chunk(fm, p, psize);
4369  check_free_chunk(fm, p);
4370  goto postaction;
4371  }
4372  }
4373  erroraction:
4375  postaction:
4376  POSTACTION(fm);
4377  }
4378  }
4379 #if !FOOTERS
4380 #undef fm
4381 #endif /* FOOTERS */
4382 }

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().

◆ dlindependent_calloc() [1/2]

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

Definition at line 4433 of file SDL_malloc.c.

4434 {
4435  size_t sz = elem_size; /* serves as 1-element array */
4436  return ialloc(gm, n_elements, &sz, 3, chunks);
4437 }

References gm, and ialloc().

◆ dlindependent_calloc() [2/2]

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

◆ dlindependent_comalloc() [1/2]

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

Definition at line 4440 of file SDL_malloc.c.

4441 {
4442  return ialloc(gm, n_elements, sizes, 0, chunks);
4443 }

References gm, and ialloc().

◆ dlindependent_comalloc() [2/2]

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

◆ dlmallinfo()

struct mallinfo dlmallinfo ( void  )

Definition at line 4482 of file SDL_malloc.c.

4490 {
4491  return internal_mallinfo(gm);
4492 }

◆ dlmalloc()

void * dlmalloc ( size_t  bytes)

Definition at line 4154 of file SDL_malloc.c.

4155 {
4156  /*
4157  Basic algorithm:
4158  If a small request (< 256 bytes minus per-chunk overhead):
4159  1. If one exists, use a remainderless chunk in associated smallbin.
4160  (Remainderless means that there are too few excess bytes to
4161  represent as a chunk.)
4162  2. If it is big enough, use the dv chunk, which is normally the
4163  chunk adjacent to the one used for the most recent small request.
4164  3. If one exists, split the smallest available chunk in a bin,
4165  saving remainder in dv.
4166  4. If it is big enough, use the top chunk.
4167  5. If available, get memory from system and use it
4168  Otherwise, for a large request:
4169  1. Find the smallest available binned chunk that fits, and use it
4170  if it is better fitting than dv chunk, splitting if necessary.
4171  2. If better fitting than any binned chunk, use the dv chunk.
4172  3. If it is big enough, use the top chunk.
4173  4. If request size >= mmap threshold, try to directly mmap this chunk.
4174  5. If available, get memory from system and use it
4175 
4176  The ugly goto's here ensure that postaction occurs along all paths.
4177  */
4178 
4179  if (!PREACTION(gm)) {
4180  void *mem;
4181  size_t nb;
4182  if (bytes <= MAX_SMALL_REQUEST) {
4183  bindex_t idx;
4184  binmap_t smallbits;
4185  nb = (bytes < MIN_REQUEST) ? MIN_CHUNK_SIZE : pad_request(bytes);
4186  idx = small_index(nb);
4187  smallbits = gm->smallmap >> idx;
4188 
4189  if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
4190  mchunkptr b, p;
4191  idx += ~smallbits & 1; /* Uses next bin if idx empty */
4192  b = smallbin_at(gm, idx);
4193  p = b->fd;
4194  assert(chunksize(p) == small_index2size(idx));
4195  unlink_first_small_chunk(gm, b, p, idx);
4197  mem = chunk2mem(p);
4198  check_malloced_chunk(gm, mem, nb);
4199  goto postaction;
4200  }
4201 
4202  else if (nb > gm->dvsize) {
4203  if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
4204  mchunkptr b, p, r;
4205  size_t rsize;
4206  bindex_t i;
4207  binmap_t leftbits =
4208  (smallbits << idx) & left_bits(idx2bit(idx));
4209  binmap_t leastbit = least_bit(leftbits);
4210  compute_bit2idx(leastbit, i);
4211  b = smallbin_at(gm, i);
4212  p = b->fd;
4215  rsize = small_index2size(i) - nb;
4216  /* Fit here cannot be remainderless if 4byte sizes */
4217  if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
4219  else {
4221  r = chunk_plus_offset(p, nb);
4223  replace_dv(gm, r, rsize);
4224  }
4225  mem = chunk2mem(p);
4226  check_malloced_chunk(gm, mem, nb);
4227  goto postaction;
4228  }
4229 
4230  else if (gm->treemap != 0
4231  && (mem = tmalloc_small(gm, nb)) != 0) {
4232  check_malloced_chunk(gm, mem, nb);
4233  goto postaction;
4234  }
4235  }
4236  } else if (bytes >= MAX_REQUEST)
4237  nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
4238  else {
4239  nb = pad_request(bytes);
4240  if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) {
4241  check_malloced_chunk(gm, mem, nb);
4242  goto postaction;
4243  }
4244  }
4245 
4246  if (nb <= gm->dvsize) {
4247  size_t rsize = gm->dvsize - nb;
4248  mchunkptr p = gm->dv;
4249  if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
4250  mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
4251  gm->dvsize = rsize;
4254  } else { /* exhaust dv */
4255  size_t dvs = gm->dvsize;
4256  gm->dvsize = 0;
4257  gm->dv = 0;
4258  set_inuse_and_pinuse(gm, p, dvs);
4259  }
4260  mem = chunk2mem(p);
4261  check_malloced_chunk(gm, mem, nb);
4262  goto postaction;
4263  }
4264 
4265  else if (nb < gm->topsize) { /* Split top */
4266  size_t rsize = gm->topsize -= nb;
4267  mchunkptr p = gm->top;
4268  mchunkptr r = gm->top = chunk_plus_offset(p, nb);
4269  r->head = rsize | PINUSE_BIT;
4271  mem = chunk2mem(p);
4272  check_top_chunk(gm, gm->top);
4273  check_malloced_chunk(gm, mem, nb);
4274  goto postaction;
4275  }
4276 
4277  mem = sys_alloc(gm, nb);
4278 
4279  postaction:
4280  POSTACTION(gm);
4281  return mem;
4282  }
4283 
4284  return 0;
4285 }

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().

◆ dlmalloc_footprint()

size_t dlmalloc_footprint ( void  )

Definition at line 4476 of file SDL_malloc.c.

4477 {
4478  return gm->footprint;
4479 }

References gm.

◆ dlmalloc_max_footprint()

size_t dlmalloc_max_footprint ( void  )

Definition at line 4482 of file SDL_malloc.c.

4483 {
4484  return gm->max_footprint;
4485 }

References gm.

◆ dlmalloc_stats()

void dlmalloc_stats ( void  )

Definition at line 4496 of file SDL_malloc.c.

4497 {
4499 }

References gm, and internal_malloc_stats().

◆ dlmalloc_trim()

int dlmalloc_trim ( size_t  pad)

Definition at line 4465 of file SDL_malloc.c.

4466 {
4467  int result = 0;
4468  if (!PREACTION(gm)) {
4469  result = sys_trim(gm, pad);
4470  POSTACTION(gm);
4471  }
4472  return result;
4473 }

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

◆ dlmalloc_usable_size()

size_t dlmalloc_usable_size ( void mem)

Definition at line 4502 of file SDL_malloc.c.

4503 {
4504  if (mem != 0) {
4505  mchunkptr p = mem2chunk(mem);
4506  if (cinuse(p))
4507  return chunksize(p) - overhead_for(p);
4508  }
4509  return 0;
4510 }

References chunksize, cinuse, mem2chunk, and overhead_for.

◆ dlmallopt()

int dlmallopt ( int  param_number,
int  value 
)

Definition at line 4513 of file SDL_malloc.c.

4514 {
4515  return change_mparam(param_number, value);
4516 }

References change_mparam().

◆ dlmemalign()

void * dlmemalign ( size_t  alignment,
size_t  bytes 
)

Definition at line 4427 of file SDL_malloc.c.

4428 {
4429  return internal_memalign(gm, alignment, bytes);
4430 }

References gm, and internal_memalign().

Referenced by dlpvalloc(), and dlvalloc().

◆ dlpvalloc()

void * dlpvalloc ( size_t  bytes)

Definition at line 4455 of file SDL_malloc.c.

4456 {
4457  size_t pagesz;
4458  init_mparams();
4459  pagesz = mparams.page_size;
4460  return dlmemalign(pagesz,
4461  (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
4462 }

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

◆ dlrealloc()

void * dlrealloc ( void oldmem,
size_t  bytes 
)

Definition at line 4402 of file SDL_malloc.c.

4403 {
4404  if (oldmem == 0)
4405  return dlmalloc(bytes);
4406 #ifdef REALLOC_ZERO_BYTES_FREES
4407  if (bytes == 0) {
4408  dlfree(oldmem);
4409  return 0;
4410  }
4411 #endif /* REALLOC_ZERO_BYTES_FREES */
4412  else {
4413 #if ! FOOTERS
4414  mstate m = gm;
4415 #else /* FOOTERS */
4416  mstate m = get_mstate_for(mem2chunk(oldmem));
4417  if (!ok_magic(m)) {
4418  USAGE_ERROR_ACTION(m, oldmem);
4419  return 0;
4420  }
4421 #endif /* FOOTERS */
4422  return internal_realloc(m, oldmem, bytes);
4423  }
4424 }

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

◆ dlvalloc()

void * dlvalloc ( size_t  bytes)

Definition at line 4446 of file SDL_malloc.c.

4447 {
4448  size_t pagesz;
4449  init_mparams();
4450  pagesz = mparams.page_size;
4451  return dlmemalign(pagesz, bytes);
4452 }

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

◆ has_segment_link()

static int has_segment_link ( mstate  m,
msegmentptr  ss 
)
static

Definition at line 2146 of file SDL_malloc.c.

2147 {
2148  msegmentptr sp = &m->seg;
2149  for (;;) {
2150  if ((char *) sp >= ss->base && (char *) sp < ss->base + ss->size)
2151  return 1;
2152  if ((sp = sp->next) == 0)
2153  return 0;
2154  }
2155 }

Referenced by sys_trim().

◆ ialloc()

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.

4029 {
4030  /*
4031  This provides common support for independent_X routines, handling
4032  all of the combinations that can result.
4033 
4034  The opts arg has:
4035  bit 0 set if all elements are same size (using sizes[0])
4036  bit 1 set if elements should be zeroed
4037  */
4038 
4039  size_t element_size; /* chunksize of each element, if all same */
4040  size_t contents_size; /* total size of elements */
4041  size_t array_size; /* request size of pointer array */
4042  void *mem; /* malloced aggregate space */
4043  mchunkptr p; /* corresponding chunk */
4044  size_t remainder_size; /* remaining bytes while splitting */
4045  void **marray; /* either "chunks" or malloced ptr array */
4046  mchunkptr array_chunk; /* chunk for malloced ptr array */
4047  flag_t was_enabled; /* to disable mmap */
4048  size_t size;
4049  size_t i;
4050 
4051  /* compute array length, if needed */
4052  if (chunks != 0) {
4053  if (n_elements == 0)
4054  return chunks; /* nothing to do */
4055  marray = chunks;
4056  array_size = 0;
4057  } else {
4058  /* if empty req, must still return chunk representing empty array */
4059  if (n_elements == 0)
4060  return (void **) internal_malloc(m, 0);
4061  marray = 0;
4062  array_size = request2size(n_elements * (sizeof(void *)));
4063  }
4064 
4065  /* compute total element size */
4066  if (opts & 0x1) { /* all-same-size */
4067  element_size = request2size(*sizes);
4068  contents_size = n_elements * element_size;
4069  } else { /* add up all the sizes */
4070  element_size = 0;
4071  contents_size = 0;
4072  for (i = 0; i != n_elements; ++i)
4073  contents_size += request2size(sizes[i]);
4074  }
4075 
4076  size = contents_size + array_size;
4077 
4078  /*
4079  Allocate the aggregate chunk. First disable direct-mmapping so
4080  malloc won't use it, since we would not be able to later
4081  free/realloc space internal to a segregated mmap region.
4082  */
4083  was_enabled = use_mmap(m);
4084  disable_mmap(m);
4086  if (was_enabled)
4087  enable_mmap(m);
4088  if (mem == 0)
4089  return 0;
4090 
4091  if (PREACTION(m))
4092  return 0;
4093  p = mem2chunk(mem);
4094  remainder_size = chunksize(p);
4095 
4096  assert(!is_mmapped(p));
4097 
4098  if (opts & 0x2) { /* optionally clear the elements */
4099  memset((size_t *) mem, 0, remainder_size - SIZE_T_SIZE - array_size);
4100  }
4101 
4102  /* If not provided, allocate the pointer array as final part of chunk */
4103  if (marray == 0) {
4104  size_t array_chunk_size;
4105  array_chunk = chunk_plus_offset(p, contents_size);
4106  array_chunk_size = remainder_size - contents_size;
4107  marray = (void **) (chunk2mem(array_chunk));
4108  set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
4109  remainder_size = contents_size;
4110  }
4111 
4112  /* split out elements */
4113  for (i = 0;; ++i) {
4114  marray[i] = chunk2mem(p);
4115  if (i != n_elements - 1) {
4116  if (element_size != 0)
4117  size = element_size;
4118  else
4119  size = request2size(sizes[i]);
4120  remainder_size -= size;
4122  p = chunk_plus_offset(p, size);
4123  } else { /* the final element absorbs any overallocation slop */
4124  set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
4125  break;
4126  }
4127  }
4128 
4129 #if DEBUG
4130  if (marray != chunks) {
4131  /* final element must have exactly exhausted chunk */
4132  if (element_size != 0) {
4133  assert(remainder_size == element_size);
4134  } else {
4135  assert(remainder_size == request2size(sizes[i]));
4136  }
4137  check_inuse_chunk(m, mem2chunk(marray));
4138  }
4139  for (i = 0; i != n_elements; ++i)
4140  check_inuse_chunk(m, mem2chunk(marray[i]));
4141 
4142 #endif /* DEBUG */
4143 
4144  POSTACTION(m);
4145  return marray;
4146 }

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().

◆ init_bins()

static void init_bins ( mstate  m)
static

Definition at line 3312 of file SDL_malloc.c.

3313 {
3314  /* Establish circular links for smallbins */
3315  bindex_t i;
3316  for (i = 0; i < NSMALLBINS; ++i) {
3317  sbinptr bin = smallbin_at(m, i);
3318  bin->fd = bin->bk = bin;
3319  }
3320 }

References i, NSMALLBINS, and smallbin_at.

Referenced by sys_alloc().

◆ init_mparams()

static int init_mparams ( void  )
static

Definition at line 2491 of file SDL_malloc.c.

2492 {
2493  if (mparams.page_size == 0) {
2494  size_t s;
2495 
2498 #if MORECORE_CONTIGUOUS
2500 #else /* MORECORE_CONTIGUOUS */
2503 #endif /* MORECORE_CONTIGUOUS */
2504 
2505 #if (FOOTERS && !INSECURE)
2506  {
2507 #if USE_DEV_RANDOM
2508  int fd;
2509  unsigned char buf[sizeof(size_t)];
2510  /* Try to use /dev/urandom, else fall back on using time */
2511  if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 &&
2512  read(fd, buf, sizeof(buf)) == sizeof(buf)) {
2513  s = *((size_t *) buf);
2514  close(fd);
2515  } else
2516 #endif /* USE_DEV_RANDOM */
2517  s = (size_t) (time(0) ^ (size_t) 0x55555555U);
2518 
2519  s |= (size_t) 8U; /* ensure nonzero */
2520  s &= ~(size_t) 7U; /* improve chances of fault for bad values */
2521 
2522  }
2523 #else /* (FOOTERS && !INSECURE) */
2524  s = (size_t) 0x58585858U;
2525 #endif /* (FOOTERS && !INSECURE) */
2527  if (mparams.magic == 0) {
2528  mparams.magic = s;
2529  /* Set up lock for main malloc area */
2530  INITIAL_LOCK(&gm->mutex);
2531  gm->mflags = mparams.default_mflags;
2532  }
2534 
2535 #ifndef WIN32
2536  mparams.page_size = malloc_getpagesize;
2539 #else /* WIN32 */
2540  {
2541  SYSTEM_INFO system_info;
2542  GetSystemInfo(&system_info);
2543  mparams.page_size = system_info.dwPageSize;
2544  mparams.granularity = system_info.dwAllocationGranularity;
2545  }
2546 #endif /* WIN32 */
2547 
2548  /* Sanity-check configuration:
2549  size_t must be unsigned and as wide as pointer type.
2550  ints must be at least 4 bytes.
2551  alignment must be at least 8.
2552  Alignment, min chunk size, and page size must all be powers of 2.
2553  */
2554  if ((sizeof(size_t) != sizeof(char *)) ||
2555  (MAX_SIZE_T < MIN_CHUNK_SIZE) ||
2556  (sizeof(int) < 4) ||
2557  (MALLOC_ALIGNMENT < (size_t) 8U) ||
2558  ((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT - SIZE_T_ONE)) != 0) ||
2559  ((MCHUNK_SIZE & (MCHUNK_SIZE - SIZE_T_ONE)) != 0) ||
2561  || ((mparams.page_size & (mparams.page_size - SIZE_T_ONE)) != 0))
2562  ABORT;
2563  }
2564  return 0;
2565 }

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 dlpvalloc(), dlvalloc(), internal_mallinfo(), and sys_alloc().

◆ init_top()

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

Definition at line 3295 of file SDL_malloc.c.

3296 {
3297  /* Ensure alignment */
3298  size_t offset = align_offset(chunk2mem(p));
3299  p = (mchunkptr) ((char *) p + offset);
3300  psize -= offset;
3301 
3302  m->top = p;
3303  m->topsize = psize;
3304  p->head = psize | PINUSE_BIT;
3305  /* set size of fake trailing chunk holding overhead space only once */
3306  chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE;
3307  m->trim_check = mparams.trim_threshold; /* reset on each update */
3308 }

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().

◆ internal_mallinfo()

static struct mallinfo internal_mallinfo ( mstate  m)
static

Definition at line 2569 of file SDL_malloc.c.

2885 {
2886  struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
2887  if (!PREACTION(m)) {
2889  if (is_initialized(m)) {
2890  size_t nfree = SIZE_T_ONE; /* top always free */
2891  size_t mfree = m->topsize + TOP_FOOT_SIZE;
2892  size_t sum = mfree;
2893  msegmentptr s = &m->seg;
2894  while (s != 0) {
2895  mchunkptr q = align_as_chunk(s->base);
2896  while (segment_holds(s, q) &&
2897  q != m->top && q->head != FENCEPOST_HEAD) {
2898  size_t sz = chunksize(q);
2899  sum += sz;
2900  if (!cinuse(q)) {
2901  mfree += sz;
2902  ++nfree;
2903  }
2904  q = next_chunk(q);
2905  }
2906  s = s->next;
2907  }
2908 
2909  nm.arena = sum;
2910  nm.ordblks = nfree;
2911  nm.hblkhd = m->footprint - sum;
2912  nm.usmblks = m->max_footprint;
2913  nm.uordblks = m->footprint - mfree;
2914  nm.fordblks = mfree;
2915  nm.keepcost = m->topsize;
2916  }
2917 
2918  POSTACTION(m);
2919  }
2920  return nm;
2921 }

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.

◆ internal_malloc_stats()

static void internal_malloc_stats ( mstate  m)
static

Definition at line 2925 of file SDL_malloc.c.

2926 {
2927  if (!PREACTION(m)) {
2928 #ifndef LACKS_STDIO_H
2929  size_t maxfp = 0;
2930 #endif
2931  size_t fp = 0;
2932  size_t used = 0;
2934  if (is_initialized(m)) {
2935  msegmentptr s = &m->seg;
2936 #ifndef LACKS_STDIO_H
2937  maxfp = m->max_footprint;
2938 #endif
2939  fp = m->footprint;
2940  used = fp - (m->topsize + TOP_FOOT_SIZE);
2941 
2942  while (s != 0) {
2943  mchunkptr q = align_as_chunk(s->base);
2944  while (segment_holds(s, q) &&
2945  q != m->top && q->head != FENCEPOST_HEAD) {
2946  if (!cinuse(q))
2947  used -= chunksize(q);
2948  q = next_chunk(q);
2949  }
2950  s = s->next;
2951  }
2952  }
2953 #ifndef LACKS_STDIO_H
2954  fprintf(stderr, "max system bytes = %10lu\n",
2955  (unsigned long) (maxfp));
2956  fprintf(stderr, "system bytes = %10lu\n", (unsigned long) (fp));
2957  fprintf(stderr, "in use bytes = %10lu\n", (unsigned long) (used));
2958 #endif
2959 
2960  POSTACTION(m);
2961  }
2962 }

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().

◆ internal_memalign()

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

Definition at line 3938 of file SDL_malloc.c.

3939 {
3940  if (alignment <= MALLOC_ALIGNMENT) /* Can just use malloc */
3941  return internal_malloc(m, bytes);
3942  if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */
3943  alignment = MIN_CHUNK_SIZE;
3944  if ((alignment & (alignment - SIZE_T_ONE)) != 0) { /* Ensure a power of 2 */
3945  size_t a = MALLOC_ALIGNMENT << 1;
3946  while (a < alignment)
3947  a <<= 1;
3948  alignment = a;
3949  }
3950 
3951  if (bytes >= MAX_REQUEST - alignment) {
3952  if (m != 0) { /* Test isn't needed but avoids compiler warning */
3954  }
3955  } else {
3956  size_t nb = request2size(bytes);
3957  size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
3958  char *mem = (char *) internal_malloc(m, req);
3959  if (mem != 0) {
3960  void *leader = 0;
3961  void *trailer = 0;
3962  mchunkptr p = mem2chunk(mem);
3963 
3964  if (PREACTION(m))
3965  return 0;
3966  if ((((size_t) (mem)) % alignment) != 0) { /* misaligned */
3967  /*
3968  Find an aligned spot inside chunk. Since we need to give
3969  back leading space in a chunk of at least MIN_CHUNK_SIZE, if
3970  the first calculation places us at a spot with less than
3971  MIN_CHUNK_SIZE leader, we can move to the next aligned spot.
3972  We've allocated enough total room so that this is always
3973  possible.
3974  */
3975  char *br = (char *) mem2chunk((size_t) (((size_t) (mem +
3976  alignment -
3977  SIZE_T_ONE))
3978  & -alignment));
3979  char *pos =
3980  ((size_t) (br - (char *) (p)) >=
3981  MIN_CHUNK_SIZE) ? br : br + alignment;
3982  mchunkptr newp = (mchunkptr) pos;
3983  size_t leadsize = pos - (char *) (p);
3984  size_t newsize = chunksize(p) - leadsize;
3985 
3986  if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */
3987  newp->prev_foot = p->prev_foot + leadsize;
3988  newp->head = (newsize | CINUSE_BIT);
3989  } else { /* Otherwise, give back leader, use the rest */
3990  set_inuse(m, newp, newsize);
3991  set_inuse(m, p, leadsize);
3992  leader = chunk2mem(p);
3993  }
3994  p = newp;
3995  }
3996 
3997  /* Give back spare room at the end */
3998  if (!is_mmapped(p)) {
3999  size_t size = chunksize(p);
4000  if (size > nb + MIN_CHUNK_SIZE) {
4001  size_t remainder_size = size - nb;
4002  mchunkptr remainder = chunk_plus_offset(p, nb);
4003  set_inuse(m, p, nb);
4004  set_inuse(m, remainder, remainder_size);
4005  trailer = chunk2mem(remainder);
4006  }
4007  }
4008 
4009  assert(chunksize(p) >= nb);
4010  assert((((size_t) (chunk2mem(p))) % alignment) == 0);
4011  check_inuse_chunk(m, p);
4012  POSTACTION(m);
4013  if (leader != 0) {
4014  internal_free(m, leader);
4015  }
4016  if (trailer != 0) {
4017  internal_free(m, trailer);
4018  }
4019  return chunk2mem(p);
4020  }
4021  }
4022  return 0;
4023 }

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().

◆ internal_realloc()

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

Definition at line 3868 of file SDL_malloc.c.

3869 {
3870  if (bytes >= MAX_REQUEST) {
3872  return 0;
3873  }
3874  if (!PREACTION(m)) {
3875  mchunkptr oldp = mem2chunk(oldmem);
3876  size_t oldsize = chunksize(oldp);
3877  mchunkptr next = chunk_plus_offset(oldp, oldsize);
3878  mchunkptr newp = 0;
3879  void *extra = 0;
3880 
3881  /* Try to either shrink or extend into top. Else malloc-copy-free */
3882 
3883  if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) &&
3884  ok_next(oldp, next) && ok_pinuse(next))) {
3885  size_t nb = request2size(bytes);
3886  if (is_mmapped(oldp))
3887  newp = mmap_resize(m, oldp, nb);
3888  else if (oldsize >= nb) { /* already big enough */
3889  size_t rsize = oldsize - nb;
3890  newp = oldp;
3891  if (rsize >= MIN_CHUNK_SIZE) {
3892  mchunkptr remainder = chunk_plus_offset(newp, nb);
3893  set_inuse(m, newp, nb);
3894  set_inuse(m, remainder, rsize);
3895  extra = chunk2mem(remainder);
3896  }
3897  } else if (next == m->top && oldsize + m->topsize > nb) {
3898  /* Expand into top */
3899  size_t newsize = oldsize + m->topsize;
3900  size_t newtopsize = newsize - nb;
3901  mchunkptr newtop = chunk_plus_offset(oldp, nb);
3902  set_inuse(m, oldp, nb);
3903  newtop->head = newtopsize | PINUSE_BIT;
3904  m->top = newtop;
3905  m->topsize = newtopsize;
3906  newp = oldp;
3907  }
3908  } else {
3909  USAGE_ERROR_ACTION(m, oldmem);
3910  POSTACTION(m);
3911  return 0;
3912  }
3913 
3914  POSTACTION(m);
3915 
3916  if (newp != 0) {
3917  if (extra != 0) {
3918  internal_free(m, extra);
3919  }
3920  check_inuse_chunk(m, newp);
3921  return chunk2mem(newp);
3922  } else {
3923  void *newmem = internal_malloc(m, bytes);
3924  if (newmem != 0) {
3925  size_t oc = oldsize - overhead_for(oldp);
3926  memcpy(newmem, oldmem, (oc < bytes) ? oc : bytes);
3927  internal_free(m, oldmem);
3928  }
3929  return newmem;
3930  }
3931  }
3932  return 0;
3933 }

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().

◆ mmap_alloc()

static void* mmap_alloc ( mstate  m,
size_t  nb 
)
static

Definition at line 3226 of file SDL_malloc.c.

3227 {
3228  size_t mmsize =
3230  if (mmsize > nb) { /* Check for wrap around 0 */
3231  char *mm = (char *) (DIRECT_MMAP(mmsize));
3232  if (mm != CMFAIL) {
3233  size_t offset = align_offset(chunk2mem(mm));
3234  size_t psize = mmsize - offset - MMAP_FOOT_PAD;
3235  mchunkptr p = (mchunkptr) (mm + offset);
3236  p->prev_foot = offset | IS_MMAPPED_BIT;
3237  (p)->head = (psize | CINUSE_BIT);
3238  mark_inuse_foot(m, p, psize);
3239  chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD;
3240  chunk_plus_offset(p, psize + SIZE_T_SIZE)->head = 0;
3241 
3242  if (mm < m->least_addr)
3243  m->least_addr = mm;
3244  if ((m->footprint += mmsize) > m->max_footprint)
3245  m->max_footprint = m->footprint;
3248  return chunk2mem(p);
3249  }
3250  }
3251  return 0;
3252 }

References align_offset, assert, check_mmapped_chunk, chunk2mem, CHUNK_ALIGN_MASK, chunk_plus_offset, CINUSE_BIT, CMFAIL, DIRECT_MMAP, FENCEPOST_HEAD, granularity_align, head, 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().

◆ mmap_resize()

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

Definition at line 3256 of file SDL_malloc.c.

3257 {
3258  size_t oldsize = chunksize(oldp);
3259  if (is_small(nb)) /* Can't shrink mmap regions below small size */
3260  return 0;
3261  /* Keep old chunk if big enough but not too big */
3262  if (oldsize >= nb + SIZE_T_SIZE &&
3263  (oldsize - nb) <= (mparams.granularity << 1))
3264  return oldp;
3265  else {
3266  size_t offset = oldp->prev_foot & ~IS_MMAPPED_BIT;
3267  size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
3268  size_t newmmsize = granularity_align(nb + SIX_SIZE_T_SIZES +
3270  char *cp = (char *) CALL_MREMAP((char *) oldp - offset,
3271  oldmmsize, newmmsize, 1);
3272  if (cp != CMFAIL) {
3273  mchunkptr newp = (mchunkptr) (cp + offset);
3274  size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
3275  newp->head = (psize | CINUSE_BIT);
3276  mark_inuse_foot(m, newp, psize);
3277  chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
3278  chunk_plus_offset(newp, psize + SIZE_T_SIZE)->head = 0;
3279 
3280  if (cp < m->least_addr)
3281  m->least_addr = cp;
3282  if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint)
3283  m->max_footprint = m->footprint;
3284  check_mmapped_chunk(m, newp);
3285  return newp;
3286  }
3287  }
3288  return 0;
3289 }

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().

◆ prepend_alloc()

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

Definition at line 3345 of file SDL_malloc.c.

3346 {
3347  mchunkptr p = align_as_chunk(newbase);
3348  mchunkptr oldfirst = align_as_chunk(oldbase);
3349  size_t psize = (char *) oldfirst - (char *) p;
3350  mchunkptr q = chunk_plus_offset(p, nb);
3351  size_t qsize = psize - nb;
3353 
3354  assert((char *) oldfirst > (char *) q);
3355  assert(pinuse(oldfirst));
3356  assert(qsize >= MIN_CHUNK_SIZE);
3357 
3358  /* consolidate remainder with first chunk of old base */
3359  if (oldfirst == m->top) {
3360  size_t tsize = m->topsize += qsize;
3361  m->top = q;
3362  q->head = tsize | PINUSE_BIT;
3363  check_top_chunk(m, q);
3364  } else if (oldfirst == m->dv) {
3365  size_t dsize = m->dvsize += qsize;
3366  m->dv = q;
3368  } else {
3369  if (!cinuse(oldfirst)) {
3370  size_t nsize = chunksize(oldfirst);
3371  unlink_chunk(m, oldfirst, nsize);
3372  oldfirst = chunk_plus_offset(oldfirst, nsize);
3373  qsize += nsize;
3374  }
3375  set_free_with_pinuse(q, qsize, oldfirst);
3376  insert_chunk(m, q, qsize);
3377  check_free_chunk(m, q);
3378  }
3379 
3381  return chunk2mem(p);
3382 }

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().

◆ release_unused_segments()

static size_t release_unused_segments ( mstate  m)
static

Definition at line 3644 of file SDL_malloc.c.

3645 {
3646  size_t released = 0;
3647  msegmentptr pred = &m->seg;
3648  msegmentptr sp = pred->next;
3649  while (sp != 0) {
3650  char *base = sp->base;
3651  size_t size = sp->size;
3652  msegmentptr next = sp->next;
3653  if (is_mmapped_segment(sp) && !is_extern_segment(sp)) {
3654  mchunkptr p = align_as_chunk(base);
3655  size_t psize = chunksize(p);
3656  /* Can unmap if first chunk holds entire segment and not pinned */
3657  if (!cinuse(p)
3658  && (char *) p + psize >= base + size - TOP_FOOT_SIZE) {
3659  tchunkptr tp = (tchunkptr) p;
3660  assert(segment_holds(sp, (char *) sp));
3661  if (p == m->dv) {
3662  m->dv = 0;
3663  m->dvsize = 0;
3664  } else {
3665  unlink_large_chunk(m, tp);
3666  }
3667  if (CALL_MUNMAP(base, size) == 0) {
3668  released += size;
3669  m->footprint -= size;
3670  /* unlink obsoleted record */
3671  sp = pred;
3672  sp->next = next;
3673  } else { /* back out if cannot unmap */
3674  insert_large_chunk(m, tp, psize);
3675  }
3676  }
3677  }
3678  pred = sp;
3679  sp = next;
3680  }
3681  return released;
3682 }

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().

◆ SDL_calloc()

void* SDL_calloc ( size_t  nmemb,
size_t  size 
)

Definition at line 5335 of file SDL_malloc.c.

5336 {
5337  void *mem;
5338 
5339  if (!nmemb || !size) {
5340  nmemb = 1;
5341  size = 1;
5342  }
5343 
5344  mem = s_mem.calloc_func(nmemb, size);
5345  if (mem) {
5346  SDL_AtomicIncRef(&s_mem.num_allocations);
5347  }
5348  return mem;
5349 }

References s_mem, and SDL_AtomicIncRef.

◆ SDL_free()

void SDL_free ( void ptr)

Definition at line 5366 of file SDL_malloc.c.

5367 {
5368  if (!ptr) {
5369  return;
5370  }
5371 
5372  s_mem.free_func(ptr);
5373  (void)SDL_AtomicDecRef(&s_mem.num_allocations);
5374 }

References s_mem, SDL_AtomicDecRef, and void.

◆ SDL_GetMemoryFunctions()

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.

5275 {
5276  if (malloc_func) {
5277  *malloc_func = s_mem.malloc_func;
5278  }
5279  if (calloc_func) {
5280  *calloc_func = s_mem.calloc_func;
5281  }
5282  if (realloc_func) {
5283  *realloc_func = s_mem.realloc_func;
5284  }
5285  if (free_func) {
5286  *free_func = s_mem.free_func;
5287  }
5288 }

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

◆ SDL_GetNumAllocations()

int SDL_GetNumAllocations ( void  )

Get the number of outstanding (unfreed) allocations.

Definition at line 5315 of file SDL_malloc.c.

5316 {
5317  return SDL_AtomicGet(&s_mem.num_allocations);
5318 }

References s_mem, and SDL_AtomicGet.

◆ SDL_malloc()

void* SDL_malloc ( size_t  size)

Definition at line 5320 of file SDL_malloc.c.

5321 {
5322  void *mem;
5323 
5324  if (!size) {
5325  size = 1;
5326  }
5327 
5328  mem = s_mem.malloc_func(size);
5329  if (mem) {
5330  SDL_AtomicIncRef(&s_mem.num_allocations);
5331  }
5332  return mem;
5333 }

References s_mem, and SDL_AtomicIncRef.

◆ SDL_realloc()

void* SDL_realloc ( void ptr,
size_t  size 
)

Definition at line 5351 of file SDL_malloc.c.

5352 {
5353  void *mem;
5354 
5355  if (!ptr && !size) {
5356  size = 1;
5357  }
5358 
5359  mem = s_mem.realloc_func(ptr, size);
5360  if (mem && !ptr) {
5361  SDL_AtomicIncRef(&s_mem.num_allocations);
5362  }
5363  return mem;
5364 }

References s_mem, and SDL_AtomicIncRef.

◆ SDL_SetMemoryFunctions()

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.

5294 {
5295  if (!malloc_func) {
5296  return SDL_InvalidParamError("malloc_func");
5297  }
5298  if (!calloc_func) {
5299  return SDL_InvalidParamError("calloc_func");
5300  }
5301  if (!realloc_func) {
5302  return SDL_InvalidParamError("realloc_func");
5303  }
5304  if (!free_func) {
5305  return SDL_InvalidParamError("free_func");
5306  }
5307 
5308  s_mem.malloc_func = malloc_func;
5309  s_mem.calloc_func = calloc_func;
5310  s_mem.realloc_func = realloc_func;
5311  s_mem.free_func = free_func;
5312  return 0;
5313 }

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

◆ segment_holding()

static msegmentptr segment_holding ( mstate  m,
char *  addr 
)
static

Definition at line 2133 of file SDL_malloc.c.

2134 {
2135  msegmentptr sp = &m->seg;
2136  for (;;) {
2137  if (addr >= sp->base && addr < sp->base + sp->size)
2138  return sp;
2139  if ((sp = sp->next) == 0)
2140  return 0;
2141  }
2142 }

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

◆ sys_alloc()

static void* sys_alloc ( mstate  m,
size_t  nb 
)
static

Definition at line 3444 of file SDL_malloc.c.

3445 {
3446  char *tbase = CMFAIL;
3447  size_t tsize = 0;
3448  flag_t mmap_flag = 0;
3449 
3450  init_mparams();
3451 
3452  /* Directly map large chunks */
3453  if (use_mmap(m) && nb >= mparams.mmap_threshold) {
3454  void *mem = mmap_alloc(m, nb);
3455  if (mem != 0)
3456  return mem;
3457  }
3458 
3459  /*
3460  Try getting memory in any of three ways (in most-preferred to
3461  least-preferred order):
3462  1. A call to MORECORE that can normally contiguously extend memory.
3463  (disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or
3464  or main space is mmapped or a previous contiguous call failed)
3465  2. A call to MMAP new space (disabled if not HAVE_MMAP).
3466  Note that under the default settings, if MORECORE is unable to
3467  fulfill a request, and HAVE_MMAP is true, then mmap is
3468  used as a noncontiguous system allocator. This is a useful backup
3469  strategy for systems with holes in address spaces -- in this case
3470  sbrk cannot contiguously expand the heap, but mmap may be able to
3471  find space.
3472  3. A call to MORECORE that cannot usually contiguously extend memory.
3473  (disabled if not HAVE_MORECORE)
3474  */
3475 
3477  char *br = CMFAIL;
3478  msegmentptr ss =
3479  (m->top == 0) ? 0 : segment_holding(m, (char *) m->top);
3480  size_t asize = 0;
3482 
3483  if (ss == 0) { /* First time through or recovery */
3484  char *base = (char *) CALL_MORECORE(0);
3485  if (base != CMFAIL) {
3486  asize =
3488  SIZE_T_ONE);
3489  /* Adjust to end on a page boundary */
3490  if (!is_page_aligned(base))
3491  asize += (page_align((size_t) base) - (size_t) base);
3492  /* Can't call MORECORE if size is negative when treated as signed */
3493  if (asize < HALF_MAX_SIZE_T &&
3494  (br = (char *) (CALL_MORECORE(asize))) == base) {
3495  tbase = base;
3496  tsize = asize;
3497  }
3498  }
3499  } else {
3500  /* Subtract out existing available top space from MORECORE request. */
3501  asize =
3502  granularity_align(nb - m->topsize + TOP_FOOT_SIZE +
3504  /* Use mem here only if it did continuously extend old space */
3505  if (asize < HALF_MAX_SIZE_T &&
3506  (br =
3507  (char *) (CALL_MORECORE(asize))) == ss->base + ss->size) {
3508  tbase = br;
3509  tsize = asize;
3510  }
3511  }
3512 
3513  if (tbase == CMFAIL) { /* Cope with partial failure */
3514  if (br != CMFAIL) { /* Try to use/extend the space we did get */
3515  if (asize < HALF_MAX_SIZE_T &&
3516  asize < nb + TOP_FOOT_SIZE + SIZE_T_ONE) {
3517  size_t esize =
3520  asize);
3521  if (esize < HALF_MAX_SIZE_T) {
3522  char *end = (char *) CALL_MORECORE(esize);
3523  if (end != CMFAIL)
3524  asize += esize;
3525  else { /* Can't use; try to release */
3526  end = (char *) CALL_MORECORE(-asize);
3527  br = CMFAIL;
3528  }
3529  }
3530  }
3531  }
3532  if (br != CMFAIL) { /* Use the space we did get */
3533  tbase = br;
3534  tsize = asize;
3535  } else
3536  disable_contiguous(m); /* Don't try contiguous path in the future */
3537  }
3538 
3540  }
3541 
3542  if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */
3543  size_t req = nb + TOP_FOOT_SIZE + MALLOC_ALIGNMENT + SIZE_T_ONE;
3544  size_t rsize = granularity_align(req);
3545  if (rsize > nb) { /* Fail if wraps around zero */
3546  char *mp = (char *) (CALL_MMAP(rsize));
3547  if (mp != CMFAIL) {
3548  tbase = mp;
3549  tsize = rsize;
3550  mmap_flag = IS_MMAPPED_BIT;
3551  }
3552  }
3553  }
3554 
3555  if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */
3556  size_t asize =
3558  SIZE_T_ONE);
3559  if (asize < HALF_MAX_SIZE_T) {
3560  char *br = CMFAIL;
3561  char *end = CMFAIL;
3563  br = (char *) (CALL_MORECORE(asize));
3564  end = (char *) (CALL_MORECORE(0));
3566  if (br != CMFAIL && end != CMFAIL && br < end) {
3567  size_t ssize = end - br;
3568  if (ssize > nb + TOP_FOOT_SIZE) {
3569  tbase = br;
3570  tsize = ssize;
3571  }
3572  }
3573  }
3574  }
3575 
3576  if (tbase != CMFAIL) {
3577 
3578  if ((m->footprint += tsize) > m->max_footprint)
3579  m->max_footprint = m->footprint;
3580 
3581  if (!is_initialized(m)) { /* first-time initialization */
3582  m->seg.base = m->least_addr = tbase;
3583  m->seg.size = tsize;
3584  m->seg.sflags = mmap_flag;
3585  m->magic = mparams.magic;
3586  init_bins(m);
3587  if (is_global(m))
3588  init_top(m, (mchunkptr) tbase, tsize - TOP_FOOT_SIZE);
3589  else {
3590  /* Offset top by embedded malloc_state */
3591  mchunkptr mn = next_chunk(mem2chunk(m));
3592  init_top(m, mn,
3593  (size_t) ((tbase + tsize) - (char *) mn) -
3594  TOP_FOOT_SIZE);
3595  }
3596  }
3597 
3598  else {
3599  /* Try to merge with an existing segment */
3600  msegmentptr sp = &m->seg;
3601  while (sp != 0 && tbase != sp->base + sp->size)
3602  sp = sp->next;
3603  if (sp != 0 && !is_extern_segment(sp) && (sp->sflags & IS_MMAPPED_BIT) == mmap_flag && segment_holds(sp, m->top)) { /* append */
3604  sp->size += tsize;
3605  init_top(m, m->top, m->topsize + tsize);
3606  } else {
3607  if (tbase < m->least_addr)
3608  m->least_addr = tbase;
3609  sp = &m->seg;
3610  while (sp != 0 && sp->base != tbase + tsize)
3611  sp = sp->next;
3612  if (sp != 0 &&
3613  !is_extern_segment(sp) &&
3614  (sp->sflags & IS_MMAPPED_BIT) == mmap_flag) {
3615  char *oldbase = sp->base;
3616  sp->base = tbase;
3617  sp->size += tsize;
3618  return prepend_alloc(m, tbase, oldbase, nb);
3619  } else
3620  add_segment(m, tbase, tsize, mmap_flag);
3621  }
3622  }
3623 
3624  if (nb < m->topsize) { /* Allocate from new or extended top space */
3625  size_t rsize = m->topsize -= nb;
3626  mchunkptr p = m->top;
3627  mchunkptr r = m->top = chunk_plus_offset(p, nb);
3628  r->head = rsize | PINUSE_BIT;
3630  check_top_chunk(m, m->top);
3632  return chunk2mem(p);
3633  }
3634  }
3635 
3637  return 0;
3638 }

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().

◆ sys_trim()

static int sys_trim ( mstate  m,
size_t  pad 
)
static

Definition at line 3685 of file SDL_malloc.c.

3686 {
3687  size_t released = 0;
3688  if (pad < MAX_REQUEST && is_initialized(m)) {
3689  pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
3690 
3691  if (m->topsize > pad) {
3692  /* Shrink top space in granularity-size units, keeping at least one */
3693  size_t unit = mparams.granularity;
3694  size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
3695  SIZE_T_ONE) * unit;
3696  msegmentptr sp = segment_holding(m, (char *) m->top);
3697 
3698  if (!is_extern_segment(sp)) {
3699  if (is_mmapped_segment(sp)) {
3700  if (HAVE_MMAP && sp->size >= extra && !has_segment_link(m, sp)) { /* can't shrink if pinned */
3701  size_t newsize = sp->size - extra;
3702  /* Prefer mremap, fall back to munmap */
3703  if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) !=
3704  MFAIL)
3705  || (CALL_MUNMAP(sp->base + newsize, extra) == 0)) {
3706  released = extra;
3707  }
3708  }
3709  } else if (HAVE_MORECORE) {
3710  if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */
3711  extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit;
3713  {
3714  /* Make sure end of memory is where we last set it. */
3715  char *old_br = (char *) (CALL_MORECORE(0));
3716  if (old_br == sp->base + sp->size) {
3717  char *rel_br = (char *) (CALL_MORECORE(-extra));
3718  char *new_br = (char *) (CALL_MORECORE(0));
3719  if (rel_br != CMFAIL && new_br < old_br)
3720  released = old_br - new_br;
3721  }
3722  }
3724  }
3725  }
3726 
3727  if (released != 0) {
3728  sp->size -= released;
3729  m->footprint -= released;
3730  init_top(m, m->top, m->topsize - released);
3731  check_top_chunk(m, m->top);
3732  }
3733  }
3734 
3735  /* Unmap any unused mmapped segments */
3736  if (HAVE_MMAP)
3737  released += release_unused_segments(m);
3738 
3739  /* On failure, disable autotrim to avoid repeated failed future calls */
3740  if (released == 0)
3741  m->trim_check = MAX_SIZE_T;
3742  }
3743 
3744  return (released != 0) ? 1 : 0;
3745 }

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().

◆ tmalloc_large()

static void* tmalloc_large ( mstate  m,
size_t  nb 
)
static

Definition at line 3751 of file SDL_malloc.c.

3752 {
3753  tchunkptr v = 0;
3754  size_t rsize = -nb; /* Unsigned negation */
3755  tchunkptr t;
3756  bindex_t idx;
3757  compute_tree_index(nb, idx);
3758 
3759  if ((t = *treebin_at(m, idx)) != 0) {
3760  /* Traverse tree for this bin looking for node with size == nb */
3761  size_t sizebits = nb << leftshift_for_tree_index(idx);
3762  tchunkptr rst = 0; /* The deepest untaken right subtree */
3763  for (;;) {
3764  tchunkptr rt;
3765  size_t trem = chunksize(t) - nb;
3766  if (trem < rsize) {
3767  v = t;
3768  if ((rsize = trem) == 0)
3769  break;
3770  }
3771  rt = t->child[1];
3772  t = t->child[(sizebits >> (SIZE_T_BITSIZE - SIZE_T_ONE)) & 1];
3773  if (rt != 0 && rt != t)
3774  rst = rt;
3775  if (t == 0) {
3776  t = rst; /* set t to least subtree holding sizes > nb */
3777  break;
3778  }
3779  sizebits <<= 1;
3780  }
3781  }
3782 
3783  if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */
3784  binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap;
3785  if (leftbits != 0) {
3786  bindex_t i;
3787  binmap_t leastbit = least_bit(leftbits);
3788  compute_bit2idx(leastbit, i);
3789  t = *treebin_at(m, i);
3790  }
3791  }
3792 
3793  while (t != 0) { /* find smallest of tree or subtree */
3794  size_t trem = chunksize(t) - nb;
3795  if (trem < rsize) {
3796  rsize = trem;
3797  v = t;
3798  }
3799  t = leftmost_child(t);
3800  }
3801 
3802  /* If dv is a better fit, return 0 so malloc will use it */
3803  if (v != 0 && rsize < (size_t) (m->dvsize - nb)) {
3804  if (RTCHECK(ok_address(m, v))) { /* split */
3805  mchunkptr r = chunk_plus_offset(v, nb);
3806  assert(chunksize(v) == rsize + nb);
3807  if (RTCHECK(ok_next(v, r))) {
3809  if (rsize < MIN_CHUNK_SIZE)
3810  set_inuse_and_pinuse(m, v, (rsize + nb));
3811  else {
3814  insert_chunk(m, r, rsize);
3815  }
3816  return chunk2mem(v);
3817  }
3818  }
3820  }
3821  return 0;
3822 }

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().

◆ tmalloc_small()

static void* tmalloc_small ( mstate  m,
size_t  nb 
)
static

Definition at line 3826 of file SDL_malloc.c.

3827 {
3828  tchunkptr t, v;
3829  size_t rsize;
3830  bindex_t i;
3831  binmap_t leastbit = least_bit(m->treemap);
3832  compute_bit2idx(leastbit, i);
3833 
3834  v = t = *treebin_at(m, i);
3835  rsize = chunksize(t) - nb;
3836 
3837  while ((t = leftmost_child(t)) != 0) {
3838  size_t trem = chunksize(t) - nb;
3839  if (trem < rsize) {
3840  rsize = trem;
3841  v = t;
3842  }
3843  }
3844 
3845  if (RTCHECK(ok_address(m, v))) {
3846  mchunkptr r = chunk_plus_offset(v, nb);
3847  assert(chunksize(v) == rsize + nb);
3848  if (RTCHECK(ok_next(v, r))) {
3850  if (rsize < MIN_CHUNK_SIZE)
3851  set_inuse_and_pinuse(m, v, (rsize + nb));
3852  else {
3855  replace_dv(m, r, rsize);
3856  }
3857  return chunk2mem(v);
3858  }
3859  }
3860 
3862  return 0;
3863 }

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().

◆ win32_acquire_lock()

static int win32_acquire_lock ( MLOCK_T sl)
static

Definition at line 1473 of file SDL_malloc.c.

1474 {
1475  for (;;) {
1476 #ifdef InterlockedCompareExchangePointer
1477  if (!InterlockedCompareExchange(sl, 1, 0))
1478  return 0;
1479 #else /* Use older void* version */
1480  if (!InterlockedCompareExchange((void **) sl, (void *) 1, (void *) 0))
1481  return 0;
1482 #endif /* InterlockedCompareExchangePointer */
1483  Sleep(0);
1484  }
1485 }

◆ win32_release_lock()

static void win32_release_lock ( MLOCK_T sl)
static

Definition at line 1488 of file SDL_malloc.c.

1489 {
1490  InterlockedExchange(sl, 0);
1491 }

◆ win32direct_mmap()

static void* win32direct_mmap ( size_t  size)
static

Definition at line 1381 of file SDL_malloc.c.

1382 {
1383  void *ptr = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
1384  PAGE_READWRITE);
1385  return (ptr != 0) ? ptr : MFAIL;
1386 }

References MFAIL.

◆ win32mmap()

static void* win32mmap ( size_t  size)
static

Definition at line 1372 of file SDL_malloc.c.

1373 {
1374  void *ptr =
1375  VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
1376  return (ptr != 0) ? ptr : MFAIL;
1377 }

References MFAIL.

◆ win32munmap()

static int win32munmap ( void ptr,
size_t  size 
)
static

Definition at line 1390 of file SDL_malloc.c.

1391 {
1392  MEMORY_BASIC_INFORMATION minfo;
1393  char *cptr = ptr;
1394  while (size) {
1395  if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
1396  return -1;
1397  if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
1398  minfo.State != MEM_COMMIT || minfo.RegionSize > size)
1399  return -1;
1400  if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
1401  return -1;
1402  cptr += minfo.RegionSize;
1403  size -= minfo.RegionSize;
1404  }
1405  return 0;
1406 }

Variable Documentation

◆ _gm_

struct malloc_state _gm_
static

Definition at line 2066 of file SDL_malloc.c.

◆ calloc_func

SDL_calloc_func calloc_func

Definition at line 5263 of file SDL_malloc.c.

Referenced by SDL_GetMemoryFunctions(), and SDL_SetMemoryFunctions().

◆ free_func

SDL_free_func free_func

Definition at line 5265 of file SDL_malloc.c.

Referenced by SDL_GetMemoryFunctions(), and SDL_SetMemoryFunctions().

◆ magic_init_mutex

MLOCK_T magic_init_mutex
static

Definition at line 1499 of file SDL_malloc.c.

◆ malloc_func

SDL_malloc_func malloc_func

Definition at line 5262 of file SDL_malloc.c.

Referenced by SDL_GetMemoryFunctions(), and SDL_SetMemoryFunctions().

◆ mparams

struct malloc_params mparams
static

◆ num_allocations

SDL_atomic_t num_allocations

Definition at line 5266 of file SDL_malloc.c.

◆ realloc_func

SDL_realloc_func realloc_func

Definition at line 5264 of file SDL_malloc.c.

Referenced by SDL_GetMemoryFunctions(), and SDL_SetMemoryFunctions().

◆ s_mem

compute_tree_index
#define compute_tree_index(S, I)
Definition: SDL_malloc.c:2290
mallinfo::fordblks
MALLINFO_FIELD_TYPE fordblks
Definition: SDL_malloc.c:677
segment_holding
static msegmentptr segment_holding(mstate m, char *addr)
Definition: SDL_malloc.c:2133
MFAIL
#define MFAIL
Definition: SDL_malloc.c:1331
use_mmap
#define use_mmap(M)
Definition: SDL_malloc.c:2102
set_free_with_pinuse
#define set_free_with_pinuse(p, s, n)
Definition: SDL_malloc.c:1760
offset
GLintptr offset
Definition: SDL_opengl_glext.h:538
time
EGLSurface EGLnsecsANDROID time
Definition: eglext.h:518
treebin_at
#define treebin_at(M, i)
Definition: SDL_malloc.c:2272
dlmalloc
void * dlmalloc(size_t)
Definition: SDL_malloc.c:4154
CALL_MUNMAP
#define CALL_MUNMAP(a, s)
Definition: SDL_malloc.c:1409
calloc_func
SDL_calloc_func calloc_func
Definition: SDL_malloc.c:5263
has_segment_link
static int has_segment_link(mstate m, msegmentptr ss)
Definition: SDL_malloc.c:2146
insert_chunk
#define insert_chunk(M, P, S)
Definition: SDL_malloc.c:3186
end
GLuint GLuint end
Definition: SDL_opengl.h:1571
request2size
#define request2size(req)
Definition: SDL_malloc.c:1711
chunk2mem
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
check_top_chunk
#define check_top_chunk(M, P)
Definition: SDL_malloc.c:2239
CORRUPTION_ERROR_ACTION
#define CORRUPTION_ERROR_ACTION(m)
Definition: SDL_malloc.c:2221
real_realloc
#define real_realloc
Definition: SDL_malloc.c:5255
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
malloc_params::magic
size_t magic
Definition: SDL_malloc.c:2078
dlmemalign
void * dlmemalign(size_t, size_t)
Definition: SDL_malloc.c:4427
binmap_t
unsigned int binmap_t
Definition: SDL_malloc.c:1674
malloc_func
SDL_malloc_func malloc_func
Definition: SDL_malloc.c:5262
MORECORE_CONTIGUOUS
#define MORECORE_CONTIGUOUS
Definition: SDL_malloc.c:575
is_mmapped
#define is_mmapped(p)
Definition: SDL_malloc.c:1763
gm
#define gm
Definition: SDL_malloc.c:2090
is_extern_segment
#define is_extern_segment(S)
Definition: SDL_malloc.c:1954
cp
static const double cp
Definition: e_pow.c:92
INUSE_BITS
#define INUSE_BITS
Definition: SDL_malloc.c:1727
CHUNK_ALIGN_MASK
#define CHUNK_ALIGN_MASK
Definition: SDL_malloc.c:1311
calloc_must_clear
#define calloc_must_clear(p)
Definition: SDL_malloc.c:1774
assert
#define assert(x)
Definition: SDL_malloc.c:1219
q
GLdouble GLdouble GLdouble GLdouble q
Definition: SDL_opengl.h:2087
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
real_malloc
#define real_malloc
Definition: SDL_malloc.c:5253
granularity_align
#define granularity_align(S)
Definition: SDL_malloc.c:2119
unlink_large_chunk
#define unlink_large_chunk(M, X)
Definition: SDL_malloc.c:3113
SDL_InvalidParamError
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
SIX_SIZE_T_SIZES
#define SIX_SIZE_T_SIZES
Definition: SDL_malloc.c:1307
SDL_AtomicIncRef
#define SDL_AtomicIncRef(a)
Increment an atomic variable used as a reference count.
Definition: SDL_atomic.h:234
MAX_SIZE_T
#define MAX_SIZE_T
Definition: SDL_malloc.c:518
malloc_params::trim_threshold
size_t trim_threshold
Definition: SDL_malloc.c:2082
change_mparam
static int change_mparam(int param_number, int value)
Definition: SDL_malloc.c:2569
real_calloc
#define real_calloc
Definition: SDL_malloc.c:5254
IS_MMAPPED_BIT
#define IS_MMAPPED_BIT
Definition: SDL_malloc.c:1342
left_bits
#define left_bits(x)
Definition: SDL_malloc.c:2371
MAX_SMALL_REQUEST
#define MAX_SMALL_REQUEST
Definition: SDL_malloc.c:2042
page_align
#define page_align(S)
Definition: SDL_malloc.c:2115
segment_holds
#define segment_holds(S, A)
Definition: SDL_malloc.c:2128
sys_trim
static int sys_trim(mstate m, size_t pad)
Definition: SDL_malloc.c:3685
malloc_params::page_size
size_t page_size
Definition: SDL_malloc.c:2079
CMFAIL
#define CMFAIL
Definition: SDL_malloc.c:1332
x1
GLuint GLfloat GLfloat GLfloat x1
Definition: SDL_opengl_glext.h:8583
a
GLboolean GLboolean GLboolean GLboolean a
Definition: SDL_opengl_glext.h:1109
v
const GLdouble * v
Definition: SDL_opengl.h:2064
init_bins
static void init_bins(mstate m)
Definition: SDL_malloc.c:3312
memcpy
#define memcpy
Definition: SDL_malloc.c:622
release_unused_segments
static size_t release_unused_segments(mstate m)
Definition: SDL_malloc.c:3644
check_free_chunk
#define check_free_chunk(M, P)
Definition: SDL_malloc.c:2234
RTCHECK
#define RTCHECK(e)
Definition: SDL_malloc.c:2435
RELEASE_MAGIC_INIT_LOCK
#define RELEASE_MAGIC_INIT_LOCK()
Definition: SDL_malloc.c:1518
next_chunk
#define next_chunk(p)
Definition: SDL_malloc.c:1745
malloc_segment
Definition: SDL_malloc.c:1946
result
GLuint64EXT * result
Definition: SDL_opengl_glext.h:9432
NTREEBINS
#define NTREEBINS
Definition: SDL_malloc.c:2036
mem2chunk
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
pinuse
#define pinuse(p)
Definition: SDL_malloc.c:1734
CINUSE_BIT
#define CINUSE_BIT
Definition: SDL_malloc.c:1726
USE_NONCONTIGUOUS_BIT
#define USE_NONCONTIGUOUS_BIT
Definition: SDL_malloc.c:1427
fm
#define fm
overhead_for
#define overhead_for(p)
Definition: SDL_malloc.c:1767
SDL_AtomicDecRef
#define SDL_AtomicDecRef(a)
Decrement an atomic variable used as a reference count.
Definition: SDL_atomic.h:244
tmalloc_large
static void * tmalloc_large(mstate m, size_t nb)
Definition: SDL_malloc.c:3751
set_size_and_pinuse_of_free_chunk
#define set_size_and_pinuse_of_free_chunk(p, s)
Definition: SDL_malloc.c:1756
USAGE_ERROR_ACTION
#define USAGE_ERROR_ACTION(m, p)
Definition: SDL_malloc.c:2225
unlink_first_small_chunk
#define unlink_first_small_chunk(M, B, P, I)
Definition: SDL_malloc.c:3013
flag_t
unsigned int flag_t
Definition: SDL_malloc.c:1675
PINUSE_BIT
#define PINUSE_BIT
Definition: SDL_malloc.c:1725
insert_small_chunk
#define insert_small_chunk(M, P, S)
Definition: SDL_malloc.c:2974
ABORT
#define ABORT
Definition: SDL_malloc.c:39
MALLOC_ALIGNMENT
#define MALLOC_ALIGNMENT
Definition: SDL_malloc.c:531
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: SDL_opengl_glext.h:2480
set_size_and_pinuse_of_inuse_chunk
#define set_size_and_pinuse_of_inuse_chunk(M, p, s)
Definition: SDL_malloc.c:2458
is_small
#define is_small(s)
Definition: SDL_malloc.c:2265
HAVE_MMAP
#define HAVE_MMAP
Definition: SDL_malloc.c:491
p
GLfloat GLfloat p
Definition: SDL_opengl_glext.h:11090
add_segment
static void add_segment(mstate m, char *tbase, size_t tsize, flag_t mmapped)
Definition: SDL_malloc.c:3387
NSMALLBINS
#define NSMALLBINS
Definition: SDL_malloc.c:2035
FOUR_SIZE_T_SIZES
#define FOUR_SIZE_T_SIZES
Definition: SDL_malloc.c:1306
chunksize
#define chunksize(p)
Definition: SDL_malloc.c:1735
unlink_chunk
#define unlink_chunk(M, P, S)
Definition: SDL_malloc.c:3190
check_malloc_state
#define check_malloc_state(M)
Definition: SDL_malloc.c:2238
init_top
static void init_top(mstate m, mchunkptr p, size_t psize)
Definition: SDL_malloc.c:3295
internal_realloc
static void * internal_realloc(mstate m, void *oldmem, size_t bytes)
Definition: SDL_malloc.c:3868
check_mmapped_chunk
#define check_mmapped_chunk(M, P)
Definition: SDL_malloc.c:2237
t
GLdouble GLdouble t
Definition: SDL_opengl.h:2071
init_mparams
static int init_mparams(void)
Definition: SDL_malloc.c:2491
enable_mmap
#define enable_mmap(M)
Definition: SDL_malloc.c:2103
mallinfo::hblkhd
MALLINFO_FIELD_TYPE hblkhd
Definition: SDL_malloc.c:673
sys_alloc
static void * sys_alloc(mstate m, size_t nb)
Definition: SDL_malloc.c:3444
MMAP_FOOT_PAD
#define MMAP_FOOT_PAD
Definition: SDL_malloc.c:1690
bindex_t
size_t bindex_t
Definition: SDL_malloc.c:1673
check_inuse_chunk
#define check_inuse_chunk(M, P)
Definition: SDL_malloc.c:2235
SIZE_T_BITSIZE
#define SIZE_T_BITSIZE
Definition: SDL_malloc.c:1298
free_func
SDL_free_func free_func
Definition: SDL_malloc.c:5265
DEFAULT_MMAP_THRESHOLD
#define DEFAULT_MMAP_THRESHOLD
Definition: SDL_malloc.c:600
I
#define I(x, y, z)
Definition: SDL_test_md5.c:76
s_mem
static struct @31 s_mem
mallinfo::ordblks
MALLINFO_FIELD_TYPE ordblks
Definition: SDL_malloc.c:670
insert_large_chunk
#define insert_large_chunk(M, X, S)
Definition: SDL_malloc.c:3045
head
SDL_EventEntry * head
Definition: SDL_events.c:82
pad_request
#define pad_request(req)
Definition: SDL_malloc.c:1707
set_inuse_and_pinuse
#define set_inuse_and_pinuse(M, p, s)
Definition: SDL_malloc.c:2453
addr
GLenum const void * addr
Definition: SDL_opengl_glext.h:7945
set_inuse
#define set_inuse(M, p, s)
Definition: SDL_malloc.c:2448
chunk_minus_offset
#define chunk_minus_offset(p, s)
Definition: SDL_malloc.c:1742
mallinfo::uordblks
MALLINFO_FIELD_TYPE uordblks
Definition: SDL_malloc.c:676
is_global
#define is_global(M)
Definition: SDL_malloc.c:2091
F
#define F(x, y, z)
Definition: SDL_test_md5.c:73
small_index
#define small_index(s)
Definition: SDL_malloc.c:2266
HALF_MAX_SIZE_T
#define HALF_MAX_SIZE_T
Definition: SDL_malloc.c:1308
malloc_params::default_mflags
flag_t default_mflags
Definition: SDL_malloc.c:2083
mallinfo::usmblks
MALLINFO_FIELD_TYPE usmblks
Definition: SDL_malloc.c:674
disable_contiguous
#define disable_contiguous(M)
Definition: SDL_malloc.c:2107
M_GRANULARITY
#define M_GRANULARITY
Definition: SDL_malloc.c:633
size_t
unsigned int size_t
Definition: SDL_config_windows.h:68
ok_address
#define ok_address(M, a)
Definition: SDL_malloc.c:2407
ok_pinuse
#define ok_pinuse(p)
Definition: SDL_malloc.c:2413
internal_free
#define internal_free(m, mem)
Definition: SDL_malloc.c:3208
size
GLsizeiptr size
Definition: SDL_opengl_glext.h:537
tmalloc_small
static void * tmalloc_small(mstate m, size_t nb)
Definition: SDL_malloc.c:3826
sizes
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
Definition: SDL_opengl_glext.h:2561
ok_magic
#define ok_magic(M)
Definition: SDL_malloc.c:2426
mmap_resize
static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb)
Definition: SDL_malloc.c:3256
internal_malloc_stats
static void internal_malloc_stats(mstate m)
Definition: SDL_malloc.c:2925
DEFAULT_TRIM_THRESHOLD
#define DEFAULT_TRIM_THRESHOLD
Definition: SDL_malloc.c:593
least_bit
#define least_bit(x)
Definition: SDL_malloc.c:2368
m
const GLfloat * m
Definition: SDL_opengl_glext.h:6092
use_noncontiguous
#define use_noncontiguous(M)
Definition: SDL_malloc.c:2106
MIN_CHUNK_SIZE
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
idx2bit
#define idx2bit(i)
Definition: SDL_malloc.c:2327
cinuse
#define cinuse(p)
Definition: SDL_malloc.c:1733
chunk_plus_offset
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
is_initialized
#define is_initialized(M)
Definition: SDL_malloc.c:2092
memset
#define memset
Definition: SDL_malloc.c:619
value
GLsizei const GLfloat * value
Definition: SDL_opengl_glext.h:698
mparams
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
val
GLuint GLfloat * val
Definition: SDL_opengl_glext.h:1492
x2
GLfixed GLfixed x2
Definition: SDL_opengl_glext.h:4583
check_malloced_chunk
#define check_malloced_chunk(M, P, N)
Definition: SDL_malloc.c:2236
leftmost_child
#define leftmost_child(t)
Definition: SDL_malloc.c:1886
should_trim
#define should_trim(M, s)
Definition: SDL_malloc.c:2158
unlink_small_chunk
#define unlink_small_chunk(M, P, S)
Definition: SDL_malloc.c:2993
PREACTION
#define PREACTION(M)
Definition: SDL_malloc.c:2185
s
GLdouble s
Definition: SDL_opengl.h:2063
SIZE_T_ONE
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303
ialloc
static void ** ialloc(mstate m, size_t n_elements, size_t *sizes, int opts, void *chunks[])
Definition: SDL_malloc.c:4028
ACQUIRE_MORECORE_LOCK
#define ACQUIRE_MORECORE_LOCK()
Definition: SDL_malloc.c:1512
ACQUIRE_MAGIC_INIT_LOCK
#define ACQUIRE_MAGIC_INIT_LOCK()
Definition: SDL_malloc.c:1517
DIRECT_MMAP
#define DIRECT_MMAP(s)
Definition: SDL_malloc.c:1410
internal_mallinfo
static struct mallinfo internal_mallinfo(mstate m)
Definition: SDL_malloc.c:2884
MAX_REQUEST
#define MAX_REQUEST
Definition: SDL_malloc.c:1703
replace_dv
#define replace_dv(M, P, S)
Definition: SDL_malloc.c:3031
MCHUNK_SIZE
#define MCHUNK_SIZE
Definition: SDL_malloc.c:1679
M_TRIM_THRESHOLD
#define M_TRIM_THRESHOLD
Definition: SDL_malloc.c:632
internal_malloc
#define internal_malloc(m, b)
Definition: SDL_malloc.c:3207
is_aligned
#define is_aligned(A)
Definition: SDL_malloc.c:1314
mallinfo::arena
MALLINFO_FIELD_TYPE arena
Definition: SDL_malloc.c:669
small_index2size
#define small_index2size(i)
Definition: SDL_malloc.c:2267
smallbin_at
#define smallbin_at(M, i)
Definition: SDL_malloc.c:2271
realloc_func
SDL_realloc_func realloc_func
Definition: SDL_malloc.c:5264
mallinfo::keepcost
MALLINFO_FIELD_TYPE keepcost
Definition: SDL_malloc.c:678
CALL_MMAP
#define CALL_MMAP(s)
Definition: SDL_malloc.c:1408
MALLOC_FAILURE_ACTION
#define MALLOC_FAILURE_ACTION
Definition: SDL_malloc.c:501
HAVE_MORECORE
#define HAVE_MORECORE
Definition: SDL_malloc.c:492
malloc_params::mmap_threshold
size_t mmap_threshold
Definition: SDL_malloc.c:2081
USE_LOCK_BIT
#define USE_LOCK_BIT
Definition: SDL_malloc.c:1502
internal_memalign
static void * internal_memalign(mstate m, size_t alignment, size_t bytes)
Definition: SDL_malloc.c:3938
is_mmapped_segment
#define is_mmapped_segment(S)
Definition: SDL_malloc.c:1953
mark_inuse_foot
#define mark_inuse_foot(M, p, s)
Definition: SDL_malloc.c:2445
dlfree
void dlfree(void *)
Definition: SDL_malloc.c:4288
align_as_chunk
#define align_as_chunk(A)
Definition: SDL_malloc.c:1700
INITIAL_LOCK
#define INITIAL_LOCK(l)
Definition: SDL_malloc.c:1493
malloc_params::granularity
size_t granularity
Definition: SDL_malloc.c:2080
RELEASE_MORECORE_LOCK
#define RELEASE_MORECORE_LOCK()
Definition: SDL_malloc.c:1513
align_offset
#define align_offset(A)
Definition: SDL_malloc.c:1317
SDL_AtomicGet
#define SDL_AtomicGet
Definition: SDL_dynapi_overrides.h:68
compute_bit2idx
#define compute_bit2idx(X, I)
Definition: SDL_malloc.c:2353
fd
GLuint64 GLenum GLint fd
Definition: gl2ext.h:1508
void
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
Definition: SDL_dynapi_procs.h:89
POSTACTION
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
ok_cinuse
#define ok_cinuse(p)
Definition: SDL_malloc.c:2411
prepend_alloc
static void * prepend_alloc(mstate m, char *newbase, char *oldbase, size_t nb)
Definition: SDL_malloc.c:3345
ok_next
#define ok_next(p, n)
Definition: SDL_malloc.c:2409
leftshift_for_tree_index
#define leftshift_for_tree_index(i)
Definition: SDL_malloc.c:2314
real_free
#define real_free
Definition: SDL_malloc.c:5256
disable_mmap
#define disable_mmap(M)
Definition: SDL_malloc.c:2104
TREEBIN_SHIFT
#define TREEBIN_SHIFT
Definition: SDL_malloc.c:2039
mallinfo
Definition: SDL_malloc.c:668
mmap_alloc
static void * mmap_alloc(mstate m, size_t nb)
Definition: SDL_malloc.c:3226
FENCEPOST_HEAD
#define FENCEPOST_HEAD
Definition: SDL_malloc.c:1730
M_MMAP_THRESHOLD
#define M_MMAP_THRESHOLD
Definition: SDL_malloc.c:634
i
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
TOP_FOOT_SIZE
#define TOP_FOOT_SIZE
Definition: SDL_malloc.c:2168
CHUNK_OVERHEAD
#define CHUNK_OVERHEAD
Definition: SDL_malloc.c:1684
CALL_MREMAP
#define CALL_MREMAP(addr, osz, nsz, mv)
Definition: SDL_malloc.c:1417
SIZE_T_SIZE
#define SIZE_T_SIZE
Definition: SDL_malloc.c:1297
CALL_MORECORE
#define CALL_MORECORE(S)
Definition: SDL_malloc.c:1423
DEFAULT_GRANULARITY
#define DEFAULT_GRANULARITY
Definition: SDL_malloc.c:588
MIN_REQUEST
#define MIN_REQUEST
Definition: SDL_malloc.c:1704
is_page_aligned
#define is_page_aligned(S)
Definition: SDL_malloc.c:2122
smallmap_is_marked
#define smallmap_is_marked(M, i)
Definition: SDL_malloc.c:2332
USE_MMAP_BIT
#define USE_MMAP_BIT
Definition: SDL_malloc.c:1343