AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-22 10:50:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Cleanups of malloc

Browse Source 
Remove ugly names and unnecessary wrappers.
This commit is contained in:
Ulrich Drepper 2012-01-31 18:49:22 -05:00
parent 41b81892f1
commit 3b49edc04b
4 changed files with 145 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,5 +1,11 @@
2012-01-31 Ulrich Drepper <drepper@gmail.com> 2012-01-31 Ulrich Drepper <drepper@gmail.com>
* malloc/malloc.c: Remove name translation. Don't use mixed-cap
names. Just use the correct names. Remove unnecessary wrapper
functions.
* malloc/arena.c: Likewise.
* malloc/hooks.c: Likewise.
* malloc/arena.c (arena_get2): Really don't call __get_nprocs if * malloc/arena.c (arena_get2): Really don't call __get_nprocs if
ARENA_TEST says not to. Simplify test for creation of a new arena. ARENA_TEST says not to. Simplify test for creation of a new arena.
Partially based on a patch by Siddhesh Poyarekar <siddhesh@redhat.com>. Partially based on a patch by Siddhesh Poyarekar <siddhesh@redhat.com>.

47
malloc/arena.c
View File

@ -185,7 +185,7 @@ malloc_atfork(size_t sz, const void *caller)
mALLOc() can be used again. */ mALLOc() can be used again. */
(void)mutex_lock(&list_lock); (void)mutex_lock(&list_lock);
(void)mutex_unlock(&list_lock); (void)mutex_unlock(&list_lock);
return public_mALLOc(sz); return __libc_malloc(sz);
} }
} }
@ -413,19 +413,19 @@ ptmalloc_init (void)
if (! __builtin_expect (__libc_enable_secure, 0)) if (! __builtin_expect (__libc_enable_secure, 0))
{ {
if (memcmp (envline, "TOP_PAD_", 8) == 0) if (memcmp (envline, "TOP_PAD_", 8) == 0)
mALLOPt(M_TOP_PAD, atoi(&envline[9])); __libc_mallopt(M_TOP_PAD, atoi(&envline[9]));
else if (memcmp (envline, "PERTURB_", 8) == 0) else if (memcmp (envline, "PERTURB_", 8) == 0)
mALLOPt(M_PERTURB, atoi(&envline[9])); __libc_mallopt(M_PERTURB, atoi(&envline[9]));
} }
break; break;
case 9: case 9:
if (! __builtin_expect (__libc_enable_secure, 0)) if (! __builtin_expect (__libc_enable_secure, 0))
{ {
if (memcmp (envline, "MMAP_MAX_", 9) == 0) if (memcmp (envline, "MMAP_MAX_", 9) == 0)
mALLOPt(M_MMAP_MAX, atoi(&envline[10])); __libc_mallopt(M_MMAP_MAX, atoi(&envline[10]));
#ifdef PER_THREAD #ifdef PER_THREAD
else if (memcmp (envline, "ARENA_MAX", 9) == 0) else if (memcmp (envline, "ARENA_MAX", 9) == 0)
mALLOPt(M_ARENA_MAX, atoi(&envline[10])); __libc_mallopt(M_ARENA_MAX, atoi(&envline[10]));
#endif #endif
} }
break; break;
@ -434,7 +434,7 @@ ptmalloc_init (void)
if (! __builtin_expect (__libc_enable_secure, 0)) if (! __builtin_expect (__libc_enable_secure, 0))
{ {
if (memcmp (envline, "ARENA_TEST", 10) == 0) if (memcmp (envline, "ARENA_TEST", 10) == 0)
mALLOPt(M_ARENA_TEST, atoi(&envline[11])); __libc_mallopt(M_ARENA_TEST, atoi(&envline[11]));
} }
break; break;
#endif #endif
@ -442,9 +442,9 @@ ptmalloc_init (void)
if (! __builtin_expect (__libc_enable_secure, 0)) if (! __builtin_expect (__libc_enable_secure, 0))
{ {
if (memcmp (envline, "TRIM_THRESHOLD_", 15) == 0) if (memcmp (envline, "TRIM_THRESHOLD_", 15) == 0)
mALLOPt(M_TRIM_THRESHOLD, atoi(&envline[16])); __libc_mallopt(M_TRIM_THRESHOLD, atoi(&envline[16]));
else if (memcmp (envline, "MMAP_THRESHOLD_", 15) == 0) else if (memcmp (envline, "MMAP_THRESHOLD_", 15) == 0)
mALLOPt(M_MMAP_THRESHOLD, atoi(&envline[16])); __libc_mallopt(M_MMAP_THRESHOLD, atoi(&envline[16]));
} }
break; break;
default: default:
@ -453,7 +453,7 @@ ptmalloc_init (void)
} }
} }
if(s && s[0]) { if(s && s[0]) {
mALLOPt(M_CHECK_ACTION, (int)(s[0] - '0')); __libc_mallopt(M_CHECK_ACTION, (int)(s[0] - '0'));
if (check_action != 0) if (check_action != 0)
__malloc_check_init(); __malloc_check_init();
} }
@ -543,39 +543,38 @@ new_heap(size_t size, size_t top_pad)
p2 = MAP_FAILED; p2 = MAP_FAILED;
if(aligned_heap_area) { if(aligned_heap_area) {
p2 = (char *)MMAP(aligned_heap_area, HEAP_MAX_SIZE, PROT_NONE, p2 = (char *)MMAP(aligned_heap_area, HEAP_MAX_SIZE, PROT_NONE,
MAP_PRIVATE|MAP_NORESERVE); MAP_NORESERVE);
aligned_heap_area = NULL; aligned_heap_area = NULL;
if (p2 != MAP_FAILED && ((unsigned long)p2 & (HEAP_MAX_SIZE-1))) { if (p2 != MAP_FAILED && ((unsigned long)p2 & (HEAP_MAX_SIZE-1))) {
munmap(p2, HEAP_MAX_SIZE); __munmap(p2, HEAP_MAX_SIZE);
p2 = MAP_FAILED; p2 = MAP_FAILED;
} }
} }
if(p2 == MAP_FAILED) { if(p2 == MAP_FAILED) {
p1 = (char *)MMAP(0, HEAP_MAX_SIZE<<1, PROT_NONE, p1 = (char *)MMAP(0, HEAP_MAX_SIZE<<1, PROT_NONE, MAP_NORESERVE);
MAP_PRIVATE|MAP_NORESERVE);
if(p1 != MAP_FAILED) { if(p1 != MAP_FAILED) {
p2 = (char *)(((unsigned long)p1 + (HEAP_MAX_SIZE-1)) p2 = (char *)(((unsigned long)p1 + (HEAP_MAX_SIZE-1))
& ~(HEAP_MAX_SIZE-1)); & ~(HEAP_MAX_SIZE-1));
ul = p2 - p1; ul = p2 - p1;
if (ul) if (ul)
munmap(p1, ul); __munmap(p1, ul);
else else
aligned_heap_area = p2 + HEAP_MAX_SIZE; aligned_heap_area = p2 + HEAP_MAX_SIZE;
munmap(p2 + HEAP_MAX_SIZE, HEAP_MAX_SIZE - ul); __munmap(p2 + HEAP_MAX_SIZE, HEAP_MAX_SIZE - ul);
} else { } else {
/* Try to take the chance that an allocation of only HEAP_MAX_SIZE /* Try to take the chance that an allocation of only HEAP_MAX_SIZE
is already aligned. */ is already aligned. */
p2 = (char *)MMAP(0, HEAP_MAX_SIZE, PROT_NONE, MAP_PRIVATE|MAP_NORESERVE); p2 = (char *)MMAP(0, HEAP_MAX_SIZE, PROT_NONE, MAP_NORESERVE);
if(p2 == MAP_FAILED) if(p2 == MAP_FAILED)
return 0; return 0;
if((unsigned long)p2 & (HEAP_MAX_SIZE-1)) { if((unsigned long)p2 & (HEAP_MAX_SIZE-1)) {
munmap(p2, HEAP_MAX_SIZE); __munmap(p2, HEAP_MAX_SIZE);
return 0; return 0;
} }
} }
} }
if(mprotect(p2, size, PROT_READ|PROT_WRITE) != 0) { if(__mprotect(p2, size, PROT_READ|PROT_WRITE) != 0) {
munmap(p2, HEAP_MAX_SIZE); __munmap(p2, HEAP_MAX_SIZE);
return 0; return 0;
} }
h = (heap_info *)p2; h = (heap_info *)p2;
@ -599,9 +598,9 @@ grow_heap(heap_info *h, long diff)
if((unsigned long) new_size > (unsigned long) HEAP_MAX_SIZE) if((unsigned long) new_size > (unsigned long) HEAP_MAX_SIZE)
return -1; return -1;
if((unsigned long) new_size > h->mprotect_size) { if((unsigned long) new_size > h->mprotect_size) {
if (mprotect((char *)h + h->mprotect_size, if (__mprotect((char *)h + h->mprotect_size,
(unsigned long) new_size - h->mprotect_size, (unsigned long) new_size - h->mprotect_size,
PROT_READ|PROT_WRITE) != 0) PROT_READ|PROT_WRITE) != 0)
return -2; return -2;
h->mprotect_size = new_size; h->mprotect_size = new_size;
} }
@ -625,7 +624,7 @@ shrink_heap(heap_info *h, long diff)
if (__builtin_expect (__libc_enable_secure, 0)) if (__builtin_expect (__libc_enable_secure, 0))
{ {
if((char *)MMAP((char *)h + new_size, diff, PROT_NONE, if((char *)MMAP((char *)h + new_size, diff, PROT_NONE,
MAP_PRIVATE|MAP_FIXED) == (char *) MAP_FAILED) MAP_FIXED) == (char *) MAP_FAILED)
return -2; return -2;
h->mprotect_size = new_size; h->mprotect_size = new_size;
} }
@ -643,7 +642,7 @@ shrink_heap(heap_info *h, long diff)
do { \ do { \
if ((char *)(heap) + HEAP_MAX_SIZE == aligned_heap_area) \ if ((char *)(heap) + HEAP_MAX_SIZE == aligned_heap_area) \
aligned_heap_area = NULL; \ aligned_heap_area = NULL; \
munmap((char*)(heap), HEAP_MAX_SIZE); \ __munmap((char*)(heap), HEAP_MAX_SIZE); \
} while (0) } while (0)
static int static int

