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.

Referenced by init_mparams().

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

Referenced by init_mparams().

◆ ACQUIRE_MORECORE_LOCK

#define ACQUIRE_MORECORE_LOCK ( )

Definition at line 1512 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

◆ align_as_chunk

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

◆ align_offset

#define align_offset (   A)
Value:
((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\
#define CHUNK_ALIGN_MASK
Definition: SDL_malloc.c:1311
unsigned int size_t
#define MALLOC_ALIGNMENT
Definition: SDL_malloc.c:531

Definition at line 1317 of file SDL_malloc.c.

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

◆ assert

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

Referenced by dlmallopt(), and sys_alloc().

◆ CALL_MORECORE

#define CALL_MORECORE (   S)    MFAIL

Definition at line 1423 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

◆ CALL_MREMAP

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

Definition at line 1417 of file SDL_malloc.c.

Referenced by mmap_resize(), and sys_trim().

◆ CALL_MUNMAP

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

Definition at line 1409 of file SDL_malloc.c.

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

◆ calloc_must_clear

#define calloc_must_clear (   p)    (1)

Definition at line 1774 of file SDL_malloc.c.

Referenced by dlcalloc(), and dlmallopt().

◆ check_free_chunk

#define check_free_chunk (   M,
 
)

Definition at line 2234 of file SDL_malloc.c.

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

◆ check_inuse_chunk

#define check_inuse_chunk (   M,
 
)

Definition at line 2235 of file SDL_malloc.c.

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

◆ check_malloc_state

#define check_malloc_state (   M)

Definition at line 2238 of file SDL_malloc.c.

Referenced by internal_mallinfo(), and internal_malloc_stats().

◆ check_malloced_chunk

#define check_malloced_chunk (   M,
  P,
 
)

Definition at line 2236 of file SDL_malloc.c.

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

◆ check_mmapped_chunk

#define check_mmapped_chunk (   M,
 
)

Definition at line 2237 of file SDL_malloc.c.

Referenced by mmap_alloc(), and mmap_resize().

◆ check_top_chunk

#define check_top_chunk (   M,
 
)

Definition at line 2239 of file SDL_malloc.c.

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

◆ chunk2mem

◆ CHUNK_ALIGN_MASK

#define CHUNK_ALIGN_MASK   (MALLOC_ALIGNMENT - SIZE_T_ONE)

Definition at line 1311 of file SDL_malloc.c.

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

◆ chunk_minus_offset

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

Definition at line 1742 of file SDL_malloc.c.

Referenced by dlfree(), and dlmallopt().

◆ CHUNK_OVERHEAD

#define CHUNK_OVERHEAD   (SIZE_T_SIZE)

Definition at line 1684 of file SDL_malloc.c.

Referenced by ialloc(), and internal_memalign().

◆ chunk_plus_offset

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

◆ chunksize

◆ cinuse

◆ CINUSE_BIT

#define CINUSE_BIT   (SIZE_T_TWO)

Definition at line 1726 of file SDL_malloc.c.

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

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

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

◆ 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);\
}
size_t bindex_t
Definition: SDL_malloc.c:1673

Definition at line 2353 of file SDL_malloc.c.

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

◆ 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));\
}\
}
#define TREEBIN_SHIFT
Definition: SDL_malloc.c:2039
#define NTREEBINS
Definition: SDL_malloc.c:2036

Definition at line 2290 of file SDL_malloc.c.

Referenced by change_mparam(), and tmalloc_large().

◆ CORRUPTION_ERROR_ACTION

#define CORRUPTION_ERROR_ACTION (   m)    ABORT

Definition at line 2221 of file SDL_malloc.c.

Referenced by tmalloc_large(), and tmalloc_small().

◆ DEFAULT_GRANULARITY

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

Definition at line 588 of file SDL_malloc.c.

Referenced by init_mparams().

◆ DEFAULT_MMAP_THRESHOLD

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

Definition at line 600 of file SDL_malloc.c.

Referenced by init_mparams().

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

Referenced by init_mparams().

◆ DIRECT_MMAP

#define DIRECT_MMAP (   s)    win32direct_mmap(s)

Definition at line 1410 of file SDL_malloc.c.

Referenced by mmap_alloc().

◆ disable_contiguous

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

Definition at line 2107 of file SDL_malloc.c.

Referenced by dlmallopt(), and sys_alloc().

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

Referenced by ialloc().

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

Referenced by ialloc().

◆ EXTERN_BIT

#define EXTERN_BIT   (8U)

Definition at line 1430 of file SDL_malloc.c.

Referenced by dlmallopt().

◆ FENCEPOST_HEAD

#define FENCEPOST_HEAD   (INUSE_BITS|SIZE_T_SIZE)

◆ fm

#define fm   gm

Referenced by dlfree(), and dlmallopt().

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

Referenced by add_segment().

◆ 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

◆ granularity_align

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

Definition at line 2119 of file SDL_malloc.c.

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

◆ HALF_MAX_SIZE_T

#define HALF_MAX_SIZE_T   (MAX_SIZE_T / 2U)

Definition at line 1308 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

◆ HAVE_MMAP

#define HAVE_MMAP   1

Definition at line 491 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

◆ HAVE_MORECORE

#define HAVE_MORECORE   0

Definition at line 492 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

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

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

◆ INITIAL_LOCK

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

Definition at line 1493 of file SDL_malloc.c.

Referenced by dlmallopt(), and init_mparams().

◆ 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); }
#define insert_small_chunk(M, P, S)
Definition: SDL_malloc.c:2974
#define is_small(s)
Definition: SDL_malloc.c:2265
#define insert_large_chunk(M, X, S)
Definition: SDL_malloc.c:3045

Definition at line 3186 of file SDL_malloc.c.

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

◆ insert_large_chunk

#define insert_large_chunk (   M,
  X,
 
)

Definition at line 3045 of file SDL_malloc.c.

Referenced by release_unused_segments().

◆ 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;\
}
#define RTCHECK(e)
Definition: SDL_malloc.c:2435
#define smallbin_at(M, i)
Definition: SDL_malloc.c:2271
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
#define I(x, y, z)
Definition: SDL_test_md5.c:76
#define small_index(s)
Definition: SDL_malloc.c:2266
#define F(x, y, z)
Definition: SDL_test_md5.c:73
#define smallmap_is_marked(M, i)
Definition: SDL_malloc.c:2332
#define ok_address(M, a)
Definition: SDL_malloc.c:2407

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.

Referenced by internal_memalign(), and internal_realloc().

◆ internal_malloc

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

Definition at line 3207 of file SDL_malloc.c.

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

◆ INUSE_BITS

#define INUSE_BITS   (PINUSE_BIT|CINUSE_BIT)

Definition at line 1727 of file SDL_malloc.c.

Referenced by dlfree(), and dlmallopt().

◆ is_aligned

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

Definition at line 1314 of file SDL_malloc.c.

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

◆ is_extern_segment

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

Definition at line 1954 of file SDL_malloc.c.

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

◆ is_global

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

Definition at line 2091 of file SDL_malloc.c.

Referenced by sys_alloc().

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

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

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

◆ IS_MMAPPED_BIT

#define IS_MMAPPED_BIT   (SIZE_T_ONE)

Definition at line 1342 of file SDL_malloc.c.

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

◆ is_mmapped_segment

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

Definition at line 1953 of file SDL_malloc.c.

Referenced by release_unused_segments(), and sys_trim().

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

Referenced by sys_alloc().

◆ is_small

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

Definition at line 2265 of file SDL_malloc.c.

Referenced by change_mparam(), and mmap_resize().

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

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

◆ left_bits

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

Definition at line 2371 of file SDL_malloc.c.

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

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

Referenced by tmalloc_large(), and tmalloc_small().

◆ 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)))
#define TREEBIN_SHIFT
Definition: SDL_malloc.c:2039
#define NTREEBINS
Definition: SDL_malloc.c:2036
#define SIZE_T_BITSIZE
Definition: SDL_malloc.c:1298
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
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303

Definition at line 2314 of file SDL_malloc.c.

