OpenE2K
/
glibc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Cleanups of malloc 

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>
* 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
ARENA_TEST says not to. Simplify test for creation of a new arena.
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. */
(void)mutex_lock(&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 (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)
mALLOPt(M_PERTURB, atoi(&envline[9]));
__libc_mallopt(M_PERTURB, atoi(&envline[9]));
}
break;
case 9:
if (! __builtin_expect (__libc_enable_secure, 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
else if (memcmp (envline, "ARENA_MAX", 9) == 0)
mALLOPt(M_ARENA_MAX, atoi(&envline[10]));
__libc_mallopt(M_ARENA_MAX, atoi(&envline[10]));
#endif
}
break;
@ -434,7 +434,7 @@ ptmalloc_init (void)
if (! __builtin_expect (__libc_enable_secure, 0))
{
if (memcmp (envline, "ARENA_TEST", 10) == 0)
mALLOPt(M_ARENA_TEST, atoi(&envline[11]));
__libc_mallopt(M_ARENA_TEST, atoi(&envline[11]));
}
break;
#endif
@ -442,9 +442,9 @@ ptmalloc_init (void)
if (! __builtin_expect (__libc_enable_secure, 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)
mALLOPt(M_MMAP_THRESHOLD, atoi(&envline[16]));
__libc_mallopt(M_MMAP_THRESHOLD, atoi(&envline[16]));
}
break;
default:
@ -453,7 +453,7 @@ ptmalloc_init (void)
}
}
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)
__malloc_check_init();
}
@ -543,39 +543,38 @@ new_heap(size_t size, size_t top_pad)
p2 = MAP_FAILED;
if(aligned_heap_area) {
p2 = (char *)MMAP(aligned_heap_area, HEAP_MAX_SIZE, PROT_NONE,
MAP_PRIVATE|MAP_NORESERVE);
MAP_NORESERVE);
aligned_heap_area = NULL;
if (p2 != MAP_FAILED && ((unsigned long)p2 & (HEAP_MAX_SIZE-1))) {
munmap(p2, HEAP_MAX_SIZE);
__munmap(p2, HEAP_MAX_SIZE);
p2 = MAP_FAILED;
}
}
if(p2 == MAP_FAILED) {
p1 = (char *)MMAP(0, HEAP_MAX_SIZE<<1, PROT_NONE,
MAP_PRIVATE|MAP_NORESERVE);
p1 = (char *)MMAP(0, HEAP_MAX_SIZE<<1, PROT_NONE, MAP_NORESERVE);
if(p1 != MAP_FAILED) {
p2 = (char *)(((unsigned long)p1 + (HEAP_MAX_SIZE-1))
& ~(HEAP_MAX_SIZE-1));
ul = p2 - p1;
if (ul)
munmap(p1, ul);
__munmap(p1, ul);
else
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 {
/* Try to take the chance that an allocation of only HEAP_MAX_SIZE
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)
return 0;
if((unsigned long)p2 & (HEAP_MAX_SIZE-1)) {
munmap(p2, HEAP_MAX_SIZE);
__munmap(p2, HEAP_MAX_SIZE);
return 0;
}
}
}
if(mprotect(p2, size, PROT_READ|PROT_WRITE) != 0) {
munmap(p2, HEAP_MAX_SIZE);
if(__mprotect(p2, size, PROT_READ|PROT_WRITE) != 0) {
__munmap(p2, HEAP_MAX_SIZE);
return 0;
}
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)
return -1;
if((unsigned long) new_size > h->mprotect_size) {
if (mprotect((char *)h + h->mprotect_size,
(unsigned long) new_size - h->mprotect_size,
PROT_READ|PROT_WRITE) != 0)
if (__mprotect((char *)h + h->mprotect_size,
(unsigned long) new_size - h->mprotect_size,
PROT_READ|PROT_WRITE) != 0)
return -2;
h->mprotect_size = new_size;
}
@ -625,7 +624,7 @@ shrink_heap(heap_info *h, long diff)
if (__builtin_expect (__libc_enable_secure, 0))
{
if((char *)MMAP((char *)h + new_size, diff, PROT_NONE,
MAP_PRIVATE|MAP_FIXED) == (char *) MAP_FAILED)
MAP_FIXED) == (char *) MAP_FAILED)
return -2;
h->mprotect_size = new_size;
}
@ -643,7 +642,7 @@ shrink_heap(heap_info *h, long diff)
do { \
if ((char *)(heap) + HEAP_MAX_SIZE == aligned_heap_area) \
aligned_heap_area = NULL; \
munmap((char*)(heap), HEAP_MAX_SIZE); \
__munmap((char*)(heap), HEAP_MAX_SIZE); \
} while (0)
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;
ptmalloc_init();
return public_mALLOc(sz);
return __libc_malloc(sz);
}
static void*
@ -39,7 +39,7 @@ realloc_hook_ini(void* ptr, size_t sz, const __malloc_ptr_t caller)
__malloc_hook = NULL;
__realloc_hook = NULL;
ptmalloc_init();
return public_rEALLOc(ptr, sz);
return __libc_realloc(ptr, sz);
}
static void*
@ -47,7 +47,7 @@ memalign_hook_ini(size_t alignment, size_t sz, const __malloc_ptr_t caller)
{
__memalign_hook = NULL;
ptmalloc_init();
return public_mEMALIGn(alignment, sz);
return __libc_memalign(alignment, sz);
}
/* Whether we are using malloc checking. */
@ -389,13 +389,13 @@ struct malloc_save_state {
};
void*
public_gET_STATe(void)
__malloc_get_state(void)
{
struct malloc_save_state* ms;
int i;
mbinptr b;
ms = (struct malloc_save_state*)public_mALLOc(sizeof(*ms));
ms = (struct malloc_save_state*)__libc_malloc(sizeof(*ms));
if (!ms)
return 0;
(void)mutex_lock(&main_arena.mutex);
@ -440,7 +440,7 @@ public_gET_STATe(void)
}
int
public_sET_STATe(void* msptr)
__malloc_set_state(void* msptr)
{
struct malloc_save_state* ms = (struct malloc_save_state*)msptr;
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
/*
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
/* Definition for getting more memory from the OS. */
#define MORECORE (*__morecore)
#define MORECORE_FAILURE 0
void * __default_morecore (ptrdiff_t);
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
representable value of a size_t.
*/
void* public_mALLOc(size_t);
libc_hidden_proto (public_mALLOc)
void* __libc_malloc(size_t);
libc_hidden_proto (__libc_malloc)
/*
free(void* p)
@ -575,15 +546,15 @@ libc_hidden_proto (public_mALLOc)
when possible, automatically trigger operations that give
back unused memory to the system, thus reducing program footprint.
*/
void public_fREe(void*);
libc_hidden_proto (public_fREe)
void __libc_free(void*);
libc_hidden_proto (__libc_free)
/*
calloc(size_t n_elements, size_t element_size);
Returns a pointer to n_elements * element_size bytes, with all locations
set to zero.
*/
void* public_cALLOc(size_t, size_t);
void* __libc_calloc(size_t, size_t);
/*
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
to be used as an argument to realloc is not supported.
*/
void* public_rEALLOc(void*, size_t);
libc_hidden_proto (public_rEALLOc)
void* __libc_realloc(void*, size_t);
libc_hidden_proto (__libc_realloc)
/*
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.
*/
void* public_mEMALIGn(size_t, size_t);
libc_hidden_proto (public_mEMALIGn)
void* __libc_memalign(size_t, size_t);
libc_hidden_proto (__libc_memalign)
/*
valloc(size_t n);
Equivalent to memalign(pagesize, n), where pagesize is the page
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_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
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,
round up n to nearest pagesize.
*/
void* public_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*);
void* __libc_pvalloc(size_t);
/*
malloc_trim(size_t pad);
@ -730,7 +692,7 @@ void public_cFREe(void*);
On systems that do not support "negative sbrks", it will always
return 0.
*/
int public_mTRIm(size_t);
int __malloc_trim(size_t);
/*
malloc_usable_size(void* p);
@ -747,7 +709,7 @@ int public_mTRIm(size_t);
assert(malloc_usable_size(p) >= 256);
*/
size_t public_mUSABLe(void*);
size_t __malloc_usable_size(void*);
/*
malloc_stats();
@ -769,7 +731,7 @@ size_t public_mUSABLe(void*);
More information can be obtained by calling mallinfo.
*/
void public_mSTATs(void);
void __malloc_stats(void);
/*
malloc_get_state(void);
@ -777,7 +739,7 @@ void public_mSTATs(void);
Returns the state of all malloc variables in an opaque data
structure.
*/
void* public_gET_STATe(void);
void* __malloc_get_state(void);
/*
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
malloc_get_state().
*/
int public_sET_STATe(void*);
int __malloc_set_state(void*);
/*
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_valloc(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* internal_function mem2mem_check(void *p, size_t sz);
@ -1141,15 +1098,11 @@ static void free_atfork(void* mem, const void *caller);
#endif
#ifndef MAP_NORESERVE
# ifdef MAP_AUTORESRV
# define MAP_NORESERVE MAP_AUTORESRV
# else
# define MAP_NORESERVE 0
# endif
# define MAP_NORESERVE 0
#endif
#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
initial_top treat the bin as a legal but unusable chunk during the
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.)
*/
@ -1854,8 +1807,8 @@ static void malloc_init_state(mstate av)
Other internal utilities operating on mstates
*/
static void* sYSMALLOc(INTERNAL_SIZE_T, mstate);
static int sYSTRIm(size_t, mstate);
static void* sysmalloc(INTERNAL_SIZE_T, mstate);
static int systrim(size_t, mstate);
static void malloc_consolidate(mstate);
@ -2270,7 +2223,7 @@ static void do_check_malloc_state(mstate av)
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 */
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 */
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) {
@ -2485,7 +2438,7 @@ static void* sYSMALLOc(INTERNAL_SIZE_T nb, mstate av)
/* Don't try if size wraps around 0 */
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) {
@ -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
memory at the `high' end of the malloc pool. It is called
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.
*/
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 extra; /* Amount to release */
@ -2783,7 +2736,7 @@ munmap_chunk(mchunkptr p)
/* If munmap failed the process virtual memory address space is in a
bad shape. Just leave the block hanging around, the process will
terminate shortly anyway since not much can be done. */
munmap((char *)block, total_size);
__munmap((char *)block, total_size);
}
#if HAVE_MREMAP
@ -2807,8 +2760,8 @@ mremap_chunk(mchunkptr p, size_t new_size)
if (size + offset == new_size)
return p;
cp = (char *)mremap((char *)p - offset, size + offset, new_size,
MREMAP_MAYMOVE);
cp = (char *)__mremap((char *)p - offset, size + offset, new_size,
MREMAP_MAYMOVE);
if (cp == MAP_FAILED) return 0;
@ -2831,7 +2784,7 @@ mremap_chunk(mchunkptr p, size_t new_size)
/*------------------------ Public wrappers. --------------------------------*/
void*
public_mALLOc(size_t bytes)
__libc_malloc(size_t bytes)
{
mstate ar_ptr;
void *victim;
@ -2870,10 +2823,10 @@ public_mALLOc(size_t bytes)
ar_ptr == arena_for_chunk(mem2chunk(victim)));
return victim;
}
libc_hidden_def(public_mALLOc)
libc_hidden_def(__libc_malloc)
void
public_fREe(void* mem)
__libc_free(void* mem)
{
mstate ar_ptr;
mchunkptr p; /* chunk corresponding to mem */
@ -2907,10 +2860,10 @@ public_fREe(void* mem)
ar_ptr = arena_for_chunk(p);
_int_free(ar_ptr, p, 0);
}
libc_hidden_def (public_fREe)
libc_hidden_def (__libc_free)
void*
public_rEALLOc(void* oldmem, size_t bytes)
__libc_realloc(void* oldmem, size_t bytes)
{
mstate ar_ptr;
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));
#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
/* 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 */
const mchunkptr oldp = mem2chunk(oldmem);
@ -2958,7 +2911,7 @@ public_rEALLOc(void* oldmem, size_t bytes)
/* Note the extra SIZE_SZ overhead. */
if(oldsize - SIZE_SZ >= nb) return oldmem; /* do nothing */
/* Must alloc, copy, free. */
newmem = public_mALLOc(bytes);
newmem = __libc_malloc(bytes);
if (newmem == 0) return 0; /* propagate failure */
MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
munmap_chunk(oldp);
@ -2991,7 +2944,7 @@ public_rEALLOc(void* oldmem, size_t bytes)
if (newp == NULL)
{
/* Try harder to allocate memory in other arenas. */
newp = public_mALLOc(bytes);
newp = __libc_malloc(bytes);
if (newp != NULL)
{
MALLOC_COPY (newp, oldmem, oldsize - SIZE_SZ);
@ -3001,10 +2954,10 @@ public_rEALLOc(void* oldmem, size_t bytes)
return newp;
}
libc_hidden_def (public_rEALLOc)
libc_hidden_def (__libc_realloc)
void*
public_mEMALIGn(size_t alignment, size_t bytes)
__libc_memalign(size_t alignment, size_t bytes)
{
mstate ar_ptr;
void *p;
@ -3016,7 +2969,7 @@ public_mEMALIGn(size_t alignment, size_t bytes)
return (*hook)(alignment, bytes, RETURN_ADDRESS (0));
/* 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 */
if (alignment < MINSIZE) alignment = MINSIZE;
@ -3050,11 +3003,11 @@ public_mEMALIGn(size_t alignment, size_t bytes)
return p;
}
/* For ISO C11. */
weak_alias (public_mEMALIGn, aligned_alloc)
libc_hidden_def (public_mEMALIGn)
weak_alias (__libc_memalign, aligned_alloc)
libc_hidden_def (__libc_memalign)
void*
public_vALLOc(size_t bytes)
__libc_valloc(size_t bytes)
{
mstate ar_ptr;
void *p;
@ -3098,7 +3051,7 @@ public_vALLOc(size_t bytes)
}
void*
public_pVALLOc(size_t bytes)
__libc_pvalloc(size_t bytes)
{
mstate ar_ptr;
void *p;
@ -3143,7 +3096,7 @@ public_pVALLOc(size_t bytes)
}
void*
public_cALLOc(size_t n, size_t elem_size)
__libc_calloc(size_t n, size_t elem_size)
{
mstate av;
mchunkptr oldtop, p;
@ -3275,64 +3228,6 @@ public_cALLOc(size_t n, size_t elem_size)
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 ------------------------------
*/
@ -3816,7 +3711,7 @@ _int_malloc(mstate av, size_t bytes)
Otherwise, relay to handle system-dependent cases
*/
else {
void *p = sYSMALLOc(nb, av);
void *p = sysmalloc(nb, av);
if (p != NULL && __builtin_expect (perturb_byte, 0))
alloc_perturb (p, bytes);
return p;
@ -4076,7 +3971,7 @@ _int_free(mstate av, mchunkptr p, int have_lock)
#ifndef MORECORE_CANNOT_TRIM
if ((unsigned long)(chunksize(av->top)) >=
(unsigned long)(mp_.trim_threshold))
sYSTRIm(mp_.top_pad, av);
systrim(mp_.top_pad, av);
#endif
} else {
/* Always try heap_trim(), even if the top chunk is not
@ -4511,7 +4406,7 @@ _int_pvalloc(mstate av, size_t bytes)
------------------------------ malloc_trim ------------------------------
*/
static int mTRIm(mstate av, size_t pad)
static int mtrim(mstate av, size_t pad)
{
/* Ensure initialization/consolidation */
malloc_consolidate (av);
@ -4559,18 +4454,42 @@ static int mTRIm(mstate av, size_t pad)
}
#ifndef MORECORE_CANNOT_TRIM
return result | (av == &main_arena ? sYSTRIm (pad, av) : 0);
return result | (av == &main_arena ? systrim (pad, av) : 0);
#else
return result;
#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 -------------------------
*/
size_t mUSABLe(void* mem)
static size_t
musable(void* mem)
{
mchunkptr p;
if (mem != 0) {
@ -4583,11 +4502,22 @@ size_t mUSABLe(void* mem)
return 0;
}
size_t
__malloc_usable_size(void* m)
{
size_t result;
result = musable(m);
return result;
}
/*
------------------------------ mallinfo ------------------------------
*/
struct mallinfo mALLINFo(mstate av)
static struct mallinfo
int_mallinfo(mstate av)
{
struct mallinfo mi;
size_t i;
@ -4642,11 +4572,25 @@ struct mallinfo mALLINFo(mstate av)
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 ------------------------------
*/
void mSTATs()
void
__malloc_stats()
{
int i;
mstate ar_ptr;
@ -4663,7 +4607,7 @@ void mSTATs()
((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
for (i=0, ar_ptr = &main_arena;; i++) {
(void)mutex_lock(&ar_ptr->mutex);
mi = mALLINFo(ar_ptr);
mi = int_mallinfo(ar_ptr);
fprintf(stderr, "Arena %d:\n", i);
fprintf(stderr, "system bytes = %10u\n", (unsigned int)mi.arena);
fprintf(stderr, "in use bytes = %10u\n", (unsigned int)mi.uordblks);
@ -4705,7 +4649,7 @@ void mSTATs()
------------------------------ mallopt ------------------------------
*/
int mALLOPt(int param_number, int value)
int __libc_mallopt(int param_number, int value)
{
mstate av = &main_arena;
int res = 1;
@ -4772,6 +4716,7 @@ int mALLOPt(int param_number, int value)
(void)mutex_unlock(&av->mutex);
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))
mem = (*hook)(alignment, size, RETURN_ADDRESS (0));
else
mem = public_mEMALIGn (alignment, size);
mem = __libc_memalign (alignment, size);
if (mem != NULL) {
*memptr = mem;