diff options
| -rw-r--r-- | ChangeLog | 6 | ||||
| -rw-r--r-- | malloc/arena.c | 47 | ||||
| -rw-r--r-- | malloc/hooks.c | 12 | ||||
| -rw-r--r-- | malloc/malloc.c | 275 |
4 files changed, 145 insertions, 195 deletions
diff --git a/ChangeLog b/ChangeLog index e62d483b07..3425762501 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 b1c9469ce0..24c11f225c 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 e38644d35c..2414d7dda8 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 12d2211b0d..d8df9c7762 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; |