Referenced by change_mparam(), and tmalloc_large().

◆ M_GRANULARITY

#define M_GRANULARITY   (-2)

Definition at line 633 of file SDL_malloc.c.

Referenced by change_mparam().

◆ M_MMAP_THRESHOLD

#define M_MMAP_THRESHOLD   (-3)

Definition at line 634 of file SDL_malloc.c.

Referenced by change_mparam().

◆ M_TRIM_THRESHOLD

#define M_TRIM_THRESHOLD   (-1)

Definition at line 632 of file SDL_malloc.c.

Referenced by change_mparam().

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

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

◆ MALLOC_FAILURE_ACTION

#define MALLOC_FAILURE_ACTION

Definition at line 501 of file SDL_malloc.c.

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

◆ mark_inuse_foot

#define mark_inuse_foot (   M,
  p,
  s 
)

Definition at line 2445 of file SDL_malloc.c.

Referenced by mmap_alloc(), and mmap_resize().

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

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

◆ MAX_SIZE_T

#define MAX_SIZE_T   (~(size_t)0)

Definition at line 518 of file SDL_malloc.c.

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

◆ MAX_SMALL_REQUEST

#define MAX_SMALL_REQUEST   (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)

Definition at line 2042 of file SDL_malloc.c.

Referenced by dlmalloc(), and dlmallopt().

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

Referenced by init_mparams().

◆ mem2chunk

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

◆ memcpy

#define memcpy   SDL_memcpy

Definition at line 622 of file SDL_malloc.c.

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

◆ memset

#define memset   SDL_memset

Definition at line 619 of file SDL_malloc.c.

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

◆ MFAIL

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

Definition at line 1331 of file SDL_malloc.c.

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

◆ MIN_CHUNK_SIZE

◆ MIN_LARGE_SIZE

#define MIN_LARGE_SIZE   (SIZE_T_ONE << TREEBIN_SHIFT)

Definition at line 2040 of file SDL_malloc.c.

Referenced by change_mparam().

◆ MIN_REQUEST

#define MIN_REQUEST   (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)

Definition at line 1704 of file SDL_malloc.c.

Referenced by dlmalloc(), and dlmallopt().

◆ 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)))
#define TREEBIN_SHIFT
Definition: SDL_malloc.c:2039
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
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303

Definition at line 2319 of file SDL_malloc.c.

Referenced by change_mparam().

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

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

◆ MORECORE_CONTIGUOUS

#define MORECORE_CONTIGUOUS   0

Definition at line 575 of file SDL_malloc.c.

Referenced by sys_alloc().

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

◆ next_pinuse

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

Definition at line 1749 of file SDL_malloc.c.

Referenced by change_mparam().

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

Referenced by change_mparam(), and init_bins().

◆ NTREEBINS

#define NTREEBINS   (32U)

Definition at line 2036 of file SDL_malloc.c.

Referenced by change_mparam(), and init_bins().

◆ ok_address

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

◆ ok_cinuse

#define ok_cinuse (   p)    cinuse(p)

Definition at line 2411 of file SDL_malloc.c.

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

◆ ok_magic

#define ok_magic (   M)    (1)

Definition at line 2426 of file SDL_malloc.c.

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

◆ ok_next

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

Definition at line 2409 of file SDL_malloc.c.

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

◆ ok_pinuse

#define ok_pinuse (   p)    pinuse(p)

Definition at line 2413 of file SDL_malloc.c.

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

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

Referenced by dlmalloc_usable_size(), and internal_realloc().

◆ pad_request

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

Definition at line 1707 of file SDL_malloc.c.

Referenced by add_segment(), dlmalloc(), and dlmallopt().

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

Referenced by sys_alloc().

◆ pinuse

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

Definition at line 1734 of file SDL_malloc.c.

Referenced by change_mparam(), dlfree(), dlmallopt(), and prepend_alloc().

◆ PINUSE_BIT

#define PINUSE_BIT   (SIZE_T_ONE)

◆ POSTACTION

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

◆ PREACTION

◆ prev_chunk

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

Definition at line 1746 of file SDL_malloc.c.

Referenced by change_mparam().

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

Referenced by init_mparams().

◆ RELEASE_MORECORE_LOCK

#define RELEASE_MORECORE_LOCK ( )

Definition at line 1513 of file SDL_malloc.c.

Referenced by sys_alloc(), and sys_trim().

◆ 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;\
}
#define is_small(s)
Definition: SDL_malloc.c:2265

Definition at line 3031 of file SDL_malloc.c.

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

◆ request2size

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

Definition at line 1711 of file SDL_malloc.c.

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

◆ RTCHECK

#define RTCHECK (   e)    (e)

Definition at line 2435 of file SDL_malloc.c.

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

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

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

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

◆ 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)
GLdouble s
Definition: SDL_opengl.h:2063
GLfloat GLfloat p
#define CINUSE_BIT
Definition: SDL_malloc.c:1726
SDL_EventEntry * head
Definition: SDL_events.c:82
#define PINUSE_BIT
Definition: SDL_malloc.c:1725

Definition at line 2448 of file SDL_malloc.c.

Referenced by internal_memalign(), and internal_realloc().

◆ set_inuse_and_pinuse

#define set_inuse_and_pinuse (   M,
  p,
  s 
)
Value:
((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)
GLdouble s
Definition: SDL_opengl.h:2063
GLfloat GLfloat p
#define CINUSE_BIT
Definition: SDL_malloc.c:1726
SDL_EventEntry * head
Definition: SDL_events.c:82
#define PINUSE_BIT
Definition: SDL_malloc.c:1725

Definition at line 2453 of file SDL_malloc.c.

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

◆ set_lock

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

Definition at line 2109 of file SDL_malloc.c.

Referenced by dlmallopt().

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

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

◆ set_size_and_pinuse_of_inuse_chunk

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

◆ should_trim

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

Definition at line 2158 of file SDL_malloc.c.

Referenced by dlfree(), and dlmallopt().

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

Referenced by mmap_alloc(), and mmap_resize().

◆ SIZE_T_BITSIZE

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

Definition at line 1298 of file SDL_malloc.c.

Referenced by change_mparam(), and tmalloc_large().

◆ SIZE_T_ONE

#define SIZE_T_ONE   ((size_t)1)

◆ SIZE_T_SIZE

#define SIZE_T_SIZE   (sizeof(size_t))

◆ SIZE_T_TWO

#define SIZE_T_TWO   ((size_t)2)

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.

Referenced by change_mparam(), dlmalloc(), and dlmallopt().

◆ small_index2size

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

Definition at line 2267 of file SDL_malloc.c.

Referenced by dlmalloc(), and dlmallopt().

◆ smallbin_at

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

Definition at line 2271 of file SDL_malloc.c.

Referenced by change_mparam(), dlmalloc(), dlmallopt(), and init_bins().

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

Referenced by change_mparam().

◆ TOP_FOOT_SIZE

◆ treebin_at

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

Definition at line 2272 of file SDL_malloc.c.

Referenced by change_mparam(), init_bins(), tmalloc_large(), and tmalloc_small().

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

Referenced by change_mparam().

◆ 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); }
#define unlink_large_chunk(M, X)
Definition: SDL_malloc.c:3113
#define unlink_small_chunk(M, P, S)
Definition: SDL_malloc.c:2993
#define is_small(s)
Definition: SDL_malloc.c:2265

Definition at line 3190 of file SDL_malloc.c.

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

◆ 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);\
}\
}
#define RTCHECK(e)
Definition: SDL_malloc.c:2435
#define small_index2size(i)
Definition: SDL_malloc.c:2267
#define I(x, y, z)
Definition: SDL_test_md5.c:76
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define F(x, y, z)
Definition: SDL_test_md5.c:73
#define ok_address(M, a)
Definition: SDL_malloc.c:2407

Definition at line 3013 of file SDL_malloc.c.

Referenced by dlmalloc(), and dlmallopt().

◆ unlink_large_chunk

#define unlink_large_chunk (   M,
 
)

Definition at line 3113 of file SDL_malloc.c.

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

