aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--ChangeLog6
-rw-r--r--malloc/arena.c47
-rw-r--r--malloc/hooks.c12
-rw-r--r--malloc/malloc.c275
4 files changed, 145 insertions, 195 deletions
diff --git a/ChangeLog b/ChangeLog
index e62d483..3425762 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -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>.
diff --git a/malloc/arena.c b/malloc/arena.c
index b1c9469..24c11f2 100644
--- a/malloc/arena.c
+++ b/malloc/arena.c
@@ -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
diff --git a/malloc/hooks.c b/malloc/hooks.c
index e38644d..2414d7d 100644
--- a/malloc/hooks.c
+++ b/malloc/hooks.c
@@ -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;
diff --git a/malloc/malloc.c b/malloc/malloc.c
index 12d2211..d8df9c7 100644
--- a/malloc/malloc.c
+++ b/malloc/malloc.c
@@ -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;