12
malloc/hooks.c
View File

@ -30,7 +30,7 @@ malloc_hook_ini(size_t sz, const __malloc_ptr_t caller)
{ {
__malloc_hook = NULL; __malloc_hook = NULL;
ptmalloc_init(); ptmalloc_init();
return public_mALLOc(sz); return __libc_malloc(sz);
} }
static void* static void*
@ -39,7 +39,7 @@ realloc_hook_ini(void* ptr, size_t sz, const __malloc_ptr_t caller)
__malloc_hook = NULL; __malloc_hook = NULL;
__realloc_hook = NULL; __realloc_hook = NULL;
ptmalloc_init(); ptmalloc_init();
return public_rEALLOc(ptr, sz); return __libc_realloc(ptr, sz);
} }
static void* static void*
@ -47,7 +47,7 @@ memalign_hook_ini(size_t alignment, size_t sz, const __malloc_ptr_t caller)
{ {
__memalign_hook = NULL; __memalign_hook = NULL;
ptmalloc_init(); ptmalloc_init();
return public_mEMALIGn(alignment, sz); return __libc_memalign(alignment, sz);
} }
/* Whether we are using malloc checking. */ /* Whether we are using malloc checking. */
@ -389,13 +389,13 @@ struct malloc_save_state {
}; };
void* void*
public_gET_STATe(void) __malloc_get_state(void)
{ {
struct malloc_save_state* ms; struct malloc_save_state* ms;
int i; int i;
mbinptr b; mbinptr b;
ms = (struct malloc_save_state*)public_mALLOc(sizeof(*ms)); ms = (struct malloc_save_state*)__libc_malloc(sizeof(*ms));
if (!ms) if (!ms)
return 0; return 0;
(void)mutex_lock(&main_arena.mutex); (void)mutex_lock(&main_arena.mutex);
@ -440,7 +440,7 @@ public_gET_STATe(void)
} }
int int
public_sET_STATe(void* msptr) __malloc_set_state(void* msptr)
{ {
struct malloc_save_state* ms = (struct malloc_save_state*)msptr; struct malloc_save_state* ms = (struct malloc_save_state*)msptr;
size_t i; size_t i;

275
malloc/malloc.c
View File

@ -387,38 +387,9 @@ __malloc_assert (const char *assertion, const char *file, unsigned int line,
#endif #endif
/* /* Definition for getting more memory from the OS. */
Two-phase name translation.
All of the actual routines are given mangled names.
When wrappers are used, they become the public callable versions.
*/
/* Special defines for the GNU C library. */
#define public_cALLOc __libc_calloc
#define public_fREe __libc_free
#define public_cFREe __libc_cfree
#define public_mALLOc __libc_malloc
#define public_mEMALIGn __libc_memalign
#define public_rEALLOc __libc_realloc
#define public_vALLOc __libc_valloc
#define public_pVALLOc __libc_pvalloc
#define public_mALLINFo __libc_mallinfo
#define public_mALLOPt __libc_mallopt
#define public_mTRIm __malloc_trim
#define public_mSTATs __malloc_stats
#define public_mUSABLe __malloc_usable_size
#define public_iCALLOc __libc_independent_calloc
#define public_iCOMALLOc __libc_independent_comalloc
#define public_gET_STATe __malloc_get_state
#define public_sET_STATe __malloc_set_state
#define open __open
#define mmap __mmap
#define munmap __munmap
#define mremap __mremap
#define mprotect __mprotect
#define MORECORE (*__morecore) #define MORECORE (*__morecore)
#define MORECORE_FAILURE 0 #define MORECORE_FAILURE 0
void * __default_morecore (ptrdiff_t); void * __default_morecore (ptrdiff_t);
void *(*__morecore)(ptrdiff_t) = __default_morecore; void *(*__morecore)(ptrdiff_t) = __default_morecore;
@ -561,8 +532,8 @@ void *(*__morecore)(ptrdiff_t) = __default_morecore;
differs across systems, but is in all cases less than the maximum differs across systems, but is in all cases less than the maximum
representable value of a size_t. representable value of a size_t.
*/ */
void* public_mALLOc(size_t); void* __libc_malloc(size_t);
libc_hidden_proto (public_mALLOc) libc_hidden_proto (__libc_malloc)
/* /*
free(void* p) free(void* p)
@ -575,15 +546,15 @@ libc_hidden_proto (public_mALLOc)
when possible, automatically trigger operations that give when possible, automatically trigger operations that give
back unused memory to the system, thus reducing program footprint. back unused memory to the system, thus reducing program footprint.
*/ */
void public_fREe(void*); void __libc_free(void*);
libc_hidden_proto (public_fREe) libc_hidden_proto (__libc_free)
/* /*
calloc(size_t n_elements, size_t element_size); calloc(size_t n_elements, size_t element_size);
Returns a pointer to n_elements * element_size bytes, with all locations Returns a pointer to n_elements * element_size bytes, with all locations
set to zero. set to zero.
*/ */
void* public_cALLOc(size_t, size_t); void* __libc_calloc(size_t, size_t);
/* /*
realloc(void* p, size_t n) realloc(void* p, size_t n)
@ -612,8 +583,8 @@ void* public_cALLOc(size_t, size_t);
The old unix realloc convention of allowing the last-free'd chunk The old unix realloc convention of allowing the last-free'd chunk
to be used as an argument to realloc is not supported. to be used as an argument to realloc is not supported.
*/ */
void* public_rEALLOc(void*, size_t); void* __libc_realloc(void*, size_t);
libc_hidden_proto (public_rEALLOc) libc_hidden_proto (__libc_realloc)
/* /*
memalign(size_t alignment, size_t n); memalign(size_t alignment, size_t n);
@ -627,15 +598,15 @@ libc_hidden_proto (public_rEALLOc)
Overreliance on memalign is a sure way to fragment space. Overreliance on memalign is a sure way to fragment space.
*/ */
void* public_mEMALIGn(size_t, size_t); void* __libc_memalign(size_t, size_t);
libc_hidden_proto (public_mEMALIGn) libc_hidden_proto (__libc_memalign)
/* /*
valloc(size_t n); valloc(size_t n);
Equivalent to memalign(pagesize, n), where pagesize is the page Equivalent to memalign(pagesize, n), where pagesize is the page
size of the system. If the pagesize is unknown, 4096 is used. size of the system. If the pagesize is unknown, 4096 is used.
*/ */
void* public_vALLOc(size_t); void* __libc_valloc(size_t);
@ -660,7 +631,8 @@ void* public_vALLOc(size_t);
M_MMAP_THRESHOLD -3 128*1024 any (or 0 if no MMAP support) M_MMAP_THRESHOLD -3 128*1024 any (or 0 if no MMAP support)
M_MMAP_MAX -4 65536 any (0 disables use of mmap) M_MMAP_MAX -4 65536 any (0 disables use of mmap)
*/ */
int public_mALLOPt(int, int); int __libc_mallopt(int, int);
libc_hidden_proto (__libc_mallopt)
/* /*
@ -686,7 +658,7 @@ int public_mALLOPt(int, int);
be kept as longs, the reported values may wrap around zero and be kept as longs, the reported values may wrap around zero and
thus be inaccurate. thus be inaccurate.
*/ */
struct mallinfo public_mALLINFo(void); struct mallinfo __libc_mallinfo(void);
/* /*
@ -694,17 +666,7 @@ struct mallinfo public_mALLINFo(void);
Equivalent to valloc(minimum-page-that-holds(n)), that is, Equivalent to valloc(minimum-page-that-holds(n)), that is,
round up n to nearest pagesize. round up n to nearest pagesize.
*/ */
void* public_pVALLOc(size_t); void* __libc_pvalloc(size_t);
/*
cfree(void* p);
Equivalent to free(p).
cfree is needed/defined on some systems that pair it with calloc,
for odd historical reasons (such as: cfree is used in example
code in the first edition of K&R).
*/
void public_cFREe(void*);
/* /*
malloc_trim(size_t pad); malloc_trim(size_t pad);
@ -730,7 +692,7 @@ void public_cFREe(void*);
On systems that do not support "negative sbrks", it will always On systems that do not support "negative sbrks", it will always
return 0. return 0.
*/ */
int public_mTRIm(size_t); int __malloc_trim(size_t);
/* /*
malloc_usable_size(void* p); malloc_usable_size(void* p);
@ -747,7 +709,7 @@ int public_mTRIm(size_t);
assert(malloc_usable_size(p) >= 256); assert(malloc_usable_size(p) >= 256);
*/ */
size_t public_mUSABLe(void*); size_t __malloc_usable_size(void*);
/* /*
malloc_stats(); malloc_stats();
@ -769,7 +731,7 @@ size_t public_mUSABLe(void*);
More information can be obtained by calling mallinfo. More information can be obtained by calling mallinfo.
*/ */
void public_mSTATs(void); void __malloc_stats(void);
/* /*
malloc_get_state(void); malloc_get_state(void);
@ -777,7 +739,7 @@ void public_mSTATs(void);
Returns the state of all malloc variables in an opaque data Returns the state of all malloc variables in an opaque data
structure. structure.
*/ */
void* public_gET_STATe(void); void* __malloc_get_state(void);
/* /*
malloc_set_state(void* state); malloc_set_state(void* state);
@ -785,7 +747,7 @@ void* public_gET_STATe(void);
Restore the state of all malloc variables from data obtained with Restore the state of all malloc variables from data obtained with
malloc_get_state(). malloc_get_state().
*/ */
int public_sET_STATe(void*); int __malloc_set_state(void*);
/* /*
posix_memalign(void **memptr, size_t alignment, size_t size); posix_memalign(void **memptr, size_t alignment, size_t size);
@ -1093,11 +1055,6 @@ static void* _int_realloc(mstate, mchunkptr, INTERNAL_SIZE_T,
static void* _int_memalign(mstate, size_t, size_t); static void* _int_memalign(mstate, size_t, size_t);
static void* _int_valloc(mstate, size_t); static void* _int_valloc(mstate, size_t);
static void* _int_pvalloc(mstate, size_t); static void* _int_pvalloc(mstate, size_t);
static int mTRIm(mstate, size_t);
static size_t mUSABLe(void*);
static void mSTATs(void);
static int mALLOPt(int, int);
static struct mallinfo mALLINFo(mstate);
static void malloc_printerr(int action, const char *str, void *ptr); static void malloc_printerr(int action, const char *str, void *ptr);
static void* internal_function mem2mem_check(void *p, size_t sz); static void* internal_function mem2mem_check(void *p, size_t sz);
@ -1141,15 +1098,11 @@ static void free_atfork(void* mem, const void *caller);
#endif #endif
#ifndef MAP_NORESERVE #ifndef MAP_NORESERVE
# ifdef MAP_AUTORESRV # define MAP_NORESERVE 0
# define MAP_NORESERVE MAP_AUTORESRV
# else
# define MAP_NORESERVE 0
# endif
#endif #endif
#define MMAP(addr, size, prot, flags) \ #define MMAP(addr, size, prot, flags) \
(mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS, -1, 0)) __mmap((addr), (size), (prot), (flags)|MAP_ANONYMOUS|MAP_PRIVATE, -1, 0)
/* /*
@ -1584,7 +1537,7 @@ typedef struct malloc_chunk* mbinptr;
need to do so when getting memory from system, so we make need to do so when getting memory from system, so we make
initial_top treat the bin as a legal but unusable chunk during the initial_top treat the bin as a legal but unusable chunk during the
interval between initialization and the first call to interval between initialization and the first call to
sYSMALLOc. (This is somewhat delicate, since it relies on sysmalloc. (This is somewhat delicate, since it relies on
the 2 preceding words to be zero during this interval as well.) the 2 preceding words to be zero during this interval as well.)
*/ */
@ -1854,8 +1807,8 @@ static void malloc_init_state(mstate av)
Other internal utilities operating on mstates Other internal utilities operating on mstates
*/ */
static void* sYSMALLOc(INTERNAL_SIZE_T, mstate); static void* sysmalloc(INTERNAL_SIZE_T, mstate);
static int sYSTRIm(size_t, mstate); static int systrim(size_t, mstate);
static void malloc_consolidate(mstate); static void malloc_consolidate(mstate);
@ -2270,7 +2223,7 @@ static void do_check_malloc_state(mstate av)
be extended or replaced. be extended or replaced.
*/ */
static void* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av) static void* sysmalloc(INTERNAL_SIZE_T nb, mstate av)
{ {
mchunkptr old_top; /* incoming value of av->top */ mchunkptr old_top; /* incoming value of av->top */
INTERNAL_SIZE_T old_size; /* its size */ INTERNAL_SIZE_T old_size; /* its size */
@ -2322,7 +2275,7 @@ static void* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
/* Don't try if size wraps around 0 */ /* Don't try if size wraps around 0 */
if ((unsigned long)(size) > (unsigned long)(nb)) { if ((unsigned long)(size) > (unsigned long)(nb)) {
mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE)); mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, 0));
if (mm != MAP_FAILED) { if (mm != MAP_FAILED) {
@ -2485,7 +2438,7 @@ static void* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
/* Don't try if size wraps around 0 */ /* Don't try if size wraps around 0 */
if ((unsigned long)(size) > (unsigned long)(nb)) { if ((unsigned long)(size) > (unsigned long)(nb)) {
char *mbrk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE)); char *mbrk = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, 0));
if (mbrk != MAP_FAILED) { if (mbrk != MAP_FAILED) {
@ -2690,7 +2643,7 @@ static void* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
/* /*
sYSTRIm is an inverse of sorts to sYSMALLOc. It gives memory back systrim is an inverse of sorts to sysmalloc. It gives memory back
to the system (via negative arguments to sbrk) if there is unused to the system (via negative arguments to sbrk) if there is unused
memory at the `high' end of the malloc pool. It is called memory at the `high' end of the malloc pool. It is called
automatically by free() when top space exceeds the trim automatically by free() when top space exceeds the trim
@ -2698,7 +2651,7 @@ static void* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
returns 1 if it actually released any memory, else 0. returns 1 if it actually released any memory, else 0.
*/ */
static int sYSTRIm(size_t pad, mstate av) static int systrim(size_t pad, mstate av)
{ {
long top_size; /* Amount of top-most memory */ long top_size; /* Amount of top-most memory */
long extra; /* Amount to release */ long extra; /* Amount to release */
@ -2783,7 +2736,7 @@ munmap_chunk(mchunkptr p)
/* If munmap failed the process virtual memory address space is in a /* If munmap failed the process virtual memory address space is in a
bad shape. Just leave the block hanging around, the process will bad shape. Just leave the block hanging around, the process will
terminate shortly anyway since not much can be done. */ terminate shortly anyway since not much can be done. */
munmap((char *)block, total_size); __munmap((char *)block, total_size);
} }
#if HAVE_MREMAP #if HAVE_MREMAP
@ -2807,8 +2760,8 @@ mremap_chunk(mchunkptr p, size_t new_size)
if (size + offset == new_size) if (size + offset == new_size)
return p; return p;
cp = (char *)mremap((char *)p - offset, size + offset, new_size, cp = (char *)__mremap((char *)p - offset, size + offset, new_size,
MREMAP_MAYMOVE); MREMAP_MAYMOVE);
if (cp == MAP_FAILED) return 0; if (cp == MAP_FAILED) return 0;
@ -2831,7 +2784,7 @@ mremap_chunk(mchunkptr p, size_t new_size)
/*------------------------ Public wrappers. --------------------------------*/ /*------------------------ Public wrappers. --------------------------------*/
void* void*
public_mALLOc(size_t bytes) __libc_malloc(size_t bytes)
{ {
mstate ar_ptr; mstate ar_ptr;
void *victim; void *victim;
@ -2870,10 +2823,10 @@ public_mALLOc(size_t bytes)
ar_ptr == arena_for_chunk(mem2chunk(victim))); ar_ptr == arena_for_chunk(mem2chunk(victim)));
return victim; return victim;
} }
libc_hidden_def(public_mALLOc) libc_hidden_def(__libc_malloc)
void void
public_fREe(void* mem) __libc_free(void* mem)
{ {
mstate ar_ptr; mstate ar_ptr;
mchunkptr p; /* chunk corresponding to mem */ mchunkptr p; /* chunk corresponding to mem */
@ -2907,10 +2860,10 @@ public_fREe(void* mem)
ar_ptr = arena_for_chunk(p); ar_ptr = arena_for_chunk(p);
_int_free(ar_ptr, p, 0); _int_free(ar_ptr, p, 0);
} }
libc_hidden_def (public_fREe) libc_hidden_def (__libc_free)
void* void*
public_rEALLOc(void* oldmem, size_t bytes) __libc_realloc(void* oldmem, size_t bytes)
{ {
mstate ar_ptr; mstate ar_ptr;
INTERNAL_SIZE_T nb; /* padded request size */ INTERNAL_SIZE_T nb; /* padded request size */
@ -2923,11 +2876,11 @@ public_rEALLOc(void* oldmem, size_t bytes)
return (*hook)(oldmem, bytes, RETURN_ADDRESS (0)); return (*hook)(oldmem, bytes, RETURN_ADDRESS (0));
#if REALLOC_ZERO_BYTES_FREES #if REALLOC_ZERO_BYTES_FREES
if (bytes == 0 && oldmem != NULL) { public_fREe(oldmem); return 0; } if (bytes == 0 && oldmem != NULL) { __libc_free(oldmem); return 0; }
#endif #endif
/* realloc of null is supposed to be same as malloc */ /* realloc of null is supposed to be same as malloc */
if (oldmem == 0) return public_mALLOc(bytes); if (oldmem == 0) return __libc_malloc(bytes);
/* chunk corresponding to oldmem */ /* chunk corresponding to oldmem */
const mchunkptr oldp = mem2chunk(oldmem); const mchunkptr oldp = mem2chunk(oldmem);
@ -2958,7 +2911,7 @@ public_rEALLOc(void* oldmem, size_t bytes)
/* Note the extra SIZE_SZ overhead. */ /* Note the extra SIZE_SZ overhead. */
if(oldsize - SIZE_SZ >= nb) return oldmem; /* do nothing */ if(oldsize - SIZE_SZ >= nb) return oldmem; /* do nothing */
/* Must alloc, copy, free. */ /* Must alloc, copy, free. */
newmem = public_mALLOc(bytes); newmem = __libc_malloc(bytes);
if (newmem == 0) return 0; /* propagate failure */ if (newmem == 0) return 0; /* propagate failure */
MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ); MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
munmap_chunk(oldp); munmap_chunk(oldp);
@ -2991,7 +2944,7 @@ public_rEALLOc(void* oldmem, size_t bytes)
if (newp == NULL) if (newp == NULL)
{ {
/* Try harder to allocate memory in other arenas. */ /* Try harder to allocate memory in other arenas. */
newp = public_mALLOc(bytes); newp = __libc_malloc(bytes);
if (newp != NULL) if (newp != NULL)
{ {
MALLOC_COPY (newp, oldmem, oldsize - SIZE_SZ); MALLOC_COPY (newp, oldmem, oldsize - SIZE_SZ);
@ -3001,10 +2954,10 @@ public_rEALLOc(void* oldmem, size_t bytes)
return newp; return newp;
} }
libc_hidden_def (public_rEALLOc) libc_hidden_def (__libc_realloc)
void* void*
public_mEMALIGn(size_t alignment, size_t bytes) __libc_memalign(size_t alignment, size_t bytes)
{ {
mstate ar_ptr; mstate ar_ptr;
void *p; void *p;
@ -3016,7 +2969,7 @@ public_mEMALIGn(size_t alignment, size_t bytes)
return (*hook)(alignment, bytes, RETURN_ADDRESS (0)); return (*hook)(alignment, bytes, RETURN_ADDRESS (0));
/* If need less alignment than we give anyway, just relay to malloc */ /* If need less alignment than we give anyway, just relay to malloc */
if (alignment <= MALLOC_ALIGNMENT) return public_mALLOc(bytes); if (alignment <= MALLOC_ALIGNMENT) return __libc_malloc(bytes);
/* Otherwise, ensure that it is at least a minimum chunk size */ /* Otherwise, ensure that it is at least a minimum chunk size */
if (alignment < MINSIZE) alignment = MINSIZE; if (alignment < MINSIZE) alignment = MINSIZE;
@ -3050,11 +3003,11 @@ public_mEMALIGn(size_t alignment, size_t bytes)
return p; return p;
} }
/* For ISO C11. */ /* For ISO C11. */
weak_alias (public_mEMALIGn, aligned_alloc) weak_alias (__libc_memalign, aligned_alloc)
libc_hidden_def (public_mEMALIGn) libc_hidden_def (__libc_memalign)
void* void*
public_vALLOc(size_t bytes) __libc_valloc(size_t bytes)
{ {
mstate ar_ptr; mstate ar_ptr;
void *p; void *p;
@ -3098,7 +3051,7 @@ public_vALLOc(size_t bytes)
} }
void* void*
public_pVALLOc(size_t bytes) __libc_pvalloc(size_t bytes)
{ {
mstate ar_ptr; mstate ar_ptr;
void *p; void *p;
@ -3143,7 +3096,7 @@ public_pVALLOc(size_t bytes)
} }
void* void*
public_cALLOc(size_t n, size_t elem_size) __libc_calloc(size_t n, size_t elem_size)
{ {
mstate av; mstate av;
mchunkptr oldtop, p; mchunkptr oldtop, p;
@ -3275,64 +3228,6 @@ public_cALLOc(size_t n, size_t elem_size)
return mem; return mem;
} }
int
public_mTRIm(size_t s)
{
int result = 0;
if(__malloc_initialized < 0)
ptmalloc_init ();
mstate ar_ptr = &main_arena;
do
{
(void) mutex_lock (&ar_ptr->mutex);
result |= mTRIm (ar_ptr, s);
(void) mutex_unlock (&ar_ptr->mutex);
ar_ptr = ar_ptr->next;
}
while (ar_ptr != &main_arena);
return result;
}
size_t
public_mUSABLe(void* m)
{
size_t result;
result = mUSABLe(m);
return result;
}
void
public_mSTATs()
{
mSTATs();
}
struct mallinfo public_mALLINFo()
{
struct mallinfo m;
if(__malloc_initialized < 0)
ptmalloc_init ();
(void)mutex_lock(&main_arena.mutex);
m = mALLINFo(&main_arena);
(void)mutex_unlock(&main_arena.mutex);
return m;
}
int
public_mALLOPt(int p, int v)
{
int result;
result = mALLOPt(p, v);
return result;
}
/* /*
------------------------------ malloc ------------------------------ ------------------------------ malloc ------------------------------
*/ */
@ -3816,7 +3711,7 @@ _int_malloc(mstate av, size_t bytes)
Otherwise, relay to handle system-dependent cases Otherwise, relay to handle system-dependent cases
*/ */
else { else {
void *p = sYSMALLOc(nb, av); void *p = sysmalloc(nb, av);
if (p != NULL && __builtin_expect (perturb_byte, 0)) if (p != NULL && __builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes); alloc_perturb (p, bytes);
return p; return p;
@ -4076,7 +3971,7 @@ _int_free(mstate av, mchunkptr p, int have_lock)
#ifndef MORECORE_CANNOT_TRIM #ifndef MORECORE_CANNOT_TRIM
if ((unsigned long)(chunksize(av->top)) >= if ((unsigned long)(chunksize(av->top)) >=
(unsigned long)(mp_.trim_threshold)) (unsigned long)(mp_.trim_threshold))
sYSTRIm(mp_.top_pad, av); systrim(mp_.top_pad, av);
#endif #endif
} else { } else {
/* Always try heap_trim(), even if the top chunk is not /* Always try heap_trim(), even if the top chunk is not
@ -4511,7 +4406,7 @@ _int_pvalloc(mstate av, size_t bytes)
------------------------------ malloc_trim ------------------------------ ------------------------------ malloc_trim ------------------------------
*/ */
static int mTRIm(mstate av, size_t pad) static int mtrim(mstate av, size_t pad)
{ {
/* Ensure initialization/consolidation */ /* Ensure initialization/consolidation */
malloc_consolidate (av); malloc_consolidate (av);
@ -4559,18 +4454,42 @@ static int mTRIm(mstate av, size_t pad)
} }
#ifndef MORECORE_CANNOT_TRIM #ifndef MORECORE_CANNOT_TRIM
return result | (av == &main_arena ? sYSTRIm (pad, av) : 0); return result | (av == &main_arena ? systrim (pad, av) : 0);
#else #else
return result; return result;
#endif #endif
} }
int
__malloc_trim(size_t s)
{
int result = 0;
if(__malloc_initialized < 0)
ptmalloc_init ();
mstate ar_ptr = &main_arena;
do
{
(void) mutex_lock (&ar_ptr->mutex);
result |= mtrim (ar_ptr, s);
(void) mutex_unlock (&ar_ptr->mutex);
ar_ptr = ar_ptr->next;
}
while (ar_ptr != &main_arena);
return result;
}
/* /*
------------------------- malloc_usable_size ------------------------- ------------------------- malloc_usable_size -------------------------
*/ */
size_t mUSABLe(void* mem) static size_t
musable(void* mem)
{ {
mchunkptr p; mchunkptr p;
if (mem != 0) { if (mem != 0) {
@ -4583,11 +4502,22 @@ size_t mUSABLe(void* mem)
return 0; return 0;
} }
size_t
__malloc_usable_size(void* m)
{
size_t result;
result = musable(m);
return result;
}
/* /*
------------------------------ mallinfo ------------------------------ ------------------------------ mallinfo ------------------------------
*/ */
struct mallinfo mALLINFo(mstate av) static struct mallinfo
int_mallinfo(mstate av)
{ {
struct mallinfo mi; struct mallinfo mi;
size_t i; size_t i;
@ -4642,11 +4572,25 @@ struct mallinfo mALLINFo(mstate av)
return mi; return mi;
} }
struct mallinfo __libc_mallinfo()
{
struct mallinfo m;
if(__malloc_initialized < 0)
ptmalloc_init ();
(void)mutex_lock(&main_arena.mutex);
m = int_mallinfo(&main_arena);
(void)mutex_unlock(&main_arena.mutex);
return m;
}
/* /*
------------------------------ malloc_stats ------------------------------ ------------------------------ malloc_stats ------------------------------
*/ */
void mSTATs() void
__malloc_stats()
{ {
int i; int i;
mstate ar_ptr; mstate ar_ptr;
@ -4663,7 +4607,7 @@ void mSTATs()
((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL; ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
for (i=0, ar_ptr = &main_arena;; i++) { for (i=0, ar_ptr = &main_arena;; i++) {
(void)mutex_lock(&ar_ptr->mutex); (void)mutex_lock(&ar_ptr->mutex);
mi = mALLINFo(ar_ptr); mi = int_mallinfo(ar_ptr);
fprintf(stderr, "Arena %d:\n", i); fprintf(stderr, "Arena %d:\n", i);
fprintf(stderr, "system bytes = %10u\n", (unsigned int)mi.arena); fprintf(stderr, "system bytes = %10u\n", (unsigned int)mi.arena);
fprintf(stderr, "in use bytes = %10u\n", (unsigned int)mi.uordblks); fprintf(stderr, "in use bytes = %10u\n", (unsigned int)mi.uordblks);
@ -4705,7 +4649,7 @@ void mSTATs()
------------------------------ mallopt ------------------------------ ------------------------------ mallopt ------------------------------
*/ */
int mALLOPt(int param_number, int value) int __libc_mallopt(int param_number, int value)
{ {
mstate av = &main_arena; mstate av = &main_arena;
int res = 1; int res = 1;
@ -4772,6 +4716,7 @@ int mALLOPt(int param_number, int value)
(void)mutex_unlock(&av->mutex); (void)mutex_unlock(&av->mutex);
return res; return res;
} }
libc_hidden_def (__libc_mallopt)
/* /*
@ -4962,7 +4907,7 @@ __posix_memalign (void **memptr, size_t alignment, size_t size)
if (__builtin_expect (hook != NULL, 0)) if (__builtin_expect (hook != NULL, 0))
mem = (*hook)(alignment, size, RETURN_ADDRESS (0)); mem = (*hook)(alignment, size, RETURN_ADDRESS (0));
else else
mem = public_mEMALIGn (alignment, size); mem = __libc_memalign (alignment, size);
if (mem != NULL) { if (mem != NULL) {
*memptr = mem; *memptr = mem;