◆ 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);\
}\
}
#define RTCHECK(e)
Definition: SDL_malloc.c:2435
#define smallbin_at(M, i)
Definition: SDL_malloc.c:2271
#define small_index2size(i)
Definition: SDL_malloc.c:2267
#define I(x, y, z)
Definition: SDL_test_md5.c:76
#define small_index(s)
Definition: SDL_malloc.c:2266
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define F(x, y, z)
Definition: SDL_test_md5.c:73
#define ok_address(M, a)
Definition: SDL_malloc.c:2407

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.

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

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

Referenced by init_mparams().

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

Referenced by change_mparam(), ialloc(), and sys_alloc().

◆ USE_MMAP_BIT

#define USE_MMAP_BIT   (SIZE_T_ONE)

Definition at line 1343 of file SDL_malloc.c.

Referenced by init_mparams().

◆ use_noncontiguous

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

Definition at line 2106 of file SDL_malloc.c.

Referenced by sys_alloc().

◆ USE_NONCONTIGUOUS_BIT

#define USE_NONCONTIGUOUS_BIT   (4U)

Definition at line 1427 of file SDL_malloc.c.

Referenced by init_mparams().

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

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

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 }
#define insert_chunk(M, P, S)
Definition: SDL_malloc.c:3186
GLdouble GLdouble GLdouble GLdouble q
Definition: SDL_opengl.h:2087
GLfloat GLfloat p
const GLfloat * m
#define FENCEPOST_HEAD
Definition: SDL_malloc.c:1730
#define set_free_with_pinuse(p, s, n)
Definition: SDL_malloc.c:1760
GLintptr offset
#define assert(x)
Definition: SDL_malloc.c:1219
#define SIZE_T_SIZE
Definition: SDL_malloc.c:1297
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define FOUR_SIZE_T_SIZES
Definition: SDL_malloc.c:1306
#define CHUNK_ALIGN_MASK
Definition: SDL_malloc.c:1311
#define is_aligned(A)
Definition: SDL_malloc.c:1314
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
static void init_top(mstate m, mchunkptr p, size_t psize)
Definition: SDL_malloc.c:3295
static msegmentptr segment_holding(mstate m, char *addr)
Definition: SDL_malloc.c:2133
#define pad_request(req)
Definition: SDL_malloc.c:1707
#define align_offset(A)
Definition: SDL_malloc.c:1317
#define TOP_FOOT_SIZE
Definition: SDL_malloc.c:2168
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
#define check_top_chunk(M, P)
Definition: SDL_malloc.c:2239
#define set_size_and_pinuse_of_inuse_chunk(M, p, s)
Definition: SDL_malloc.c:2458

◆ change_mparam()

static int change_mparam ( int  param_number,
int  value 
)
static

Definition at line 2569 of file SDL_malloc.c.

References align_as_chunk, assert, sbinptr::bk, chunk2mem, CHUNK_ALIGN_MASK, chunk_plus_offset, chunksize, cinuse, CINUSE_BIT, compute_tree_index, FENCEPOST_HEAD, mstate::footprint, malloc_params::granularity, head, i, init_mparams(), is_aligned, is_initialized, is_mmapped, IS_MMAPPED_BIT, is_small, leftshift_for_tree_index, M_GRANULARITY, M_MMAP_THRESHOLD, M_TRIM_THRESHOLD, mem2chunk, MIN_CHUNK_SIZE, MIN_LARGE_SIZE, minsize_for_tree_index, MMAP_FOOT_PAD, malloc_params::mmap_threshold, mparams, next_chunk, next_pinuse, NSMALLBINS, NTREEBINS, ok_address, malloc_params::page_size, pinuse, PINUSE_BIT, prev_chunk, segment_holding(), segment_holds, SIZE_T_BITSIZE, SIZE_T_ONE, SIZE_T_SIZE, small_index, smallbin_at, smallmap_is_marked, TOP_FOOT_SIZE, treebin_at, treemap_is_marked, malloc_params::trim_threshold, and use_mmap.

Referenced by dlmallopt().

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 }
#define M_MMAP_THRESHOLD
Definition: SDL_malloc.c:634
#define M_GRANULARITY
Definition: SDL_malloc.c:633
unsigned int size_t
GLuint GLfloat * val
size_t trim_threshold
Definition: SDL_malloc.c:2082
size_t page_size
Definition: SDL_malloc.c:2079
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
GLsizei const GLfloat * value
#define M_TRIM_THRESHOLD
Definition: SDL_malloc.c:632
size_t granularity
Definition: SDL_malloc.c:2080
static int init_mparams(void)
Definition: SDL_malloc.c:2491
size_t mmap_threshold
Definition: SDL_malloc.c:2081

◆ dlcalloc()

void * dlcalloc ( size_t  n_elements,
size_t  elem_size 
)

Definition at line 4385 of file SDL_malloc.c.

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

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 }
#define memset
Definition: SDL_malloc.c:619
void * dlmalloc(size_t)
Definition: SDL_malloc.c:4154
#define MAX_SIZE_T
Definition: SDL_malloc.c:518
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
#define calloc_must_clear(p)
Definition: SDL_malloc.c:1774

◆ dlfree()

void dlfree ( void mem)

Definition at line 4288 of file SDL_malloc.c.

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

Referenced by dlrealloc().

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)) {
4301  USAGE_ERROR_ACTION(fm, p);
4302  return;
4303  }
4304 #else /* FOOTERS */
4305 #define fm gm
4306 #endif /* FOOTERS */
4307  if (!PREACTION(fm)) {
4308  check_inuse_chunk(fm, p);
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:
4374  USAGE_ERROR_ACTION(fm, p);
4375  postaction:
4376  POSTACTION(fm);
4377  }
4378  }
4379 #if !FOOTERS
4380 #undef fm
4381 #endif /* FOOTERS */
4382 }
#define USAGE_ERROR_ACTION(m, p)
Definition: SDL_malloc.c:2225
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
#define fm
#define ok_cinuse(p)
Definition: SDL_malloc.c:2411
#define insert_chunk(M, P, S)
Definition: SDL_malloc.c:3186
#define cinuse(p)
Definition: SDL_malloc.c:1733
#define RTCHECK(e)
Definition: SDL_malloc.c:2435
GLfloat GLfloat p
#define set_free_with_pinuse(p, s, n)
Definition: SDL_malloc.c:1760
#define IS_MMAPPED_BIT
Definition: SDL_malloc.c:1342
#define ok_pinuse(p)
Definition: SDL_malloc.c:2413
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define CALL_MUNMAP(a, s)
Definition: SDL_malloc.c:1409
#define INUSE_BITS
Definition: SDL_malloc.c:1727
static int sys_trim(mstate m, size_t pad)
Definition: SDL_malloc.c:3685
#define check_inuse_chunk(M, P)
Definition: SDL_malloc.c:2235
#define unlink_chunk(M, P, S)
Definition: SDL_malloc.c:3190
#define ok_next(p, n)
Definition: SDL_malloc.c:2409
#define chunk_minus_offset(p, s)
Definition: SDL_malloc.c:1742
#define should_trim(M, s)
Definition: SDL_malloc.c:2158
#define PREACTION(M)
Definition: SDL_malloc.c:2185
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define MMAP_FOOT_PAD
Definition: SDL_malloc.c:1690
#define set_size_and_pinuse_of_free_chunk(p, s)
Definition: SDL_malloc.c:1756
#define pinuse(p)
Definition: SDL_malloc.c:1734
#define check_free_chunk(M, P)
Definition: SDL_malloc.c:2234
#define ok_address(M, a)
Definition: SDL_malloc.c:2407
#define PINUSE_BIT
Definition: SDL_malloc.c:1725
#define ok_magic(M)
Definition: SDL_malloc.c:2426

◆ dlindependent_calloc() [1/2]

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

◆ dlindependent_calloc() [2/2]

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

Definition at line 4433 of file SDL_malloc.c.

References gm, and ialloc().

4434 {
4435  size_t sz = elem_size; /* serves as 1-element array */
4436  return ialloc(gm, n_elements, &sz, 3, chunks);
4437 }
static void ** ialloc(mstate m, size_t n_elements, size_t *sizes, int opts, void *chunks[])
Definition: SDL_malloc.c:4028
#define gm
Definition: SDL_malloc.c:2090

◆ dlindependent_comalloc() [1/2]

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

◆ dlindependent_comalloc() [2/2]

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

Definition at line 4440 of file SDL_malloc.c.

References gm, and ialloc().

4441 {
4442  return ialloc(gm, n_elements, sizes, 0, chunks);
4443 }
static void ** ialloc(mstate m, size_t n_elements, size_t *sizes, int opts, void *chunks[])
Definition: SDL_malloc.c:4028
#define gm
Definition: SDL_malloc.c:2090
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes

◆ dlmallinfo()

struct mallinfo dlmallinfo ( void  )

Definition at line 4489 of file SDL_malloc.c.

References gm, and internal_mallinfo().

4490 {
4491  return internal_mallinfo(gm);
4492 }
#define gm
Definition: SDL_malloc.c:2090
static struct mallinfo internal_mallinfo(mstate m)
Definition: SDL_malloc.c:2884

◆ dlmalloc()

void * dlmalloc ( size_t  bytes)

Definition at line 4154 of file SDL_malloc.c.

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

Referenced by dlcalloc(), and dlrealloc().

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;
4213  assert(chunksize(p) == small_index2size(i));
4214  unlink_first_small_chunk(gm, b, p, i);
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 }
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
static void * sys_alloc(mstate m, size_t nb)
Definition: SDL_malloc.c:3444
size_t bindex_t
Definition: SDL_malloc.c:1673
static void * tmalloc_large(mstate m, size_t nb)
Definition: SDL_malloc.c:3751
#define smallbin_at(M, i)
Definition: SDL_malloc.c:2271
GLfloat GLfloat p
#define replace_dv(M, P, S)
Definition: SDL_malloc.c:3031
#define compute_bit2idx(X, I)
Definition: SDL_malloc.c:2353
#define assert(x)
Definition: SDL_malloc.c:1219
#define SIZE_T_SIZE
Definition: SDL_malloc.c:1297
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define small_index2size(i)
Definition: SDL_malloc.c:2267
#define MIN_REQUEST
Definition: SDL_malloc.c:1704
#define unlink_first_small_chunk(M, B, P, I)
Definition: SDL_malloc.c:3013
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
#define gm
Definition: SDL_malloc.c:2090
static void * tmalloc_small(mstate m, size_t nb)
Definition: SDL_malloc.c:3826
#define MAX_SIZE_T
Definition: SDL_malloc.c:518
#define idx2bit(i)
Definition: SDL_malloc.c:2327
#define MAX_SMALL_REQUEST
Definition: SDL_malloc.c:2042
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
#define PREACTION(M)
Definition: SDL_malloc.c:2185
#define check_malloced_chunk(M, P, N)
Definition: SDL_malloc.c:2236
#define left_bits(x)
Definition: SDL_malloc.c:2371
#define MAX_REQUEST
Definition: SDL_malloc.c:1703
#define small_index(s)
Definition: SDL_malloc.c:2266
#define chunksize(p)
Definition: SDL_malloc.c:1735
unsigned int binmap_t
Definition: SDL_malloc.c:1674
#define pad_request(req)
Definition: SDL_malloc.c:1707
#define set_size_and_pinuse_of_free_chunk(p, s)
Definition: SDL_malloc.c:1756
GLboolean GLboolean GLboolean b
#define least_bit(x)
Definition: SDL_malloc.c:2368
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
#define PINUSE_BIT
Definition: SDL_malloc.c:1725
#define check_top_chunk(M, P)
Definition: SDL_malloc.c:2239
#define set_size_and_pinuse_of_inuse_chunk(M, p, s)
Definition: SDL_malloc.c:2458
#define set_inuse_and_pinuse(M, p, s)
Definition: SDL_malloc.c:2453

◆ dlmalloc_footprint()

size_t dlmalloc_footprint ( void  )

Definition at line 4476 of file SDL_malloc.c.

References gm.

4477 {
4478  return gm->footprint;
4479 }
#define gm
Definition: SDL_malloc.c:2090

◆ dlmalloc_max_footprint()

size_t dlmalloc_max_footprint ( void  )

Definition at line 4482 of file SDL_malloc.c.

References gm.

4483 {
4484  return gm->max_footprint;
4485 }
#define gm
Definition: SDL_malloc.c:2090

◆ dlmalloc_stats()

void dlmalloc_stats ( void  )

Definition at line 4496 of file SDL_malloc.c.

References gm, and internal_malloc_stats().

4497 {
4499 }
#define gm
Definition: SDL_malloc.c:2090
static void internal_malloc_stats(mstate m)
Definition: SDL_malloc.c:2925

◆ dlmalloc_trim()

int dlmalloc_trim ( size_t  pad)

Definition at line 4465 of file SDL_malloc.c.

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

4466 {
4467  int result = 0;
4468  if (!PREACTION(gm)) {
4469  result = sys_trim(gm, pad);
4470  POSTACTION(gm);
4471  }
4472  return result;
4473 }
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
GLuint64EXT * result
static int sys_trim(mstate m, size_t pad)
Definition: SDL_malloc.c:3685
#define gm
Definition: SDL_malloc.c:2090
#define PREACTION(M)
Definition: SDL_malloc.c:2185

◆ dlmalloc_usable_size()

size_t dlmalloc_usable_size ( void mem)

Definition at line 4502 of file SDL_malloc.c.

References chunksize, cinuse, mem2chunk, and overhead_for.

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 }
#define cinuse(p)
Definition: SDL_malloc.c:1733
GLfloat GLfloat p
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define overhead_for(p)
Definition: SDL_malloc.c:1767

◆ dlmallopt()

int dlmallopt ( int  param_number,
int  value 
)

Definition at line 4513 of file SDL_malloc.c.

References align_as_chunk, assert, msegmentptr::base, CALL_MMAP, CALL_MUNMAP, calloc_must_clear, change_mparam(), check_free_chunk, check_inuse_chunk, check_malloced_chunk, check_top_chunk, chunk2mem, chunk_minus_offset, chunk_plus_offset, chunksize, cinuse, CINUSE_BIT, CMFAIL, compute_bit2idx, malloc_params::default_mflags, disable_contiguous, EXTERN_BIT, fm, mstate::footprint, malloc_params::granularity, granularity_align, i, ialloc(), idx2bit, init_bins(), init_mparams(), init_top(), INITIAL_LOCK, insert_chunk, internal_mallinfo(), internal_malloc, internal_malloc_stats(), internal_memalign(), internal_realloc(), INUSE_BITS, IS_MMAPPED_BIT, least_bit, left_bits, malloc_params::magic, mstate::max_footprint, MAX_REQUEST, MAX_SIZE_T, MAX_SMALL_REQUEST, mem2chunk, memset, MIN_CHUNK_SIZE, MIN_REQUEST, MMAP_FOOT_PAD, mparams, next_chunk, ok_address, ok_cinuse, ok_magic, ok_next, ok_pinuse, pad_request, malloc_params::page_size, pinuse, PINUSE_BIT, POSTACTION, PREACTION, replace_dv, RTCHECK, set_free_with_pinuse, set_inuse_and_pinuse, set_lock, set_size_and_pinuse_of_free_chunk, set_size_and_pinuse_of_inuse_chunk, should_trim, SIZE_T_SIZE, small_index, small_index2size, smallbin_at, sys_alloc(), sys_trim(), tmalloc_large(), tmalloc_small(), TOP_FOOT_SIZE, unlink_chunk, unlink_first_small_chunk, and USAGE_ERROR_ACTION.

4514 {
4515  return change_mparam(param_number, value);
4516 }
static int change_mparam(int param_number, int value)
Definition: SDL_malloc.c:2569
GLsizei const GLfloat * value

◆ dlmemalign()

void * dlmemalign ( size_t  alignment,
size_t  bytes 
)

Definition at line 4427 of file SDL_malloc.c.

References gm, and internal_memalign().

Referenced by dlpvalloc(), and dlvalloc().

4428 {
4429  return internal_memalign(gm, alignment, bytes);
4430 }
#define gm
Definition: SDL_malloc.c:2090
static void * internal_memalign(mstate m, size_t alignment, size_t bytes)
Definition: SDL_malloc.c:3938

◆ dlpvalloc()

void * dlpvalloc ( size_t  bytes)

Definition at line 4455 of file SDL_malloc.c.

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

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 }
size_t page_size
Definition: SDL_malloc.c:2079
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
void * dlmemalign(size_t, size_t)
Definition: SDL_malloc.c:4427
static int init_mparams(void)
Definition: SDL_malloc.c:2491
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303

◆ dlrealloc()

void * dlrealloc ( void oldmem,
size_t  bytes 
)

Definition at line 4402 of file SDL_malloc.c.

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

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 }
#define USAGE_ERROR_ACTION(m, p)
Definition: SDL_malloc.c:2225
void dlfree(void *)
Definition: SDL_malloc.c:4288
static void * internal_realloc(mstate m, void *oldmem, size_t bytes)
Definition: SDL_malloc.c:3868
const GLfloat * m
#define gm
Definition: SDL_malloc.c:2090
void * dlmalloc(size_t)
Definition: SDL_malloc.c:4154
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
#define ok_magic(M)
Definition: SDL_malloc.c:2426

◆ dlvalloc()

void * dlvalloc ( size_t  bytes)

Definition at line 4446 of file SDL_malloc.c.

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

4447 {
4448  size_t pagesz;
4449  init_mparams();
4450  pagesz = mparams.page_size;
4451  return dlmemalign(pagesz, bytes);
4452 }
size_t page_size
Definition: SDL_malloc.c:2079
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
void * dlmemalign(size_t, size_t)
Definition: SDL_malloc.c:4427
static int init_mparams(void)
Definition: SDL_malloc.c:2491

◆ has_segment_link()

static int has_segment_link ( mstate  m,
msegmentptr  ss 
)
static

Definition at line 2146 of file SDL_malloc.c.

Referenced by sys_trim().

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 }
const GLfloat * m

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

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(), dlindependent_comalloc(), and dlmallopt().

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);
4085  mem = internal_malloc(m, size - CHUNK_OVERHEAD);
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 }
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
#define request2size(req)
Definition: SDL_malloc.c:1711
GLuint GLfloat GLfloat GLfloat x1
unsigned int flag_t
Definition: SDL_malloc.c:1675
GLfloat GLfloat p
const GLfloat * m
#define memset
Definition: SDL_malloc.c:619
#define assert(x)
Definition: SDL_malloc.c:1219
#define SIZE_T_SIZE
Definition: SDL_malloc.c:1297
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
GLfixed GLfixed x2
#define CHUNK_OVERHEAD
Definition: SDL_malloc.c:1684
#define check_inuse_chunk(M, P)
Definition: SDL_malloc.c:2235
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
GLsizeiptr size
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
#define PREACTION(M)
Definition: SDL_malloc.c:2185
#define enable_mmap(M)
Definition: SDL_malloc.c:2103
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define use_mmap(M)
Definition: SDL_malloc.c:2102
#define internal_malloc(m, b)
Definition: SDL_malloc.c:3207
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
#define disable_mmap(M)
Definition: SDL_malloc.c:2104
#define is_mmapped(p)
Definition: SDL_malloc.c:1763
#define set_size_and_pinuse_of_inuse_chunk(M, p, s)
Definition: SDL_malloc.c:2458

◆ init_bins()

static void init_bins ( mstate  m)
static

Definition at line 3312 of file SDL_malloc.c.

References i, NSMALLBINS, NTREEBINS, smallbin_at, and treebin_at.

Referenced by dlmallopt(), and sys_alloc().

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 }
size_t bindex_t
Definition: SDL_malloc.c:1673
#define smallbin_at(M, i)
Definition: SDL_malloc.c:2271
const GLfloat * m
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
#define NSMALLBINS
Definition: SDL_malloc.c:2035

◆ init_mparams()

static int init_mparams ( void  )
static

Definition at line 2491 of file SDL_malloc.c.

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

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

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 }
#define DEFAULT_MMAP_THRESHOLD
Definition: SDL_malloc.c:600
#define INITIAL_LOCK(l)
Definition: SDL_malloc.c:1493
flag_t default_mflags
Definition: SDL_malloc.c:2083
#define ACQUIRE_MAGIC_INIT_LOCK()
Definition: SDL_malloc.c:1517
GLdouble s
Definition: SDL_opengl.h:2063
EGLSurface EGLnsecsANDROID time
Definition: eglext.h:518
#define DEFAULT_TRIM_THRESHOLD
Definition: SDL_malloc.c:593
#define ABORT
Definition: SDL_malloc.c:39
#define MCHUNK_SIZE
Definition: SDL_malloc.c:1679
#define USE_NONCONTIGUOUS_BIT
Definition: SDL_malloc.c:1427
unsigned int size_t
size_t trim_threshold
Definition: SDL_malloc.c:2082
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
size_t page_size
Definition: SDL_malloc.c:2079
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
#define gm
Definition: SDL_malloc.c:2090
#define USE_MMAP_BIT
Definition: SDL_malloc.c:1343
#define MALLOC_ALIGNMENT
Definition: SDL_malloc.c:531
#define MAX_SIZE_T
Definition: SDL_malloc.c:518
#define DEFAULT_GRANULARITY
Definition: SDL_malloc.c:588
GLenum GLuint GLenum GLsizei const GLchar * buf
#define RELEASE_MAGIC_INIT_LOCK()
Definition: SDL_malloc.c:1518
size_t granularity
Definition: SDL_malloc.c:2080
#define USE_LOCK_BIT
Definition: SDL_malloc.c:1502
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303
GLuint64 GLenum GLint fd
Definition: gl2ext.h:1508
size_t mmap_threshold
Definition: SDL_malloc.c:2081

◆ init_top()

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

Definition at line 3295 of file SDL_malloc.c.

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

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

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 }
GLfloat GLfloat p
const GLfloat * m
GLintptr offset
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
size_t trim_threshold
Definition: SDL_malloc.c:2082
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
#define align_offset(A)
Definition: SDL_malloc.c:1317
#define TOP_FOOT_SIZE
Definition: SDL_malloc.c:2168
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
#define PINUSE_BIT
Definition: SDL_malloc.c:1725

◆ internal_mallinfo()

static struct mallinfo internal_mallinfo ( mstate  m)
static

Definition at line 2884 of file SDL_malloc.c.

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

Referenced by dlmallinfo(), and dlmallopt().

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 }
#define next_chunk(p)
Definition: SDL_malloc.c:1745
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
MALLINFO_FIELD_TYPE arena
Definition: SDL_malloc.c:669
GLdouble s
Definition: SDL_opengl.h:2063
GLdouble GLdouble GLdouble GLdouble q
Definition: SDL_opengl.h:2087
#define cinuse(p)
Definition: SDL_malloc.c:1733
const GLfloat * m
#define FENCEPOST_HEAD
Definition: SDL_malloc.c:1730
#define is_initialized(M)
Definition: SDL_malloc.c:2092
MALLINFO_FIELD_TYPE ordblks
Definition: SDL_malloc.c:670
MALLINFO_FIELD_TYPE fordblks
Definition: SDL_malloc.c:677
#define align_as_chunk(A)
Definition: SDL_malloc.c:1700
#define PREACTION(M)
Definition: SDL_malloc.c:2185
#define check_malloc_state(M)
Definition: SDL_malloc.c:2238
MALLINFO_FIELD_TYPE keepcost
Definition: SDL_malloc.c:678
#define segment_holds(S, A)
Definition: SDL_malloc.c:2128
MALLINFO_FIELD_TYPE hblkhd
Definition: SDL_malloc.c:673
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303
#define TOP_FOOT_SIZE
Definition: SDL_malloc.c:2168
MALLINFO_FIELD_TYPE uordblks
Definition: SDL_malloc.c:676
MALLINFO_FIELD_TYPE usmblks
Definition: SDL_malloc.c:674

◆ internal_malloc_stats()

static void internal_malloc_stats ( mstate  m)
static

Definition at line 2925 of file SDL_malloc.c.

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

Referenced by dlmalloc_stats(), and dlmallopt().

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 }
#define next_chunk(p)
Definition: SDL_malloc.c:1745
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
GLdouble s
Definition: SDL_opengl.h:2063
GLdouble GLdouble GLdouble GLdouble q
Definition: SDL_opengl.h:2087
#define cinuse(p)
Definition: SDL_malloc.c:1733
const GLfloat * m
#define FENCEPOST_HEAD
Definition: SDL_malloc.c:1730
#define is_initialized(M)
Definition: SDL_malloc.c:2092
#define align_as_chunk(A)
Definition: SDL_malloc.c:1700
#define PREACTION(M)
Definition: SDL_malloc.c:2185
#define check_malloc_state(M)
Definition: SDL_malloc.c:2238
#define segment_holds(S, A)
Definition: SDL_malloc.c:2128
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define TOP_FOOT_SIZE
Definition: SDL_malloc.c:2168

◆ internal_memalign()

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

Definition at line 3938 of file SDL_malloc.c.

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

Referenced by dlmallopt(), and dlmemalign().

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 }
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
#define request2size(req)
Definition: SDL_malloc.c:1711
#define MALLOC_FAILURE_ACTION
Definition: SDL_malloc.c:501
GLfloat GLfloat p
const GLfloat * m
#define assert(x)
Definition: SDL_malloc.c:1219
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define CHUNK_OVERHEAD
Definition: SDL_malloc.c:1684
unsigned int size_t
#define check_inuse_chunk(M, P)
Definition: SDL_malloc.c:2235
#define CINUSE_BIT
Definition: SDL_malloc.c:1726
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
#define set_inuse(M, p, s)
Definition: SDL_malloc.c:2448
#define MALLOC_ALIGNMENT
Definition: SDL_malloc.c:531
GLsizeiptr size
#define PREACTION(M)
Definition: SDL_malloc.c:2185
#define MAX_REQUEST
Definition: SDL_malloc.c:1703
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
#define internal_free(m, mem)
Definition: SDL_malloc.c:3208
#define chunksize(p)
Definition: SDL_malloc.c:1735
GLboolean GLboolean GLboolean GLboolean a
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303
#define internal_malloc(m, b)
Definition: SDL_malloc.c:3207
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
#define is_mmapped(p)
Definition: SDL_malloc.c:1763

◆ internal_realloc()

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

Definition at line 3868 of file SDL_malloc.c.

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

Referenced by dlmallopt(), and dlrealloc().

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 }
#define USAGE_ERROR_ACTION(m, p)
Definition: SDL_malloc.c:2225
#define POSTACTION(M)
Definition: SDL_malloc.c:2186
#define request2size(req)
Definition: SDL_malloc.c:1711
#define ok_cinuse(p)
Definition: SDL_malloc.c:2411
#define MALLOC_FAILURE_ACTION
Definition: SDL_malloc.c:501
#define RTCHECK(e)
Definition: SDL_malloc.c:2435
const GLfloat * m
#define ok_pinuse(p)
Definition: SDL_malloc.c:2413
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb)
Definition: SDL_malloc.c:3256
#define check_inuse_chunk(M, P)
Definition: SDL_malloc.c:2235
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
#define set_inuse(M, p, s)
Definition: SDL_malloc.c:2448
#define ok_next(p, n)
Definition: SDL_malloc.c:2409
#define PREACTION(M)
Definition: SDL_malloc.c:2185
#define memcpy
Definition: SDL_malloc.c:622
#define MAX_REQUEST
Definition: SDL_malloc.c:1703
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
#define internal_free(m, mem)
Definition: SDL_malloc.c:3208
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define overhead_for(p)
Definition: SDL_malloc.c:1767
#define internal_malloc(m, b)
Definition: SDL_malloc.c:3207
#define ok_address(M, a)
Definition: SDL_malloc.c:2407
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
#define PINUSE_BIT
Definition: SDL_malloc.c:1725
#define is_mmapped(p)
Definition: SDL_malloc.c:1763

◆ mmap_alloc()

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

Definition at line 3226 of file SDL_malloc.c.

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

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;
3247  check_mmapped_chunk(m, p);
3248  return chunk2mem(p);
3249  }
3250  }
3251  return 0;
3252 }
#define DIRECT_MMAP(s)
Definition: SDL_malloc.c:1410
#define mark_inuse_foot(M, p, s)
Definition: SDL_malloc.c:2445
GLfloat GLfloat p
const GLfloat * m
#define FENCEPOST_HEAD
Definition: SDL_malloc.c:1730
#define IS_MMAPPED_BIT
Definition: SDL_malloc.c:1342
#define SIX_SIZE_T_SIZES
Definition: SDL_malloc.c:1307
GLintptr offset
#define assert(x)
Definition: SDL_malloc.c:1219
#define SIZE_T_SIZE
Definition: SDL_malloc.c:1297
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define CMFAIL
Definition: SDL_malloc.c:1332
#define CHUNK_ALIGN_MASK
Definition: SDL_malloc.c:1311
#define is_aligned(A)
Definition: SDL_malloc.c:1314
#define CINUSE_BIT
Definition: SDL_malloc.c:1726
#define check_mmapped_chunk(M, P)
Definition: SDL_malloc.c:2237
#define MMAP_FOOT_PAD
Definition: SDL_malloc.c:1690
SDL_EventEntry * head
Definition: SDL_events.c:82
#define align_offset(A)
Definition: SDL_malloc.c:1317
#define granularity_align(S)
Definition: SDL_malloc.c:2119
#define chunk2mem(p)
Definition: SDL_malloc.c:1697

◆ mmap_resize()

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

Definition at line 3256 of file SDL_malloc.c.

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

Referenced by internal_realloc().

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 }
#define mark_inuse_foot(M, p, s)
Definition: SDL_malloc.c:2445
const GLfloat * m
#define FENCEPOST_HEAD
Definition: SDL_malloc.c:1730
#define IS_MMAPPED_BIT
Definition: SDL_malloc.c:1342
#define SIX_SIZE_T_SIZES
Definition: SDL_malloc.c:1307
GLintptr offset
#define SIZE_T_SIZE
Definition: SDL_malloc.c:1297
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define CMFAIL
Definition: SDL_malloc.c:1332
#define CHUNK_ALIGN_MASK
Definition: SDL_malloc.c:1311
#define CINUSE_BIT
Definition: SDL_malloc.c:1726
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
#define is_small(s)
Definition: SDL_malloc.c:2265
size_t granularity
Definition: SDL_malloc.c:2080
#define CALL_MREMAP(addr, osz, nsz, mv)
Definition: SDL_malloc.c:1417
#define check_mmapped_chunk(M, P)
Definition: SDL_malloc.c:2237
static const double cp
Definition: e_pow.c:92
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define MMAP_FOOT_PAD
Definition: SDL_malloc.c:1690
#define granularity_align(S)
Definition: SDL_malloc.c:2119

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

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

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 
3380  check_malloced_chunk(m, chunk2mem(p), nb);
3381  return chunk2mem(p);
3382 }
#define insert_chunk(M, P, S)
Definition: SDL_malloc.c:3186
GLdouble GLdouble GLdouble GLdouble q
Definition: SDL_opengl.h:2087
#define cinuse(p)
Definition: SDL_malloc.c:1733
GLfloat GLfloat p
const GLfloat * m
#define set_free_with_pinuse(p, s, n)
Definition: SDL_malloc.c:1760
#define assert(x)
Definition: SDL_malloc.c:1219
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
#define align_as_chunk(A)
Definition: SDL_malloc.c:1700
#define unlink_chunk(M, P, S)
Definition: SDL_malloc.c:3190
#define check_malloced_chunk(M, P, N)
Definition: SDL_malloc.c:2236
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define set_size_and_pinuse_of_free_chunk(p, s)
Definition: SDL_malloc.c:1756
#define pinuse(p)
Definition: SDL_malloc.c:1734
#define check_free_chunk(M, P)
Definition: SDL_malloc.c:2234
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
#define PINUSE_BIT
Definition: SDL_malloc.c:1725
#define check_top_chunk(M, P)
Definition: SDL_malloc.c:2239
#define set_size_and_pinuse_of_inuse_chunk(M, p, s)
Definition: SDL_malloc.c:2458

◆ release_unused_segments()

static size_t release_unused_segments ( mstate  m)
static

Definition at line 3644 of file SDL_malloc.c.

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

Referenced by sys_trim().

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 }
#define unlink_large_chunk(M, X)
Definition: SDL_malloc.c:3113
#define cinuse(p)
Definition: SDL_malloc.c:1733
GLfloat GLfloat p
const GLfloat * m
#define assert(x)
Definition: SDL_malloc.c:1219
#define CALL_MUNMAP(a, s)
Definition: SDL_malloc.c:1409
#define align_as_chunk(A)
Definition: SDL_malloc.c:1700
GLsizeiptr size
#define insert_large_chunk(M, X, S)
Definition: SDL_malloc.c:3045
#define segment_holds(S, A)
Definition: SDL_malloc.c:2128
#define chunksize(p)
Definition: SDL_malloc.c:1735
#define is_mmapped_segment(S)
Definition: SDL_malloc.c:1953
#define is_extern_segment(S)
Definition: SDL_malloc.c:1954
#define TOP_FOOT_SIZE
Definition: SDL_malloc.c:2168

◆ SDL_calloc()

void* SDL_calloc ( size_t  nmemb,
size_t  size 
)

Definition at line 5335 of file SDL_malloc.c.

References s_mem, and SDL_AtomicIncRef.

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 }
static struct @32 s_mem
#define SDL_AtomicIncRef(a)
Increment an atomic variable used as a reference count.
Definition: SDL_atomic.h:234
GLsizeiptr size

◆ SDL_free()

void SDL_free ( void ptr)

Definition at line 5366 of file SDL_malloc.c.

References s_mem, SDL_AtomicDecRef, and void.

5367 {
5368  if (!ptr) {
5369  return;
5370  }
5371 
5372  s_mem.free_func(ptr);
5373  (void)SDL_AtomicDecRef(&s_mem.num_allocations);
5374 }
static struct @32 s_mem
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
#define SDL_AtomicDecRef(a)
Decrement an atomic variable used as a reference count.
Definition: SDL_atomic.h:244

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

References s_mem.

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 }
static struct @32 s_mem
SDL_realloc_func realloc_func
Definition: SDL_malloc.c:5264
SDL_malloc_func malloc_func
Definition: SDL_malloc.c:5262
SDL_free_func free_func
Definition: SDL_malloc.c:5265
SDL_calloc_func calloc_func
Definition: SDL_malloc.c:5263

◆ SDL_GetNumAllocations()

int SDL_GetNumAllocations ( void  )

Get the number of outstanding (unfreed) allocations.

Definition at line 5315 of file SDL_malloc.c.

References s_mem, and SDL_AtomicGet.

5316 {
5317  return SDL_AtomicGet(&s_mem.num_allocations);
5318 }
static struct @32 s_mem
#define SDL_AtomicGet

◆ SDL_malloc()

void* SDL_malloc ( size_t  size)

Definition at line 5320 of file SDL_malloc.c.

References s_mem, and SDL_AtomicIncRef.

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 }
static struct @32 s_mem
#define SDL_AtomicIncRef(a)
Increment an atomic variable used as a reference count.
Definition: SDL_atomic.h:234
GLsizeiptr size

◆ SDL_realloc()

void* SDL_realloc ( void ptr,
size_t  size 
)

Definition at line 5351 of file SDL_malloc.c.

References s_mem, and SDL_AtomicIncRef.

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 }
static struct @32 s_mem
#define SDL_AtomicIncRef(a)
Increment an atomic variable used as a reference count.
Definition: SDL_atomic.h:234
GLsizeiptr size

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

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

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 }
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
static struct @32 s_mem
SDL_realloc_func realloc_func
Definition: SDL_malloc.c:5264
SDL_malloc_func malloc_func
Definition: SDL_malloc.c:5262
SDL_free_func free_func
Definition: SDL_malloc.c:5265
SDL_calloc_func calloc_func
Definition: SDL_malloc.c:5263

◆ segment_holding()

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

Definition at line 2133 of file SDL_malloc.c.

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

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 }
const GLfloat * m
GLenum const void * addr

◆ sys_alloc()

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

Definition at line 3444 of file SDL_malloc.c.

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

Referenced by dlmalloc(), and dlmallopt().

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);
3631  check_malloced_chunk(m, chunk2mem(p), nb);
3632  return chunk2mem(p);
3633  }
3634  }
3635 
3637  return 0;
3638 }
#define next_chunk(p)
Definition: SDL_malloc.c:1745
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
#define HAVE_MMAP
Definition: SDL_malloc.c:491
unsigned int flag_t
Definition: SDL_malloc.c:1675
#define MALLOC_FAILURE_ACTION
Definition: SDL_malloc.c:501
GLuint GLuint end
Definition: SDL_opengl.h:1571
GLfloat GLfloat p
#define disable_contiguous(M)
Definition: SDL_malloc.c:2107
const GLfloat * m
#define is_initialized(M)
Definition: SDL_malloc.c:2092
#define IS_MMAPPED_BIT
Definition: SDL_malloc.c:1342
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define CMFAIL
Definition: SDL_malloc.c:1332
#define ACQUIRE_MORECORE_LOCK()
Definition: SDL_malloc.c:1512
#define CALL_MORECORE(S)
Definition: SDL_malloc.c:1423
unsigned int size_t
#define use_noncontiguous(M)
Definition: SDL_malloc.c:2106
static void init_bins(mstate m)
Definition: SDL_malloc.c:3312
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
#define MORECORE_CONTIGUOUS
Definition: SDL_malloc.c:575
#define MALLOC_ALIGNMENT
Definition: SDL_malloc.c:531
#define is_global(M)
Definition: SDL_malloc.c:2091
#define page_align(S)
Definition: SDL_malloc.c:2115
#define CALL_MMAP(s)
Definition: SDL_malloc.c:1408
static void init_top(mstate m, mchunkptr p, size_t psize)
Definition: SDL_malloc.c:3295
#define HALF_MAX_SIZE_T
Definition: SDL_malloc.c:1308
#define HAVE_MORECORE
Definition: SDL_malloc.c:492
#define check_malloced_chunk(M, P, N)
Definition: SDL_malloc.c:2236
static void * prepend_alloc(mstate m, char *newbase, char *oldbase, size_t nb)
Definition: SDL_malloc.c:3345
#define segment_holds(S, A)
Definition: SDL_malloc.c:2128
static int init_mparams(void)
Definition: SDL_malloc.c:2491
static void add_segment(mstate m, char *tbase, size_t tsize, flag_t mmapped)
Definition: SDL_malloc.c:3387
#define RELEASE_MORECORE_LOCK()
Definition: SDL_malloc.c:1513
#define mem2chunk(mem)
Definition: SDL_malloc.c:1698
#define use_mmap(M)
Definition: SDL_malloc.c:2102
static msegmentptr segment_holding(mstate m, char *addr)
Definition: SDL_malloc.c:2133
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303
#define is_extern_segment(S)
Definition: SDL_malloc.c:1954
#define TOP_FOOT_SIZE
Definition: SDL_malloc.c:2168
#define granularity_align(S)
Definition: SDL_malloc.c:2119
static void * mmap_alloc(mstate m, size_t nb)
Definition: SDL_malloc.c:3226
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
#define PINUSE_BIT
Definition: SDL_malloc.c:1725
#define is_page_aligned(S)
Definition: SDL_malloc.c:2122
#define check_top_chunk(M, P)
Definition: SDL_malloc.c:2239
#define set_size_and_pinuse_of_inuse_chunk(M, p, s)
Definition: SDL_malloc.c:2458
size_t mmap_threshold
Definition: SDL_malloc.c:2081

◆ sys_trim()

static int sys_trim ( mstate  m,
size_t  pad 
)
static

Definition at line 3685 of file SDL_malloc.c.

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

Referenced by dlfree(), dlmalloc_trim(), and dlmallopt().

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 }
#define HAVE_MMAP
Definition: SDL_malloc.c:491
static int has_segment_link(mstate m, msegmentptr ss)
Definition: SDL_malloc.c:2146
const GLfloat * m
#define is_initialized(M)
Definition: SDL_malloc.c:2092
#define CALL_MUNMAP(a, s)
Definition: SDL_malloc.c:1409
#define CMFAIL
Definition: SDL_malloc.c:1332
#define ACQUIRE_MORECORE_LOCK()
Definition: SDL_malloc.c:1512
#define CALL_MORECORE(S)
Definition: SDL_malloc.c:1423
#define MFAIL
Definition: SDL_malloc.c:1331
static struct malloc_params mparams
Definition: SDL_malloc.c:2086
#define MAX_SIZE_T
Definition: SDL_malloc.c:518
static void init_top(mstate m, mchunkptr p, size_t psize)
Definition: SDL_malloc.c:3295
#define HALF_MAX_SIZE_T
Definition: SDL_malloc.c:1308
#define HAVE_MORECORE
Definition: SDL_malloc.c:492
size_t granularity
Definition: SDL_malloc.c:2080
static size_t release_unused_segments(mstate m)
Definition: SDL_malloc.c:3644
#define RELEASE_MORECORE_LOCK()
Definition: SDL_malloc.c:1513
#define MAX_REQUEST
Definition: SDL_malloc.c:1703
#define CALL_MREMAP(addr, osz, nsz, mv)
Definition: SDL_malloc.c:1417
static msegmentptr segment_holding(mstate m, char *addr)
Definition: SDL_malloc.c:2133
#define is_mmapped_segment(S)
Definition: SDL_malloc.c:1953
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303
#define is_extern_segment(S)
Definition: SDL_malloc.c:1954
#define TOP_FOOT_SIZE
Definition: SDL_malloc.c:2168
#define check_top_chunk(M, P)
Definition: SDL_malloc.c:2239

◆ tmalloc_large()

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

Definition at line 3751 of file SDL_malloc.c.

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

Referenced by dlmalloc(), and dlmallopt().

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))) {
3808  unlink_large_chunk(m, v);
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 }
#define unlink_large_chunk(M, X)
Definition: SDL_malloc.c:3113
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
size_t bindex_t
Definition: SDL_malloc.c:1673
#define compute_tree_index(S, I)
Definition: SDL_malloc.c:2290
const GLdouble * v
Definition: SDL_opengl.h:2064
#define insert_chunk(M, P, S)
Definition: SDL_malloc.c:3186
#define RTCHECK(e)
Definition: SDL_malloc.c:2435
const GLfloat * m
#define compute_bit2idx(X, I)
Definition: SDL_malloc.c:2353
#define assert(x)
Definition: SDL_malloc.c:1219
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define leftmost_child(t)
Definition: SDL_malloc.c:1886
#define CORRUPTION_ERROR_ACTION(m)
Definition: SDL_malloc.c:2221
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
#define idx2bit(i)
Definition: SDL_malloc.c:2327
#define ok_next(p, n)
Definition: SDL_malloc.c:2409
#define leftshift_for_tree_index(i)
Definition: SDL_malloc.c:2314
#define SIZE_T_BITSIZE
Definition: SDL_malloc.c:1298
#define treebin_at(M, i)
Definition: SDL_malloc.c:2272
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
#define left_bits(x)
Definition: SDL_malloc.c:2371
#define chunksize(p)
Definition: SDL_malloc.c:1735
unsigned int binmap_t
Definition: SDL_malloc.c:1674
#define set_size_and_pinuse_of_free_chunk(p, s)
Definition: SDL_malloc.c:1756
#define SIZE_T_ONE
Definition: SDL_malloc.c:1303
#define ok_address(M, a)
Definition: SDL_malloc.c:2407
#define least_bit(x)
Definition: SDL_malloc.c:2368
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
GLdouble GLdouble t
Definition: SDL_opengl.h:2071
#define set_size_and_pinuse_of_inuse_chunk(M, p, s)
Definition: SDL_malloc.c:2458
#define set_inuse_and_pinuse(M, p, s)
Definition: SDL_malloc.c:2453

◆ tmalloc_small()

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

Definition at line 3826 of file SDL_malloc.c.

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

Referenced by dlmalloc(), and dlmallopt().

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))) {
3849  unlink_large_chunk(m, v);
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 }
#define unlink_large_chunk(M, X)
Definition: SDL_malloc.c:3113
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
size_t bindex_t
Definition: SDL_malloc.c:1673
const GLdouble * v
Definition: SDL_opengl.h:2064
#define RTCHECK(e)
Definition: SDL_malloc.c:2435
#define replace_dv(M, P, S)
Definition: SDL_malloc.c:3031
const GLfloat * m
#define compute_bit2idx(X, I)
Definition: SDL_malloc.c:2353
#define assert(x)
Definition: SDL_malloc.c:1219
#define chunk_plus_offset(p, s)
Definition: SDL_malloc.c:1741
#define leftmost_child(t)
Definition: SDL_malloc.c:1886
#define CORRUPTION_ERROR_ACTION(m)
Definition: SDL_malloc.c:2221
#define MIN_CHUNK_SIZE
Definition: SDL_malloc.c:1693
#define ok_next(p, n)
Definition: SDL_malloc.c:2409
#define treebin_at(M, i)
Definition: SDL_malloc.c:2272
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
#define chunksize(p)
Definition: SDL_malloc.c:1735
unsigned int binmap_t
Definition: SDL_malloc.c:1674
#define set_size_and_pinuse_of_free_chunk(p, s)
Definition: SDL_malloc.c:1756
#define ok_address(M, a)
Definition: SDL_malloc.c:2407
#define least_bit(x)
Definition: SDL_malloc.c:2368
#define chunk2mem(p)
Definition: SDL_malloc.c:1697
GLdouble GLdouble t
Definition: SDL_opengl.h:2071
#define set_size_and_pinuse_of_inuse_chunk(M, p, s)
Definition: SDL_malloc.c:2458
#define set_inuse_and_pinuse(M, p, s)
Definition: SDL_malloc.c:2453

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

References MFAIL.

1382 {
1383  void *ptr = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
1384  PAGE_READWRITE);
1385  return (ptr != 0) ? ptr : MFAIL;
1386 }
#define MFAIL
Definition: SDL_malloc.c:1331
GLsizeiptr size

◆ win32mmap()

static void* win32mmap ( size_t  size)
static

Definition at line 1372 of file SDL_malloc.c.

References MFAIL.

1373 {
1374  void *ptr =
1375  VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
1376  return (ptr != 0) ? ptr : MFAIL;
1377 }
#define MFAIL
Definition: SDL_malloc.c:1331
GLsizeiptr size

◆ 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 }
GLsizeiptr size

Variable Documentation

◆ _gm_

struct malloc_state _gm_
static

Definition at line 2089 of file SDL_malloc.c.

◆ calloc_func

SDL_calloc_func calloc_func

Definition at line 5263 of file SDL_malloc.c.

Referenced by SDL_SetMemoryFunctions().

◆ free_func

SDL_free_func free_func

Definition at line 5265 of file SDL_malloc.c.

Referenced by 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_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_SetMemoryFunctions().

◆ s_mem

struct { ... } s_mem
Initial value:
= {
}
#define real_realloc
Definition: SDL_malloc.c:5255
#define real_calloc
Definition: SDL_malloc.c:5254
#define real_free
Definition: SDL_malloc.c:5256
#define real_malloc
Definition: SDL_malloc.c:5253

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