This is the mail archive of the
libc-alpha@sourceware.org
mailing list for the glibc project.
[PING][PATCH] Reformat malloc to gnu style.
- From: OndÅej BÃlka <neleai at seznam dot cz>
- To: libc-alpha at sourceware dot org
- Date: Tue, 17 Dec 2013 10:54:18 +0100
- Subject: [PING][PATCH] Reformat malloc to gnu style.
- Authentication-results: sourceware.org; auth=none
- References: <20131211102701 dot GA25483 at domone dot podge>
ping
On Wed, Dec 11, 2013 at 11:27:01AM +0100, OndÅej BÃlka wrote:
> As written before that a malloc code should be reformatted and
> simplified I used formatter to mostly convert it to gnu style.
>
> A patch for this is relatively big, we could just check that code is
> equivalent and fix inconsistencies that are left as they are discovered.
>
> OK to commit?
>
> * malloc/arena.c (malloc_atfork, free_atfork, ptmalloc_lock_all,
> ptmalloc_unlock_all, ptmalloc_unlock_all2, next_env_entry,
> __failing_morecore, ptmalloc_init, dump_heap, new_heap, grow_heap,
> heap_trim, _int_new_arena, get_free_list, reused_arena, arena_get2):
> Convert to GNU style.
> * malloc/hooks.c (memalign_hook_ini, __malloc_check_init,
> mem2mem_check, mem2chunk_check, top_check, realloc_check,
> memalign_check, __malloc_set_state): Likewise.
> * malloc/mallocbug.c (main): Likewise.
> * malloc/malloc.c (__malloc_assert, malloc_init_state, free_perturb,
> do_check_malloced_chunk, do_check_malloc_state, sysmalloc, systrim,
> mremap_chunk, __libc_malloc, __libc_free, __libc_realloc, _mid_memalign,
> _int_malloc, malloc_consolidate, _int_realloc, _int_memalign, mtrim,
> musable, __libc_mallopt, __posix_memalign, malloc_info): Likewise.
> * malloc/malloc.h: Likewise.
> * malloc/mcheck.c (checkhdr, unlink_blk, link_blk, freehook, mallochook,
> memalignhook, reallochook, mabort): Likewise.
> * malloc/mcheck.h: Likewise.
> * malloc/memusage.c (update_data, me, malloc, realloc, calloc, free, mmap,
> mmap64, mremap, munmap, dest): Likewise.
> * malloc/memusagestat.c (main, parse_opt, more_help): Likewise.
> * malloc/morecore.c (__default_morecore): Likewise.
> * malloc/mtrace.c (tr_break, lock_and_info, mtrace): Likewise.
> * malloc/obstack.c (_obstack_begin, _obstack_newchunk,
> _obstack_allocated_p, obstack_free, _obstack_memory_used,
> print_and_abort): Likewise.
> * malloc/obstack.h: Likewise.
> * malloc/set-freeres.c (__libc_freeres): Likewise.
> * malloc/tst-mallocstate.c (main): Likewise.
> * malloc/tst-mtrace.c (main): Likewise.
> * malloc/tst-realloc.c (do_test): Likewise.
>
>
> diff --git a/malloc/arena.c b/malloc/arena.c
> index 9d49f93..fd41f48 100644
> --- a/malloc/arena.c
> +++ b/malloc/arena.c
> @@ -21,12 +21,12 @@
>
> /* Compile-time constants. */
>
> -#define HEAP_MIN_SIZE (32*1024)
> +#define HEAP_MIN_SIZE (32 * 1024)
> #ifndef HEAP_MAX_SIZE
> # ifdef DEFAULT_MMAP_THRESHOLD_MAX
> # define HEAP_MAX_SIZE (2 * DEFAULT_MMAP_THRESHOLD_MAX)
> # else
> -# define HEAP_MAX_SIZE (1024*1024) /* must be a power of two */
> +# define HEAP_MAX_SIZE (1024 * 1024) /* must be a power of two */
> # endif
> #endif
>
> @@ -39,7 +39,7 @@
>
>
> #ifndef THREAD_STATS
> -#define THREAD_STATS 0
> +# define THREAD_STATS 0
> #endif
>
> /* If THREAD_STATS is non-zero, some statistics on mutex locking are
> @@ -53,12 +53,13 @@
> malloc_chunks. It is allocated with mmap() and always starts at an
> address aligned to HEAP_MAX_SIZE. */
>
> -typedef struct _heap_info {
> +typedef struct _heap_info
> +{
> mstate ar_ptr; /* Arena for this heap. */
> struct _heap_info *prev; /* Previous heap. */
> size_t size; /* Current size in bytes. */
> - size_t mprotect_size; /* Size in bytes that has been mprotected
> - PROT_READ|PROT_WRITE. */
> + size_t mprotect_size; /* Size in bytes that has been mprotected
> + PROT_READ|PROT_WRITE. */
> /* Make sure the following data is properly aligned, particularly
> that sizeof (heap_info) + 2 * SIZE_SZ is a multiple of
> MALLOC_ALIGNMENT. */
> @@ -68,8 +69,8 @@ typedef struct _heap_info {
> /* Get a compile-time error if the heap_info padding is not correct
> to make alignment work as expected in sYSMALLOc. */
> extern int sanity_check_heap_info_alignment[(sizeof (heap_info)
> - + 2 * SIZE_SZ) % MALLOC_ALIGNMENT
> - ? -1 : 1];
> + + 2 * SIZE_SZ) % MALLOC_ALIGNMENT
> + ? -1 : 1];
>
> /* Thread specific data */
>
> @@ -80,9 +81,9 @@ static mstate free_list;
>
> #if THREAD_STATS
> static int stat_n_heaps;
> -#define THREAD_STAT(x) x
> +# define THREAD_STAT(x) x
> #else
> -#define THREAD_STAT(x) do ; while(0)
> +# define THREAD_STAT(x) do ; while (0)
> #endif
>
> /* Mapped memory in non-main arenas (reliable only for NO_THREADS). */
> @@ -103,28 +104,28 @@ int __malloc_initialized = -1;
> in the new arena. */
>
> #define arena_get(ptr, size) do { \
> - arena_lookup(ptr); \
> - arena_lock(ptr, size); \
> -} while(0)
> + arena_lookup (ptr); \
> + arena_lock (ptr, size); \
> + } while (0)
>
> #define arena_lookup(ptr) do { \
> - void *vptr = NULL; \
> - ptr = (mstate)tsd_getspecific(arena_key, vptr); \
> -} while(0)
> + void *vptr = NULL; \
> + ptr = (mstate) tsd_getspecific (arena_key, vptr); \
> + } while (0)
>
> -# define arena_lock(ptr, size) do { \
> - if(ptr) \
> - (void)mutex_lock(&ptr->mutex); \
> - else \
> - ptr = arena_get2(ptr, (size), NULL); \
> -} while(0)
> +#define arena_lock(ptr, size) do { \
> + if (ptr) \
> + (void) mutex_lock (&ptr->mutex); \
> + else \
> + ptr = arena_get2 (ptr, (size), NULL); \
> + } while (0)
>
> /* find the heap and corresponding arena for a given ptr */
>
> #define heap_for_ptr(ptr) \
> - ((heap_info *)((unsigned long)(ptr) & ~(HEAP_MAX_SIZE-1)))
> + ((heap_info *) ((unsigned long) (ptr) & ~(HEAP_MAX_SIZE - 1)))
> #define arena_for_chunk(ptr) \
> - (chunk_non_main_arena(ptr) ? heap_for_ptr(ptr)->ar_ptr : &main_arena)
> + (chunk_non_main_arena (ptr) ? heap_for_ptr (ptr)->ar_ptr : &main_arena)
>
>
> /**************************************************************************/
> @@ -133,51 +134,58 @@ int __malloc_initialized = -1;
>
> /* atfork support. */
>
> -static void *(*save_malloc_hook) (size_t __size, const void *);
> +static void *(*save_malloc_hook)(size_t __size, const void *);
> static void (*save_free_hook) (void *__ptr, const void *);
> static void *save_arena;
>
> -#ifdef ATFORK_MEM
> +# ifdef ATFORK_MEM
> ATFORK_MEM;
> -#endif
> +# endif
>
> /* Magic value for the thread-specific arena pointer when
> malloc_atfork() is in use. */
>
> -#define ATFORK_ARENA_PTR ((void*)-1)
> +# define ATFORK_ARENA_PTR ((void *) -1)
>
> /* The following hooks are used while the `atfork' handling mechanism
> is active. */
>
> -static void*
> -malloc_atfork(size_t sz, const void *caller)
> +static void *
> +malloc_atfork (size_t sz, const void *caller)
> {
> void *vptr = NULL;
> void *victim;
>
> - tsd_getspecific(arena_key, vptr);
> - if(vptr == ATFORK_ARENA_PTR) {
> - /* We are the only thread that may allocate at all. */
> - if(save_malloc_hook != malloc_check) {
> - return _int_malloc(&main_arena, sz);
> - } else {
> - if(top_check()<0)
> - return 0;
> - victim = _int_malloc(&main_arena, sz+1);
> - return mem2mem_check(victim, sz);
> + tsd_getspecific (arena_key, vptr);
> + if (vptr == ATFORK_ARENA_PTR)
> + {
> + /* We are the only thread that may allocate at all. */
> + if (save_malloc_hook != malloc_check)
> + {
> + return _int_malloc (&main_arena, sz);
> + }
> + else
> + {
> + if (top_check () < 0)
> + return 0;
> +
> + victim = _int_malloc (&main_arena, sz + 1);
> + return mem2mem_check (victim, sz);
> + }
> + }
> + else
> + {
> + /* Suspend the thread until the `atfork' handlers have completed.
> + By that time, the hooks will have been reset as well, so that
> + mALLOc() can be used again. */
> + (void) mutex_lock (&list_lock);
> + (void) mutex_unlock (&list_lock);
> + return __libc_malloc (sz);
> }
> - } else {
> - /* Suspend the thread until the `atfork' handlers have completed.
> - By that time, the hooks will have been reset as well, so that
> - mALLOc() can be used again. */
> - (void)mutex_lock(&list_lock);
> - (void)mutex_unlock(&list_lock);
> - return __libc_malloc(sz);
> - }
> }
>
> static void
> -free_atfork(void* mem, const void *caller)
> +free_atfork (void *mem, const void *caller)
> {
> void *vptr = NULL;
> mstate ar_ptr;
> @@ -186,17 +194,17 @@ free_atfork(void* mem, const void *caller)
> if (mem == 0) /* free(0) has no effect */
> return;
>
> - p = mem2chunk(mem); /* do not bother to replicate free_check here */
> + p = mem2chunk (mem); /* do not bother to replicate free_check here */
>
> - if (chunk_is_mmapped(p)) /* release mmapped memory. */
> - {
> - munmap_chunk(p);
> - return;
> - }
> + if (chunk_is_mmapped (p)) /* release mmapped memory. */
> + {
> + munmap_chunk (p);
> + return;
> + }
>
> - ar_ptr = arena_for_chunk(p);
> - tsd_getspecific(arena_key, vptr);
> - _int_free(ar_ptr, p, vptr == ATFORK_ARENA_PTR);
> + ar_ptr = arena_for_chunk (p);
> + tsd_getspecific (arena_key, vptr);
> + _int_free (ar_ptr, p, vptr == ATFORK_ARENA_PTR);
> }
>
>
> @@ -214,33 +222,36 @@ ptmalloc_lock_all (void)
> {
> mstate ar_ptr;
>
> - if(__malloc_initialized < 1)
> + if (__malloc_initialized < 1)
> return;
> - if (mutex_trylock(&list_lock))
> +
> + if (mutex_trylock (&list_lock))
> {
> void *my_arena;
> - tsd_getspecific(arena_key, my_arena);
> + tsd_getspecific (arena_key, my_arena);
> if (my_arena == ATFORK_ARENA_PTR)
> - /* This is the same thread which already locks the global list.
> - Just bump the counter. */
> - goto out;
> + /* This is the same thread which already locks the global list.
> + Just bump the counter. */
> + goto out;
>
> /* This thread has to wait its turn. */
> - (void)mutex_lock(&list_lock);
> + (void) mutex_lock (&list_lock);
> + }
> + for (ar_ptr = &main_arena;; )
> + {
> + (void) mutex_lock (&ar_ptr->mutex);
> + ar_ptr = ar_ptr->next;
> + if (ar_ptr == &main_arena)
> + break;
> }
> - for(ar_ptr = &main_arena;;) {
> - (void)mutex_lock(&ar_ptr->mutex);
> - ar_ptr = ar_ptr->next;
> - if(ar_ptr == &main_arena) break;
> - }
> save_malloc_hook = __malloc_hook;
> save_free_hook = __free_hook;
> __malloc_hook = malloc_atfork;
> __free_hook = free_atfork;
> /* Only the current thread may perform malloc/free calls now. */
> - tsd_getspecific(arena_key, save_arena);
> - tsd_setspecific(arena_key, ATFORK_ARENA_PTR);
> - out:
> + tsd_getspecific (arena_key, save_arena);
> + tsd_setspecific (arena_key, ATFORK_ARENA_PTR);
> +out:
> ++atfork_recursive_cntr;
> }
>
> @@ -249,19 +260,23 @@ ptmalloc_unlock_all (void)
> {
> mstate ar_ptr;
>
> - if(__malloc_initialized < 1)
> + if (__malloc_initialized < 1)
> return;
> +
> if (--atfork_recursive_cntr != 0)
> return;
> - tsd_setspecific(arena_key, save_arena);
> +
> + tsd_setspecific (arena_key, save_arena);
> __malloc_hook = save_malloc_hook;
> __free_hook = save_free_hook;
> - for(ar_ptr = &main_arena;;) {
> - (void)mutex_unlock(&ar_ptr->mutex);
> - ar_ptr = ar_ptr->next;
> - if(ar_ptr == &main_arena) break;
> - }
> - (void)mutex_unlock(&list_lock);
> + for (ar_ptr = &main_arena;; )
> + {
> + (void) mutex_unlock (&ar_ptr->mutex);
> + ar_ptr = ar_ptr->next;
> + if (ar_ptr == &main_arena)
> + break;
> + }
> + (void) mutex_unlock (&list_lock);
> }
>
> # ifdef __linux__
> @@ -276,31 +291,33 @@ ptmalloc_unlock_all2 (void)
> {
> mstate ar_ptr;
>
> - if(__malloc_initialized < 1)
> + if (__malloc_initialized < 1)
> return;
> - tsd_setspecific(arena_key, save_arena);
> +
> + tsd_setspecific (arena_key, save_arena);
> __malloc_hook = save_malloc_hook;
> __free_hook = save_free_hook;
> free_list = NULL;
> - for(ar_ptr = &main_arena;;) {
> - mutex_init(&ar_ptr->mutex);
> - if (ar_ptr != save_arena) {
> - ar_ptr->next_free = free_list;
> - free_list = ar_ptr;
> + for (ar_ptr = &main_arena;; )
> + {
> + mutex_init (&ar_ptr->mutex);
> + if (ar_ptr != save_arena)
> + {
> + ar_ptr->next_free = free_list;
> + free_list = ar_ptr;
> + }
> + ar_ptr = ar_ptr->next;
> + if (ar_ptr == &main_arena)
> + break;
> }
> - ar_ptr = ar_ptr->next;
> - if(ar_ptr == &main_arena) break;
> - }
> - mutex_init(&list_lock);
> + mutex_init (&list_lock);
> atfork_recursive_cntr = 0;
> }
>
> # else
>
> # define ptmalloc_unlock_all2 ptmalloc_unlock_all
> -
> # endif
> -
> #endif /* !NO_THREADS */
>
> /* Initialization routine. */
> @@ -317,20 +334,20 @@ next_env_entry (char ***position)
> while (*current != NULL)
> {
> if (__builtin_expect ((*current)[0] == 'M', 0)
> - && (*current)[1] == 'A'
> - && (*current)[2] == 'L'
> - && (*current)[3] == 'L'
> - && (*current)[4] == 'O'
> - && (*current)[5] == 'C'
> - && (*current)[6] == '_')
> - {
> - result = &(*current)[7];
> + && (*current)[1] == 'A'
> + && (*current)[2] == 'L'
> + && (*current)[3] == 'L'
> + && (*current)[4] == 'O'
> + && (*current)[5] == 'C'
> + && (*current)[6] == '_')
> + {
> + result = &(*current)[7];
>
> - /* Save current position for next visit. */
> - *position = ++current;
> + /* Save current position for next visit. */
> + *position = ++current;
>
> - break;
> - }
> + break;
> + }
>
> ++current;
> }
> @@ -353,7 +370,9 @@ libc_hidden_proto (_dl_open_hook);
> static void
> ptmalloc_init (void)
> {
> - if(__malloc_initialized >= 0) return;
> + if (__malloc_initialized >= 0)
> + return;
> +
> __malloc_initialized = 0;
>
> #ifdef SHARED
> @@ -364,13 +383,13 @@ ptmalloc_init (void)
>
> if (_dl_open_hook != NULL
> || (_dl_addr (ptmalloc_init, &di, &l, NULL) != 0
> - && l->l_ns != LM_ID_BASE))
> + && l->l_ns != LM_ID_BASE))
> __morecore = __failing_morecore;
> #endif
>
> - tsd_key_create(&arena_key, NULL);
> - tsd_setspecific(arena_key, (void *)&main_arena);
> - thread_atfork(ptmalloc_lock_all, ptmalloc_unlock_all, ptmalloc_unlock_all2);
> + tsd_key_create (&arena_key, NULL);
> + tsd_setspecific (arena_key, (void *) &main_arena);
> + thread_atfork (ptmalloc_lock_all, ptmalloc_unlock_all, ptmalloc_unlock_all2);
> const char *s = NULL;
> if (__builtin_expect (_environ != NULL, 1))
> {
> @@ -378,66 +397,67 @@ ptmalloc_init (void)
> char *envline;
>
> while (__builtin_expect ((envline = next_env_entry (&runp)) != NULL,
> - 0))
> - {
> - size_t len = strcspn (envline, "=");
> -
> - if (envline[len] != '=')
> - /* This is a "MALLOC_" variable at the end of the string
> - without a '=' character. Ignore it since otherwise we
> - will access invalid memory below. */
> - continue;
> -
> - switch (len)
> - {
> - case 6:
> - if (memcmp (envline, "CHECK_", 6) == 0)
> - s = &envline[7];
> - break;
> - case 8:
> - if (! __builtin_expect (__libc_enable_secure, 0))
> - {
> - if (memcmp (envline, "TOP_PAD_", 8) == 0)
> - __libc_mallopt(M_TOP_PAD, atoi(&envline[9]));
> - else if (memcmp (envline, "PERTURB_", 8) == 0)
> - __libc_mallopt(M_PERTURB, atoi(&envline[9]));
> - }
> - break;
> - case 9:
> - if (! __builtin_expect (__libc_enable_secure, 0))
> - {
> - if (memcmp (envline, "MMAP_MAX_", 9) == 0)
> - __libc_mallopt(M_MMAP_MAX, atoi(&envline[10]));
> - else if (memcmp (envline, "ARENA_MAX", 9) == 0)
> - __libc_mallopt(M_ARENA_MAX, atoi(&envline[10]));
> - }
> - break;
> - case 10:
> - if (! __builtin_expect (__libc_enable_secure, 0))
> - {
> - if (memcmp (envline, "ARENA_TEST", 10) == 0)
> - __libc_mallopt(M_ARENA_TEST, atoi(&envline[11]));
> - }
> - break;
> - case 15:
> - if (! __builtin_expect (__libc_enable_secure, 0))
> - {
> - if (memcmp (envline, "TRIM_THRESHOLD_", 15) == 0)
> - __libc_mallopt(M_TRIM_THRESHOLD, atoi(&envline[16]));
> - else if (memcmp (envline, "MMAP_THRESHOLD_", 15) == 0)
> - __libc_mallopt(M_MMAP_THRESHOLD, atoi(&envline[16]));
> - }
> - break;
> - default:
> - break;
> - }
> - }
> + 0))
> + {
> + size_t len = strcspn (envline, "=");
> +
> + if (envline[len] != '=')
> + /* This is a "MALLOC_" variable at the end of the string
> + without a '=' character. Ignore it since otherwise we
> + will access invalid memory below. */
> + continue;
> +
> + switch (len)
> + {
> + case 6:
> + if (memcmp (envline, "CHECK_", 6) == 0)
> + s = &envline[7];
> + break;
> + case 8:
> + if (!__builtin_expect (__libc_enable_secure, 0))
> + {
> + if (memcmp (envline, "TOP_PAD_", 8) == 0)
> + __libc_mallopt (M_TOP_PAD, atoi (&envline[9]));
> + else if (memcmp (envline, "PERTURB_", 8) == 0)
> + __libc_mallopt (M_PERTURB, atoi (&envline[9]));
> + }
> + break;
> + case 9:
> + if (!__builtin_expect (__libc_enable_secure, 0))
> + {
> + if (memcmp (envline, "MMAP_MAX_", 9) == 0)
> + __libc_mallopt (M_MMAP_MAX, atoi (&envline[10]));
> + else if (memcmp (envline, "ARENA_MAX", 9) == 0)
> + __libc_mallopt (M_ARENA_MAX, atoi (&envline[10]));
> + }
> + break;
> + case 10:
> + if (!__builtin_expect (__libc_enable_secure, 0))
> + {
> + if (memcmp (envline, "ARENA_TEST", 10) == 0)
> + __libc_mallopt (M_ARENA_TEST, atoi (&envline[11]));
> + }
> + break;
> + case 15:
> + if (!__builtin_expect (__libc_enable_secure, 0))
> + {
> + if (memcmp (envline, "TRIM_THRESHOLD_", 15) == 0)
> + __libc_mallopt (M_TRIM_THRESHOLD, atoi (&envline[16]));
> + else if (memcmp (envline, "MMAP_THRESHOLD_", 15) == 0)
> + __libc_mallopt (M_MMAP_THRESHOLD, atoi (&envline[16]));
> + }
> + break;
> + default:
> + break;
> + }
> + }
> + }
> + if (s && s[0])
> + {
> + __libc_mallopt (M_CHECK_ACTION, (int) (s[0] - '0'));
> + if (check_action != 0)
> + __malloc_check_init ();
> }
> - if(s && s[0]) {
> - __libc_mallopt(M_CHECK_ACTION, (int)(s[0] - '0'));
> - if (check_action != 0)
> - __malloc_check_init();
> - }
> void (*hook) (void) = atomic_forced_read (__malloc_initialize_hook);
> if (hook != NULL)
> (*hook)();
> @@ -446,11 +466,11 @@ ptmalloc_init (void)
>
> /* There are platforms (e.g. Hurd) with a link-time hook mechanism. */
> #ifdef thread_atfork_static
> -thread_atfork_static(ptmalloc_lock_all, ptmalloc_unlock_all, \
> - ptmalloc_unlock_all2)
> +thread_atfork_static (ptmalloc_lock_all, ptmalloc_unlock_all, \
> + ptmalloc_unlock_all2)
> #endif
>
> -
> +
>
> /* Managing heaps and arenas (for concurrent threads) */
>
> @@ -459,30 +479,33 @@ thread_atfork_static(ptmalloc_lock_all, ptmalloc_unlock_all, \
> /* Print the complete contents of a single heap to stderr. */
>
> static void
> -dump_heap(heap_info *heap)
> +dump_heap (heap_info *heap)
> {
> char *ptr;
> mchunkptr p;
>
> - fprintf(stderr, "Heap %p, size %10lx:\n", heap, (long)heap->size);
> - ptr = (heap->ar_ptr != (mstate)(heap+1)) ?
> - (char*)(heap + 1) : (char*)(heap + 1) + sizeof(struct malloc_state);
> - p = (mchunkptr)(((unsigned long)ptr + MALLOC_ALIGN_MASK) &
> - ~MALLOC_ALIGN_MASK);
> - for(;;) {
> - fprintf(stderr, "chunk %p size %10lx", p, (long)p->size);
> - if(p == top(heap->ar_ptr)) {
> - fprintf(stderr, " (top)\n");
> - break;
> - } else if(p->size == (0|PREV_INUSE)) {
> - fprintf(stderr, " (fence)\n");
> - break;
> + fprintf (stderr, "Heap %p, size %10lx:\n", heap, (long) heap->size);
> + ptr = (heap->ar_ptr != (mstate) (heap + 1)) ?
> + (char *) (heap + 1) : (char *) (heap + 1) + sizeof (struct malloc_state);
> + p = (mchunkptr) (((unsigned long) ptr + MALLOC_ALIGN_MASK) &
> + ~MALLOC_ALIGN_MASK);
> + for (;; )
> + {
> + fprintf (stderr, "chunk %p size %10lx", p, (long) p->size);
> + if (p == top (heap->ar_ptr))
> + {
> + fprintf (stderr, " (top)\n");
> + break;
> + }
> + else if (p->size == (0 | PREV_INUSE))
> + {
> + fprintf (stderr, " (fence)\n");
> + break;
> + }
> + fprintf (stderr, "\n");
> + p = next_chunk (p);
> }
> - fprintf(stderr, "\n");
> - p = next_chunk(p);
> - }
> }
> -
> #endif /* MALLOC_DEBUG > 1 */
>
> /* If consecutive mmap (0, HEAP_MAX_SIZE << 1, ...) calls return decreasing
> @@ -500,18 +523,18 @@ static char *aligned_heap_area;
>
> static heap_info *
> internal_function
> -new_heap(size_t size, size_t top_pad)
> +new_heap (size_t size, size_t top_pad)
> {
> - size_t page_mask = GLRO(dl_pagesize) - 1;
> + size_t page_mask = GLRO (dl_pagesize) - 1;
> char *p1, *p2;
> unsigned long ul;
> heap_info *h;
>
> - if(size+top_pad < HEAP_MIN_SIZE)
> + if (size + top_pad < HEAP_MIN_SIZE)
> size = HEAP_MIN_SIZE;
> - else if(size+top_pad <= HEAP_MAX_SIZE)
> + else if (size + top_pad <= HEAP_MAX_SIZE)
> size += top_pad;
> - else if(size > HEAP_MAX_SIZE)
> + else if (size > HEAP_MAX_SIZE)
> return 0;
> else
> size = HEAP_MAX_SIZE;
> @@ -522,46 +545,55 @@ new_heap(size_t size, size_t top_pad)
> mapping (on Linux, this is the case for all non-writable mappings
> anyway). */
> p2 = MAP_FAILED;
> - if(aligned_heap_area) {
> - p2 = (char *)MMAP(aligned_heap_area, HEAP_MAX_SIZE, PROT_NONE,
> - MAP_NORESERVE);
> - aligned_heap_area = NULL;
> - if (p2 != MAP_FAILED && ((unsigned long)p2 & (HEAP_MAX_SIZE-1))) {
> - __munmap(p2, HEAP_MAX_SIZE);
> - p2 = MAP_FAILED;
> + if (aligned_heap_area)
> + {
> + p2 = (char *) MMAP (aligned_heap_area, HEAP_MAX_SIZE, PROT_NONE,
> + MAP_NORESERVE);
> + aligned_heap_area = NULL;
> + if (p2 != MAP_FAILED && ((unsigned long) p2 & (HEAP_MAX_SIZE - 1)))
> + {
> + __munmap (p2, HEAP_MAX_SIZE);
> + p2 = MAP_FAILED;
> + }
> }
> - }
> - if(p2 == MAP_FAILED) {
> - 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);
> + if (p2 == MAP_FAILED)
> + {
> + 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);
> + else
> + aligned_heap_area = p2 + HEAP_MAX_SIZE;
> + __munmap (p2 + HEAP_MAX_SIZE, HEAP_MAX_SIZE - ul);
> + }
> else
> - aligned_heap_area = p2 + HEAP_MAX_SIZE;
> - __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_NORESERVE);
> - if(p2 == MAP_FAILED)
> - return 0;
> - if((unsigned long)p2 & (HEAP_MAX_SIZE-1)) {
> - __munmap(p2, HEAP_MAX_SIZE);
> - return 0;
> - }
> + {
> + /* 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_NORESERVE);
> + if (p2 == MAP_FAILED)
> + return 0;
> +
> + if ((unsigned long) p2 & (HEAP_MAX_SIZE - 1))
> + {
> + __munmap (p2, HEAP_MAX_SIZE);
> + return 0;
> + }
> + }
> }
> - }
> - if(__mprotect(p2, size, PROT_READ|PROT_WRITE) != 0) {
> - __munmap(p2, HEAP_MAX_SIZE);
> - return 0;
> - }
> - h = (heap_info *)p2;
> + if (__mprotect (p2, size, PROT_READ | PROT_WRITE) != 0)
> + {
> + __munmap (p2, HEAP_MAX_SIZE);
> + return 0;
> + }
> + h = (heap_info *) p2;
> h->size = size;
> h->mprotect_size = size;
> - THREAD_STAT(stat_n_heaps++);
> + THREAD_STAT (stat_n_heaps++);
> LIBC_PROBE (memory_heap_new, 2, h, h->size);
> return h;
> }
> @@ -570,22 +602,25 @@ new_heap(size_t size, size_t top_pad)
> multiple of the page size. */
>
> static int
> -grow_heap(heap_info *h, long diff)
> +grow_heap (heap_info *h, long diff)
> {
> - size_t page_mask = GLRO(dl_pagesize) - 1;
> + size_t page_mask = GLRO (dl_pagesize) - 1;
> long new_size;
>
> diff = (diff + page_mask) & ~page_mask;
> - new_size = (long)h->size + diff;
> - if((unsigned long) new_size > (unsigned long) HEAP_MAX_SIZE)
> + new_size = (long) h->size + 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)
> - return -2;
> - h->mprotect_size = new_size;
> - }
> +
> + 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)
> + return -2;
> +
> + h->mprotect_size = new_size;
> + }
>
> h->size = new_size;
> LIBC_PROBE (memory_heap_more, 2, h, h->size);
> @@ -595,24 +630,26 @@ grow_heap(heap_info *h, long diff)
> /* Shrink a heap. */
>
> static int
> -shrink_heap(heap_info *h, long diff)
> +shrink_heap (heap_info *h, long diff)
> {
> long new_size;
>
> - new_size = (long)h->size - diff;
> - if(new_size < (long)sizeof(*h))
> + new_size = (long) h->size - diff;
> + if (new_size < (long) sizeof (*h))
> return -1;
> +
> /* Try to re-map the extra heap space freshly to save memory, and make it
> inaccessible. See malloc-sysdep.h to know when this is true. */
> if (__builtin_expect (check_may_shrink_heap (), 0))
> {
> - if((char *)MMAP((char *)h + new_size, diff, PROT_NONE,
> - MAP_FIXED) == (char *) MAP_FAILED)
> - return -2;
> + if ((char *) MMAP ((char *) h + new_size, diff, PROT_NONE,
> + MAP_FIXED) == (char *) MAP_FAILED)
> + return -2;
> +
> h->mprotect_size = new_size;
> }
> else
> - __madvise ((char *)h + new_size, diff, MADV_DONTNEED);
> + __madvise ((char *) h + new_size, diff, MADV_DONTNEED);
> /*fprintf(stderr, "shrink %p %08lx\n", h, new_size);*/
>
> h->size = new_size;
> @@ -623,66 +660,70 @@ shrink_heap(heap_info *h, long diff)
> /* Delete a heap. */
>
> #define delete_heap(heap) \
> - do { \
> - if ((char *)(heap) + HEAP_MAX_SIZE == aligned_heap_area) \
> - aligned_heap_area = NULL; \
> - __munmap((char*)(heap), HEAP_MAX_SIZE); \
> - } while (0)
> + do { \
> + if ((char *) (heap) + HEAP_MAX_SIZE == aligned_heap_area) \
> + aligned_heap_area = NULL; \
> + __munmap ((char *) (heap), HEAP_MAX_SIZE); \
> + } while (0)
>
> static int
> internal_function
> -heap_trim(heap_info *heap, size_t pad)
> +heap_trim (heap_info *heap, size_t pad)
> {
> mstate ar_ptr = heap->ar_ptr;
> - unsigned long pagesz = GLRO(dl_pagesize);
> - mchunkptr top_chunk = top(ar_ptr), p, bck, fwd;
> + unsigned long pagesz = GLRO (dl_pagesize);
> + mchunkptr top_chunk = top (ar_ptr), p, bck, fwd;
> heap_info *prev_heap;
> long new_size, top_size, extra, prev_size, misalign;
>
> /* Can this heap go away completely? */
> - while(top_chunk == chunk_at_offset(heap, sizeof(*heap))) {
> - prev_heap = heap->prev;
> - prev_size = prev_heap->size - (MINSIZE-2*SIZE_SZ);
> - p = chunk_at_offset(prev_heap, prev_size);
> - /* fencepost must be properly aligned. */
> - misalign = ((long) p) & MALLOC_ALIGN_MASK;
> - p = chunk_at_offset(prev_heap, prev_size - misalign);
> - assert(p->size == (0|PREV_INUSE)); /* must be fencepost */
> - p = prev_chunk(p);
> - new_size = chunksize(p) + (MINSIZE-2*SIZE_SZ) + misalign;
> - assert(new_size>0 && new_size<(long)(2*MINSIZE));
> - if(!prev_inuse(p))
> - new_size += p->prev_size;
> - assert(new_size>0 && new_size<HEAP_MAX_SIZE);
> - if(new_size + (HEAP_MAX_SIZE - prev_heap->size) < pad + MINSIZE + pagesz)
> - break;
> - ar_ptr->system_mem -= heap->size;
> - arena_mem -= heap->size;
> - LIBC_PROBE (memory_heap_free, 2, heap, heap->size);
> - delete_heap(heap);
> - heap = prev_heap;
> - if(!prev_inuse(p)) { /* consolidate backward */
> - p = prev_chunk(p);
> - unlink(p, bck, fwd);
> + while (top_chunk == chunk_at_offset (heap, sizeof (*heap)))
> + {
> + prev_heap = heap->prev;
> + prev_size = prev_heap->size - (MINSIZE - 2 * SIZE_SZ);
> + p = chunk_at_offset (prev_heap, prev_size);
> + /* fencepost must be properly aligned. */
> + misalign = ((long) p) & MALLOC_ALIGN_MASK;
> + p = chunk_at_offset (prev_heap, prev_size - misalign);
> + assert (p->size == (0 | PREV_INUSE)); /* must be fencepost */
> + p = prev_chunk (p);
> + new_size = chunksize (p) + (MINSIZE - 2 * SIZE_SZ) + misalign;
> + assert (new_size > 0 && new_size < (long) (2 * MINSIZE));
> + if (!prev_inuse (p))
> + new_size += p->prev_size;
> + assert (new_size > 0 && new_size < HEAP_MAX_SIZE);
> + if (new_size + (HEAP_MAX_SIZE - prev_heap->size) < pad + MINSIZE + pagesz)
> + break;
> + ar_ptr->system_mem -= heap->size;
> + arena_mem -= heap->size;
> + LIBC_PROBE (memory_heap_free, 2, heap, heap->size);
> + delete_heap (heap);
> + heap = prev_heap;
> + if (!prev_inuse (p)) /* consolidate backward */
> + {
> + p = prev_chunk (p);
> + unlink (p, bck, fwd);
> + }
> + assert (((unsigned long) ((char *) p + new_size) & (pagesz - 1)) == 0);
> + assert (((char *) p + new_size) == ((char *) heap + heap->size));
> + top (ar_ptr) = top_chunk = p;
> + set_head (top_chunk, new_size | PREV_INUSE);
> + /*check_chunk(ar_ptr, top_chunk);*/
> }
> - assert(((unsigned long)((char*)p + new_size) & (pagesz-1)) == 0);
> - assert( ((char*)p + new_size) == ((char*)heap + heap->size) );
> - top(ar_ptr) = top_chunk = p;
> - set_head(top_chunk, new_size | PREV_INUSE);
> - /*check_chunk(ar_ptr, top_chunk);*/
> - }
> - top_size = chunksize(top_chunk);
> + top_size = chunksize (top_chunk);
> extra = (top_size - pad - MINSIZE - 1) & ~(pagesz - 1);
> - if(extra < (long)pagesz)
> + if (extra < (long) pagesz)
> return 0;
> +
> /* Try to shrink. */
> - if(shrink_heap(heap, extra) != 0)
> + if (shrink_heap (heap, extra) != 0)
> return 0;
> +
> ar_ptr->system_mem -= extra;
> arena_mem -= extra;
>
> /* Success. Adjust top accordingly. */
> - set_head(top_chunk, (top_size - extra) | PREV_INUSE);
> + set_head (top_chunk, (top_size - extra) | PREV_INUSE);
> /*check_chunk(ar_ptr, top_chunk);*/
> return 1;
> }
> @@ -690,52 +731,53 @@ heap_trim(heap_info *heap, size_t pad)
> /* Create a new arena with initial size "size". */
>
> static mstate
> -_int_new_arena(size_t size)
> +_int_new_arena (size_t size)
> {
> mstate a;
> heap_info *h;
> char *ptr;
> unsigned long misalign;
>
> - h = new_heap(size + (sizeof(*h) + sizeof(*a) + MALLOC_ALIGNMENT),
> - mp_.top_pad);
> - if(!h) {
> - /* Maybe size is too large to fit in a single heap. So, just try
> - to create a minimally-sized arena and let _int_malloc() attempt
> - to deal with the large request via mmap_chunk(). */
> - h = new_heap(sizeof(*h) + sizeof(*a) + MALLOC_ALIGNMENT, mp_.top_pad);
> - if(!h)
> - return 0;
> - }
> - a = h->ar_ptr = (mstate)(h+1);
> - malloc_init_state(a);
> + h = new_heap (size + (sizeof (*h) + sizeof (*a) + MALLOC_ALIGNMENT),
> + mp_.top_pad);
> + if (!h)
> + {
> + /* Maybe size is too large to fit in a single heap. So, just try
> + to create a minimally-sized arena and let _int_malloc() attempt
> + to deal with the large request via mmap_chunk(). */
> + h = new_heap (sizeof (*h) + sizeof (*a) + MALLOC_ALIGNMENT, mp_.top_pad);
> + if (!h)
> + return 0;
> + }
> + a = h->ar_ptr = (mstate) (h + 1);
> + malloc_init_state (a);
> /*a->next = NULL;*/
> a->system_mem = a->max_system_mem = h->size;
> arena_mem += h->size;
>
> /* Set up the top chunk, with proper alignment. */
> - ptr = (char *)(a + 1);
> - misalign = (unsigned long)chunk2mem(ptr) & MALLOC_ALIGN_MASK;
> + ptr = (char *) (a + 1);
> + misalign = (unsigned long) chunk2mem (ptr) & MALLOC_ALIGN_MASK;
> if (misalign > 0)
> ptr += MALLOC_ALIGNMENT - misalign;
> - top(a) = (mchunkptr)ptr;
> - set_head(top(a), (((char*)h + h->size) - ptr) | PREV_INUSE);
> + top (a) = (mchunkptr) ptr;
> + set_head (top (a), (((char *) h + h->size) - ptr) | PREV_INUSE);
>
> LIBC_PROBE (memory_arena_new, 2, a, size);
> - tsd_setspecific(arena_key, (void *)a);
> - mutex_init(&a->mutex);
> - (void)mutex_lock(&a->mutex);
> + tsd_setspecific (arena_key, (void *) a);
> + mutex_init (&a->mutex);
> + (void) mutex_lock (&a->mutex);
>
> - (void)mutex_lock(&list_lock);
> + (void) mutex_lock (&list_lock);
>
> /* Add the new arena to the global list. */
> a->next = main_arena.next;
> atomic_write_barrier ();
> main_arena.next = a;
>
> - (void)mutex_unlock(&list_lock);
> + (void) mutex_unlock (&list_lock);
>
> - THREAD_STAT(++(a->stat_lock_loop));
> + THREAD_STAT (++(a->stat_lock_loop));
>
> return a;
> }
> @@ -747,19 +789,19 @@ get_free_list (void)
> mstate result = free_list;
> if (result != NULL)
> {
> - (void)mutex_lock(&list_lock);
> + (void) mutex_lock (&list_lock);
> result = free_list;
> if (result != NULL)
> - free_list = result->next_free;
> - (void)mutex_unlock(&list_lock);
> + free_list = result->next_free;
> + (void) mutex_unlock (&list_lock);
>
> if (result != NULL)
> - {
> - LIBC_PROBE (memory_arena_reuse_free_list, 1, result);
> - (void)mutex_lock(&result->mutex);
> - tsd_setspecific(arena_key, (void *)result);
> - THREAD_STAT(++(result->stat_lock_loop));
> - }
> + {
> + LIBC_PROBE (memory_arena_reuse_free_list, 1, result);
> + (void) mutex_lock (&result->mutex);
> + tsd_setspecific (arena_key, (void *) result);
> + THREAD_STAT (++(result->stat_lock_loop));
> + }
> }
>
> return result;
> @@ -779,8 +821,8 @@ reused_arena (mstate avoid_arena)
> result = next_to_use;
> do
> {
> - if (!mutex_trylock(&result->mutex))
> - goto out;
> + if (!mutex_trylock (&result->mutex))
> + goto out;
>
> result = result->next;
> }
> @@ -793,12 +835,12 @@ reused_arena (mstate avoid_arena)
>
> /* No arena available. Wait for the next in line. */
> LIBC_PROBE (memory_arena_reuse_wait, 3, &result->mutex, result, avoid_arena);
> - (void)mutex_lock(&result->mutex);
> + (void) mutex_lock (&result->mutex);
>
> - out:
> +out:
> LIBC_PROBE (memory_arena_reuse, 2, result, avoid_arena);
> - tsd_setspecific(arena_key, (void *)result);
> - THREAD_STAT(++(result->stat_lock_loop));
> + tsd_setspecific (arena_key, (void *) result);
> + THREAD_STAT (++(result->stat_lock_loop));
> next_to_use = result->next;
>
> return result;
> @@ -806,7 +848,7 @@ reused_arena (mstate avoid_arena)
>
> static mstate
> internal_function
> -arena_get2(mstate a_tsd, size_t size, mstate avoid_arena)
> +arena_get2 (mstate a_tsd, size_t size, mstate avoid_arena)
> {
> mstate a;
>
> @@ -817,40 +859,40 @@ arena_get2(mstate a_tsd, size_t size, mstate avoid_arena)
> {
> /* Nothing immediately available, so generate a new arena. */
> if (narenas_limit == 0)
> - {
> - if (mp_.arena_max != 0)
> - narenas_limit = mp_.arena_max;
> - else if (narenas > mp_.arena_test)
> - {
> - int n = __get_nprocs ();
> -
> - if (n >= 1)
> - narenas_limit = NARENAS_FROM_NCORES (n);
> - else
> - /* We have no information about the system. Assume two
> - cores. */
> - narenas_limit = NARENAS_FROM_NCORES (2);
> - }
> - }
> + {
> + if (mp_.arena_max != 0)
> + narenas_limit = mp_.arena_max;
> + else if (narenas > mp_.arena_test)
> + {
> + int n = __get_nprocs ();
> +
> + if (n >= 1)
> + narenas_limit = NARENAS_FROM_NCORES (n);
> + else
> + /* We have no information about the system. Assume two
> + cores. */
> + narenas_limit = NARENAS_FROM_NCORES (2);
> + }
> + }
> repeat:;
> size_t n = narenas;
> /* NB: the following depends on the fact that (size_t)0 - 1 is a
> - very large number and that the underflow is OK. If arena_max
> - is set the value of arena_test is irrelevant. If arena_test
> - is set but narenas is not yet larger or equal to arena_test
> - narenas_limit is 0. There is no possibility for narenas to
> - be too big for the test to always fail since there is not
> - enough address space to create that many arenas. */
> + very large number and that the underflow is OK. If arena_max
> + is set the value of arena_test is irrelevant. If arena_test
> + is set but narenas is not yet larger or equal to arena_test
> + narenas_limit is 0. There is no possibility for narenas to
> + be too big for the test to always fail since there is not
> + enough address space to create that many arenas. */
> if (__builtin_expect (n <= narenas_limit - 1, 0))
> - {
> - if (catomic_compare_and_exchange_bool_acq (&narenas, n + 1, n))
> - goto repeat;
> - a = _int_new_arena (size);
> - if (__builtin_expect (a == NULL, 0))
> - catomic_decrement (&narenas);
> - }
> + {
> + if (catomic_compare_and_exchange_bool_acq (&narenas, n + 1, n))
> + goto repeat;
> + a = _int_new_arena (size);
> + if (__builtin_expect (a == NULL, 0))
> + catomic_decrement (&narenas);
> + }
> else
> - a = reused_arena (avoid_arena);
> + a = reused_arena (avoid_arena);
> }
> return a;
> }
> @@ -863,16 +905,19 @@ static mstate
> arena_get_retry (mstate ar_ptr, size_t bytes)
> {
> LIBC_PROBE (memory_arena_retry, 2, bytes, ar_ptr);
> - if(ar_ptr != &main_arena) {
> - (void)mutex_unlock(&ar_ptr->mutex);
> - ar_ptr = &main_arena;
> - (void)mutex_lock(&ar_ptr->mutex);
> - } else {
> - /* Grab ar_ptr->next prior to releasing its lock. */
> - mstate prev = ar_ptr->next ? ar_ptr : 0;
> - (void)mutex_unlock(&ar_ptr->mutex);
> - ar_ptr = arena_get2(prev, bytes, ar_ptr);
> - }
> + if (ar_ptr != &main_arena)
> + {
> + (void) mutex_unlock (&ar_ptr->mutex);
> + ar_ptr = &main_arena;
> + (void) mutex_lock (&ar_ptr->mutex);
> + }
> + else
> + {
> + /* Grab ar_ptr->next prior to releasing its lock. */
> + mstate prev = ar_ptr->next ? ar_ptr : 0;
> + (void) mutex_unlock (&ar_ptr->mutex);
> + ar_ptr = arena_get2 (prev, bytes, ar_ptr);
> + }
>
> return ar_ptr;
> }
> @@ -881,15 +926,15 @@ static void __attribute__ ((section ("__libc_thread_freeres_fn")))
> arena_thread_freeres (void)
> {
> void *vptr = NULL;
> - mstate a = tsd_getspecific(arena_key, vptr);
> - tsd_setspecific(arena_key, NULL);
> + mstate a = tsd_getspecific (arena_key, vptr);
> + tsd_setspecific (arena_key, NULL);
>
> if (a != NULL)
> {
> - (void)mutex_lock(&list_lock);
> + (void) mutex_lock (&list_lock);
> a->next_free = free_list;
> free_list = a;
> - (void)mutex_unlock(&list_lock);
> + (void) mutex_unlock (&list_lock);
> }
> }
> text_set_element (__libc_thread_subfreeres, arena_thread_freeres);
> diff --git a/malloc/hooks.c b/malloc/hooks.c
> index 7010fe6..75a9b1b 100644
> --- a/malloc/hooks.c
> +++ b/malloc/hooks.c
> @@ -24,29 +24,29 @@
> /* Hooks for debugging versions. The initial hooks just call the
> initialization routine, then do the normal work. */
>
> -static void*
> -malloc_hook_ini(size_t sz, const void *caller)
> +static void *
> +malloc_hook_ini (size_t sz, const void *caller)
> {
> __malloc_hook = NULL;
> - ptmalloc_init();
> - return __libc_malloc(sz);
> + ptmalloc_init ();
> + return __libc_malloc (sz);
> }
>
> -static void*
> -realloc_hook_ini(void* ptr, size_t sz, const void *caller)
> +static void *
> +realloc_hook_ini (void *ptr, size_t sz, const void *caller)
> {
> __malloc_hook = NULL;
> __realloc_hook = NULL;
> - ptmalloc_init();
> - return __libc_realloc(ptr, sz);
> + ptmalloc_init ();
> + return __libc_realloc (ptr, sz);
> }
>
> -static void*
> -memalign_hook_ini(size_t alignment, size_t sz, const void *caller)
> +static void *
> +memalign_hook_ini (size_t alignment, size_t sz, const void *caller)
> {
> __memalign_hook = NULL;
> - ptmalloc_init();
> - return __libc_memalign(alignment, sz);
> + ptmalloc_init ();
> + return __libc_memalign (alignment, sz);
> }
>
> /* Whether we are using malloc checking. */
> @@ -71,10 +71,11 @@ static int disallow_malloc_check;
> void
> __malloc_check_init (void)
> {
> - if (disallow_malloc_check) {
> - disallow_malloc_check = 0;
> - return;
> - }
> + if (disallow_malloc_check)
> + {
> + disallow_malloc_check = 0;
> + return;
> + }
> using_malloc_checking = 1;
> __malloc_hook = malloc_check;
> __free_hook = free_check;
> @@ -87,7 +88,7 @@ __malloc_check_init (void)
> overruns. The goal here is to avoid obscure crashes due to invalid
> usage, unlike in the MALLOC_DEBUG code. */
>
> -#define MAGICBYTE(p) ( ( ((size_t)p >> 3) ^ ((size_t)p >> 11)) & 0xFF )
> +#define MAGICBYTE(p) ((((size_t) p >> 3) ^ ((size_t) p >> 11)) & 0xFF)
>
> /* Visualize the chunk as being partitioned into blocks of 256 bytes from the
> highest address of the chunk, downwards. The beginning of each block tells
> @@ -96,53 +97,58 @@ __malloc_check_init (void)
> must reach it with this iteration, otherwise we have witnessed a memory
> corruption. */
> static size_t
> -malloc_check_get_size(mchunkptr p)
> +malloc_check_get_size (mchunkptr p)
> {
> size_t size;
> unsigned char c;
> - unsigned char magic = MAGICBYTE(p);
> + unsigned char magic = MAGICBYTE (p);
>
> - assert(using_malloc_checking == 1);
> + assert (using_malloc_checking == 1);
>
> - for (size = chunksize(p) - 1 + (chunk_is_mmapped(p) ? 0 : SIZE_SZ);
> - (c = ((unsigned char*)p)[size]) != magic;
> - size -= c) {
> - if(c<=0 || size<(c+2*SIZE_SZ)) {
> - malloc_printerr(check_action, "malloc_check_get_size: memory corruption",
> - chunk2mem(p));
> - return 0;
> + for (size = chunksize (p) - 1 + (chunk_is_mmapped (p) ? 0 : SIZE_SZ);
> + (c = ((unsigned char *) p)[size]) != magic;
> + size -= c)
> + {
> + if (c <= 0 || size < (c + 2 * SIZE_SZ))
> + {
> + malloc_printerr (check_action, "malloc_check_get_size: memory corruption",
> + chunk2mem (p));
> + return 0;
> + }
> }
> - }
>
> /* chunk2mem size. */
> - return size - 2*SIZE_SZ;
> + return size - 2 * SIZE_SZ;
> }
>
> /* Instrument a chunk with overrun detector byte(s) and convert it
> into a user pointer with requested size sz. */
>
> -static void*
> +static void *
> internal_function
> -mem2mem_check(void *ptr, size_t sz)
> +mem2mem_check (void *ptr, size_t sz)
> {
> mchunkptr p;
> - unsigned char* m_ptr = ptr;
> + unsigned char *m_ptr = ptr;
> size_t i;
>
> if (!ptr)
> return ptr;
> - p = mem2chunk(ptr);
> - for(i = chunksize(p) - (chunk_is_mmapped(p) ? 2*SIZE_SZ+1 : SIZE_SZ+1);
> - i > sz;
> - i -= 0xFF) {
> - if(i-sz < 0x100) {
> - m_ptr[i] = (unsigned char)(i-sz);
> - break;
> +
> + p = mem2chunk (ptr);
> + for (i = chunksize (p) - (chunk_is_mmapped (p) ? 2 * SIZE_SZ + 1 : SIZE_SZ + 1);
> + i > sz;
> + i -= 0xFF)
> + {
> + if (i - sz < 0x100)
> + {
> + m_ptr[i] = (unsigned char) (i - sz);
> + break;
> + }
> + m_ptr[i] = 0xFF;
> }
> - m_ptr[i] = 0xFF;
> - }
> - m_ptr[sz] = MAGICBYTE(p);
> - return (void*)m_ptr;
> + m_ptr[sz] = MAGICBYTE (p);
> + return (void *) m_ptr;
> }
>
> /* Convert a pointer to be free()d or realloc()ed to a valid chunk
> @@ -150,53 +156,64 @@ mem2mem_check(void *ptr, size_t sz)
>
> static mchunkptr
> internal_function
> -mem2chunk_check(void* mem, unsigned char **magic_p)
> +mem2chunk_check (void *mem, unsigned char **magic_p)
> {
> mchunkptr p;
> INTERNAL_SIZE_T sz, c;
> unsigned char magic;
>
> - if(!aligned_OK(mem)) return NULL;
> - p = mem2chunk(mem);
> - if (!chunk_is_mmapped(p)) {
> - /* Must be a chunk in conventional heap memory. */
> - int contig = contiguous(&main_arena);
> - sz = chunksize(p);
> - if((contig &&
> - ((char*)p<mp_.sbrk_base ||
> - ((char*)p + sz)>=(mp_.sbrk_base+main_arena.system_mem) )) ||
> - sz<MINSIZE || sz&MALLOC_ALIGN_MASK || !inuse(p) ||
> - ( !prev_inuse(p) && (p->prev_size&MALLOC_ALIGN_MASK ||
> - (contig && (char*)prev_chunk(p)<mp_.sbrk_base) ||
> - next_chunk(prev_chunk(p))!=p) ))
> - return NULL;
> - magic = MAGICBYTE(p);
> - for(sz += SIZE_SZ-1; (c = ((unsigned char*)p)[sz]) != magic; sz -= c) {
> - if(c<=0 || sz<(c+2*SIZE_SZ)) return NULL;
> + if (!aligned_OK (mem))
> + return NULL;
> +
> + p = mem2chunk (mem);
> + if (!chunk_is_mmapped (p))
> + {
> + /* Must be a chunk in conventional heap memory. */
> + int contig = contiguous (&main_arena);
> + sz = chunksize (p);
> + if ((contig &&
> + ((char *) p < mp_.sbrk_base ||
> + ((char *) p + sz) >= (mp_.sbrk_base + main_arena.system_mem))) ||
> + sz < MINSIZE || sz & MALLOC_ALIGN_MASK || !inuse (p) ||
> + (!prev_inuse (p) && (p->prev_size & MALLOC_ALIGN_MASK ||
> + (contig && (char *) prev_chunk (p) < mp_.sbrk_base) ||
> + next_chunk (prev_chunk (p)) != p)))
> + return NULL;
> +
> + magic = MAGICBYTE (p);
> + for (sz += SIZE_SZ - 1; (c = ((unsigned char *) p)[sz]) != magic; sz -= c)
> + {
> + if (c <= 0 || sz < (c + 2 * SIZE_SZ))
> + return NULL;
> + }
> }
> - } else {
> - unsigned long offset, page_mask = GLRO(dl_pagesize)-1;
> -
> - /* mmap()ed chunks have MALLOC_ALIGNMENT or higher power-of-two
> - alignment relative to the beginning of a page. Check this
> - first. */
> - offset = (unsigned long)mem & page_mask;
> - if((offset!=MALLOC_ALIGNMENT && offset!=0 && offset!=0x10 &&
> - offset!=0x20 && offset!=0x40 && offset!=0x80 && offset!=0x100 &&
> - offset!=0x200 && offset!=0x400 && offset!=0x800 && offset!=0x1000 &&
> - offset<0x2000) ||
> - !chunk_is_mmapped(p) || (p->size & PREV_INUSE) ||
> - ( (((unsigned long)p - p->prev_size) & page_mask) != 0 ) ||
> - ( (sz = chunksize(p)), ((p->prev_size + sz) & page_mask) != 0 ) )
> - return NULL;
> - magic = MAGICBYTE(p);
> - for(sz -= 1; (c = ((unsigned char*)p)[sz]) != magic; sz -= c) {
> - if(c<=0 || sz<(c+2*SIZE_SZ)) return NULL;
> + else
> + {
> + unsigned long offset, page_mask = GLRO (dl_pagesize) - 1;
> +
> + /* mmap()ed chunks have MALLOC_ALIGNMENT or higher power-of-two
> + alignment relative to the beginning of a page. Check this
> + first. */
> + offset = (unsigned long) mem & page_mask;
> + if ((offset != MALLOC_ALIGNMENT && offset != 0 && offset != 0x10 &&
> + offset != 0x20 && offset != 0x40 && offset != 0x80 && offset != 0x100 &&
> + offset != 0x200 && offset != 0x400 && offset != 0x800 && offset != 0x1000 &&
> + offset < 0x2000) ||
> + !chunk_is_mmapped (p) || (p->size & PREV_INUSE) ||
> + ((((unsigned long) p - p->prev_size) & page_mask) != 0) ||
> + ((sz = chunksize (p)), ((p->prev_size + sz) & page_mask) != 0))
> + return NULL;
> +
> + magic = MAGICBYTE (p);
> + for (sz -= 1; (c = ((unsigned char *) p)[sz]) != magic; sz -= c)
> + {
> + if (c <= 0 || sz < (c + 2 * SIZE_SZ))
> + return NULL;
> + }
> }
> - }
> - ((unsigned char*)p)[sz] ^= 0xFF;
> + ((unsigned char *) p)[sz] ^= 0xFF;
> if (magic_p)
> - *magic_p = (unsigned char *)p + sz;
> + *magic_p = (unsigned char *) p + sz;
> return p;
> }
>
> @@ -205,32 +222,32 @@ mem2chunk_check(void* mem, unsigned char **magic_p)
>
> static int
> internal_function
> -top_check(void)
> +top_check (void)
> {
> - mchunkptr t = top(&main_arena);
> - char* brk, * new_brk;
> + mchunkptr t = top (&main_arena);
> + char *brk, *new_brk;
> INTERNAL_SIZE_T front_misalign, sbrk_size;
> - unsigned long pagesz = GLRO(dl_pagesize);
> -
> - if (t == initial_top(&main_arena) ||
> - (!chunk_is_mmapped(t) &&
> - chunksize(t)>=MINSIZE &&
> - prev_inuse(t) &&
> - (!contiguous(&main_arena) ||
> - (char*)t + chunksize(t) == mp_.sbrk_base + main_arena.system_mem)))
> + unsigned long pagesz = GLRO (dl_pagesize);
> +
> + if (t == initial_top (&main_arena) ||
> + (!chunk_is_mmapped (t) &&
> + chunksize (t) >= MINSIZE &&
> + prev_inuse (t) &&
> + (!contiguous (&main_arena) ||
> + (char *) t + chunksize (t) == mp_.sbrk_base + main_arena.system_mem)))
> return 0;
>
> malloc_printerr (check_action, "malloc: top chunk is corrupt", t);
>
> /* Try to set up a new top chunk. */
> - brk = MORECORE(0);
> - front_misalign = (unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK;
> + brk = MORECORE (0);
> + front_misalign = (unsigned long) chunk2mem (brk) & MALLOC_ALIGN_MASK;
> if (front_misalign > 0)
> front_misalign = MALLOC_ALIGNMENT - front_misalign;
> sbrk_size = front_misalign + mp_.top_pad + MINSIZE;
> - sbrk_size += pagesz - ((unsigned long)(brk + sbrk_size) & (pagesz - 1));
> - new_brk = (char*)(MORECORE (sbrk_size));
> - if (new_brk == (char*)(MORECORE_FAILURE))
> + sbrk_size += pagesz - ((unsigned long) (brk + sbrk_size) & (pagesz - 1));
> + new_brk = (char *) (MORECORE (sbrk_size));
> + if (new_brk == (char *) (MORECORE_FAILURE))
> {
> __set_errno (ENOMEM);
> return -1;
> @@ -238,128 +255,148 @@ top_check(void)
> /* Call the `morecore' hook if necessary. */
> void (*hook) (void) = atomic_forced_read (__after_morecore_hook);
> if (hook)
> - (*hook) ();
> + (*hook)();
> main_arena.system_mem = (new_brk - mp_.sbrk_base) + sbrk_size;
>
> - top(&main_arena) = (mchunkptr)(brk + front_misalign);
> - set_head(top(&main_arena), (sbrk_size - front_misalign) | PREV_INUSE);
> + top (&main_arena) = (mchunkptr) (brk + front_misalign);
> + set_head (top (&main_arena), (sbrk_size - front_misalign) | PREV_INUSE);
>
> return 0;
> }
>
> -static void*
> -malloc_check(size_t sz, const void *caller)
> +static void *
> +malloc_check (size_t sz, const void *caller)
> {
> void *victim;
>
> - if (sz+1 == 0) {
> - __set_errno (ENOMEM);
> - return NULL;
> - }
> + if (sz + 1 == 0)
> + {
> + __set_errno (ENOMEM);
> + return NULL;
> + }
>
> - (void)mutex_lock(&main_arena.mutex);
> - victim = (top_check() >= 0) ? _int_malloc(&main_arena, sz+1) : NULL;
> - (void)mutex_unlock(&main_arena.mutex);
> - return mem2mem_check(victim, sz);
> + (void) mutex_lock (&main_arena.mutex);
> + victim = (top_check () >= 0) ? _int_malloc (&main_arena, sz + 1) : NULL;
> + (void) mutex_unlock (&main_arena.mutex);
> + return mem2mem_check (victim, sz);
> }
>
> static void
> -free_check(void* mem, const void *caller)
> +free_check (void *mem, const void *caller)
> {
> mchunkptr p;
>
> - if(!mem) return;
> - (void)mutex_lock(&main_arena.mutex);
> - p = mem2chunk_check(mem, NULL);
> - if(!p) {
> - (void)mutex_unlock(&main_arena.mutex);
> -
> - malloc_printerr(check_action, "free(): invalid pointer", mem);
> + if (!mem)
> return;
> - }
> - if (chunk_is_mmapped(p)) {
> - (void)mutex_unlock(&main_arena.mutex);
> - munmap_chunk(p);
> - return;
> - }
> - _int_free(&main_arena, p, 1);
> - (void)mutex_unlock(&main_arena.mutex);
> +
> + (void) mutex_lock (&main_arena.mutex);
> + p = mem2chunk_check (mem, NULL);
> + if (!p)
> + {
> + (void) mutex_unlock (&main_arena.mutex);
> +
> + malloc_printerr (check_action, "free(): invalid pointer", mem);
> + return;
> + }
> + if (chunk_is_mmapped (p))
> + {
> + (void) mutex_unlock (&main_arena.mutex);
> + munmap_chunk (p);
> + return;
> + }
> + _int_free (&main_arena, p, 1);
> + (void) mutex_unlock (&main_arena.mutex);
> }
>
> -static void*
> -realloc_check(void* oldmem, size_t bytes, const void *caller)
> +static void *
> +realloc_check (void *oldmem, size_t bytes, const void *caller)
> {
> INTERNAL_SIZE_T nb;
> - void* newmem = 0;
> + void *newmem = 0;
> unsigned char *magic_p;
>
> - if (bytes+1 == 0) {
> - __set_errno (ENOMEM);
> - return NULL;
> - }
> - if (oldmem == 0) return malloc_check(bytes, NULL);
> - if (bytes == 0) {
> - free_check (oldmem, NULL);
> - return NULL;
> - }
> - (void)mutex_lock(&main_arena.mutex);
> - const mchunkptr oldp = mem2chunk_check(oldmem, &magic_p);
> - (void)mutex_unlock(&main_arena.mutex);
> - if(!oldp) {
> - malloc_printerr(check_action, "realloc(): invalid pointer", oldmem);
> - return malloc_check(bytes, NULL);
> - }
> - const INTERNAL_SIZE_T oldsize = chunksize(oldp);
> -
> - checked_request2size(bytes+1, nb);
> - (void)mutex_lock(&main_arena.mutex);
> -
> - if (chunk_is_mmapped(oldp)) {
> + if (bytes + 1 == 0)
> + {
> + __set_errno (ENOMEM);
> + return NULL;
> + }
> + if (oldmem == 0)
> + return malloc_check (bytes, NULL);
> +
> + if (bytes == 0)
> + {
> + free_check (oldmem, NULL);
> + return NULL;
> + }
> + (void) mutex_lock (&main_arena.mutex);
> + const mchunkptr oldp = mem2chunk_check (oldmem, &magic_p);
> + (void) mutex_unlock (&main_arena.mutex);
> + if (!oldp)
> + {
> + malloc_printerr (check_action, "realloc(): invalid pointer", oldmem);
> + return malloc_check (bytes, NULL);
> + }
> + const INTERNAL_SIZE_T oldsize = chunksize (oldp);
> +
> + checked_request2size (bytes + 1, nb);
> + (void) mutex_lock (&main_arena.mutex);
> +
> + if (chunk_is_mmapped (oldp))
> + {
> #if HAVE_MREMAP
> - mchunkptr newp = mremap_chunk(oldp, nb);
> - if(newp)
> - newmem = chunk2mem(newp);
> - else
> + mchunkptr newp = mremap_chunk (oldp, nb);
> + if (newp)
> + newmem = chunk2mem (newp);
> + else
> #endif
> - {
> - /* Note the extra SIZE_SZ overhead. */
> - if(oldsize - SIZE_SZ >= nb)
> - newmem = oldmem; /* do nothing */
> - else {
> - /* Must alloc, copy, free. */
> - if (top_check() >= 0)
> - newmem = _int_malloc(&main_arena, bytes+1);
> - if (newmem) {
> - memcpy(newmem, oldmem, oldsize - 2*SIZE_SZ);
> - munmap_chunk(oldp);
> - }
> + {
> + /* Note the extra SIZE_SZ overhead. */
> + if (oldsize - SIZE_SZ >= nb)
> + newmem = oldmem; /* do nothing */
> + else
> + {
> + /* Must alloc, copy, free. */
> + if (top_check () >= 0)
> + newmem = _int_malloc (&main_arena, bytes + 1);
> + if (newmem)
> + {
> + memcpy (newmem, oldmem, oldsize - 2 * SIZE_SZ);
> + munmap_chunk (oldp);
> + }
> + }
> }
> }
> - } else {
> - if (top_check() >= 0) {
> - INTERNAL_SIZE_T nb;
> - checked_request2size(bytes + 1, nb);
> - newmem = _int_realloc(&main_arena, oldp, oldsize, nb);
> + else
> + {
> + if (top_check () >= 0)
> + {
> + INTERNAL_SIZE_T nb;
> + checked_request2size (bytes + 1, nb);
> + newmem = _int_realloc (&main_arena, oldp, oldsize, nb);
> + }
> }
> - }
>
> /* mem2chunk_check changed the magic byte in the old chunk.
> If newmem is NULL, then the old chunk will still be used though,
> so we need to invert that change here. */
> - if (newmem == NULL) *magic_p ^= 0xFF;
> + if (newmem == NULL)
> + *magic_p ^= 0xFF;
>
> - (void)mutex_unlock(&main_arena.mutex);
> + (void) mutex_unlock (&main_arena.mutex);
>
> - return mem2mem_check(newmem, bytes);
> + return mem2mem_check (newmem, bytes);
> }
>
> -static void*
> -memalign_check(size_t alignment, size_t bytes, const void *caller)
> +static void *
> +memalign_check (size_t alignment, size_t bytes, const void *caller)
> {
> - void* mem;
> + void *mem;
> +
> + if (alignment <= MALLOC_ALIGNMENT)
> + return malloc_check (bytes, NULL);
>
> - if (alignment <= MALLOC_ALIGNMENT) return malloc_check(bytes, NULL);
> - if (alignment < MINSIZE) alignment = MINSIZE;
> + if (alignment < MINSIZE)
> + alignment = MINSIZE;
>
> /* If the alignment is greater than SIZE_MAX / 2 + 1 it cannot be a
> power of 2 and will cause overflow in the check below. */
> @@ -377,17 +414,19 @@ memalign_check(size_t alignment, size_t bytes, const void *caller)
> }
>
> /* Make sure alignment is power of 2. */
> - if (!powerof2(alignment)) {
> - size_t a = MALLOC_ALIGNMENT * 2;
> - while (a < alignment) a <<= 1;
> - alignment = a;
> - }
> -
> - (void)mutex_lock(&main_arena.mutex);
> - mem = (top_check() >= 0) ? _int_memalign(&main_arena, alignment, bytes+1) :
> - NULL;
> - (void)mutex_unlock(&main_arena.mutex);
> - return mem2mem_check(mem, bytes);
> + if (!powerof2 (alignment))
> + {
> + size_t a = MALLOC_ALIGNMENT * 2;
> + while (a < alignment)
> + a <<= 1;
> + alignment = a;
> + }
> +
> + (void) mutex_lock (&main_arena.mutex);
> + mem = (top_check () >= 0) ? _int_memalign (&main_arena, alignment, bytes + 1) :
> + NULL;
> + (void) mutex_unlock (&main_arena.mutex);
> + return mem2mem_check (mem, bytes);
> }
>
>
> @@ -408,59 +447,63 @@ memalign_check(size_t alignment, size_t bytes, const void *caller)
> then the hooks are reset to 0. */
>
> #define MALLOC_STATE_MAGIC 0x444c4541l
> -#define MALLOC_STATE_VERSION (0*0x100l + 4l) /* major*0x100 + minor */
> -
> -struct malloc_save_state {
> - long magic;
> - long version;
> - mbinptr av[NBINS * 2 + 2];
> - char* sbrk_base;
> - int sbrked_mem_bytes;
> +#define MALLOC_STATE_VERSION (0 * 0x100l + 4l) /* major*0x100 + minor */
> +
> +struct malloc_save_state
> +{
> + long magic;
> + long version;
> + mbinptr av[NBINS * 2 + 2];
> + char *sbrk_base;
> + int sbrked_mem_bytes;
> unsigned long trim_threshold;
> unsigned long top_pad;
> - unsigned int n_mmaps_max;
> + unsigned int n_mmaps_max;
> unsigned long mmap_threshold;
> - int check_action;
> + int check_action;
> unsigned long max_sbrked_mem;
> unsigned long max_total_mem;
> - unsigned int n_mmaps;
> - unsigned int max_n_mmaps;
> + unsigned int n_mmaps;
> + unsigned int max_n_mmaps;
> unsigned long mmapped_mem;
> unsigned long max_mmapped_mem;
> - int using_malloc_checking;
> + int using_malloc_checking;
> unsigned long max_fast;
> unsigned long arena_test;
> unsigned long arena_max;
> unsigned long narenas;
> };
>
> -void*
> -__malloc_get_state(void)
> +void *
> +__malloc_get_state (void)
> {
> - struct malloc_save_state* ms;
> + struct malloc_save_state *ms;
> int i;
> mbinptr b;
>
> - ms = (struct malloc_save_state*)__libc_malloc(sizeof(*ms));
> + ms = (struct malloc_save_state *) __libc_malloc (sizeof (*ms));
> if (!ms)
> return 0;
> - (void)mutex_lock(&main_arena.mutex);
> - malloc_consolidate(&main_arena);
> +
> + (void) mutex_lock (&main_arena.mutex);
> + malloc_consolidate (&main_arena);
> ms->magic = MALLOC_STATE_MAGIC;
> ms->version = MALLOC_STATE_VERSION;
> ms->av[0] = 0;
> ms->av[1] = 0; /* used to be binblocks, now no longer used */
> - ms->av[2] = top(&main_arena);
> + ms->av[2] = top (&main_arena);
> ms->av[3] = 0; /* used to be undefined */
> - for(i=1; i<NBINS; i++) {
> - b = bin_at(&main_arena, i);
> - if(first(b) == b)
> - ms->av[2*i+2] = ms->av[2*i+3] = 0; /* empty bin */
> - else {
> - ms->av[2*i+2] = first(b);
> - ms->av[2*i+3] = last(b);
> + for (i = 1; i < NBINS; i++)
> + {
> + b = bin_at (&main_arena, i);
> + if (first (b) == b)
> + ms->av[2 * i + 2] = ms->av[2 * i + 3] = 0; /* empty bin */
> + else
> + {
> + ms->av[2 * i + 2] = first (b);
> + ms->av[2 * i + 3] = last (b);
> + }
> }
> - }
> ms->sbrk_base = mp_.sbrk_base;
> ms->sbrked_mem_bytes = main_arena.system_mem;
> ms->trim_threshold = mp_.trim_threshold;
> @@ -475,78 +518,92 @@ __malloc_get_state(void)
> ms->mmapped_mem = mp_.mmapped_mem;
> ms->max_mmapped_mem = mp_.max_mmapped_mem;
> ms->using_malloc_checking = using_malloc_checking;
> - ms->max_fast = get_max_fast();
> + ms->max_fast = get_max_fast ();
> ms->arena_test = mp_.arena_test;
> ms->arena_max = mp_.arena_max;
> ms->narenas = narenas;
> - (void)mutex_unlock(&main_arena.mutex);
> - return (void*)ms;
> + (void) mutex_unlock (&main_arena.mutex);
> + return (void *) ms;
> }
>
> int
> -__malloc_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;
> mbinptr b;
>
> disallow_malloc_check = 1;
> - ptmalloc_init();
> - if(ms->magic != MALLOC_STATE_MAGIC) return -1;
> + ptmalloc_init ();
> + if (ms->magic != MALLOC_STATE_MAGIC)
> + return -1;
> +
> /* Must fail if the major version is too high. */
> - if((ms->version & ~0xffl) > (MALLOC_STATE_VERSION & ~0xffl)) return -2;
> - (void)mutex_lock(&main_arena.mutex);
> + if ((ms->version & ~0xffl) > (MALLOC_STATE_VERSION & ~0xffl))
> + return -2;
> +
> + (void) mutex_lock (&main_arena.mutex);
> /* There are no fastchunks. */
> - clear_fastchunks(&main_arena);
> + clear_fastchunks (&main_arena);
> if (ms->version >= 4)
> - set_max_fast(ms->max_fast);
> + set_max_fast (ms->max_fast);
> else
> - set_max_fast(64); /* 64 used to be the value we always used. */
> - for (i=0; i<NFASTBINS; ++i)
> + set_max_fast (64); /* 64 used to be the value we always used. */
> + for (i = 0; i < NFASTBINS; ++i)
> fastbin (&main_arena, i) = 0;
> - for (i=0; i<BINMAPSIZE; ++i)
> + for (i = 0; i < BINMAPSIZE; ++i)
> main_arena.binmap[i] = 0;
> - top(&main_arena) = ms->av[2];
> + top (&main_arena) = ms->av[2];
> main_arena.last_remainder = 0;
> - for(i=1; i<NBINS; i++) {
> - b = bin_at(&main_arena, i);
> - if(ms->av[2*i+2] == 0) {
> - assert(ms->av[2*i+3] == 0);
> - first(b) = last(b) = b;
> - } else {
> - if(ms->version >= 3 &&
> - (i<NSMALLBINS || (largebin_index(chunksize(ms->av[2*i+2]))==i &&
> - largebin_index(chunksize(ms->av[2*i+3]))==i))) {
> - first(b) = ms->av[2*i+2];
> - last(b) = ms->av[2*i+3];
> - /* Make sure the links to the bins within the heap are correct. */
> - first(b)->bk = b;
> - last(b)->fd = b;
> - /* Set bit in binblocks. */
> - mark_bin(&main_arena, i);
> - } else {
> - /* Oops, index computation from chunksize must have changed.
> - Link the whole list into unsorted_chunks. */
> - first(b) = last(b) = b;
> - b = unsorted_chunks(&main_arena);
> - ms->av[2*i+2]->bk = b;
> - ms->av[2*i+3]->fd = b->fd;
> - b->fd->bk = ms->av[2*i+3];
> - b->fd = ms->av[2*i+2];
> - }
> + for (i = 1; i < NBINS; i++)
> + {
> + b = bin_at (&main_arena, i);
> + if (ms->av[2 * i + 2] == 0)
> + {
> + assert (ms->av[2 * i + 3] == 0);
> + first (b) = last (b) = b;
> + }
> + else
> + {
> + if (ms->version >= 3 &&
> + (i < NSMALLBINS || (largebin_index (chunksize (ms->av[2 * i + 2])) == i &&
> + largebin_index (chunksize (ms->av[2 * i + 3])) == i)))
> + {
> + first (b) = ms->av[2 * i + 2];
> + last (b) = ms->av[2 * i + 3];
> + /* Make sure the links to the bins within the heap are correct. */
> + first (b)->bk = b;
> + last (b)->fd = b;
> + /* Set bit in binblocks. */
> + mark_bin (&main_arena, i);
> + }
> + else
> + {
> + /* Oops, index computation from chunksize must have changed.
> + Link the whole list into unsorted_chunks. */
> + first (b) = last (b) = b;
> + b = unsorted_chunks (&main_arena);
> + ms->av[2 * i + 2]->bk = b;
> + ms->av[2 * i + 3]->fd = b->fd;
> + b->fd->bk = ms->av[2 * i + 3];
> + b->fd = ms->av[2 * i + 2];
> + }
> + }
> }
> - }
> - if (ms->version < 3) {
> - /* Clear fd_nextsize and bk_nextsize fields. */
> - b = unsorted_chunks(&main_arena)->fd;
> - while (b != unsorted_chunks(&main_arena)) {
> - if (!in_smallbin_range(chunksize(b))) {
> - b->fd_nextsize = NULL;
> - b->bk_nextsize = NULL;
> - }
> - b = b->fd;
> + if (ms->version < 3)
> + {
> + /* Clear fd_nextsize and bk_nextsize fields. */
> + b = unsorted_chunks (&main_arena)->fd;
> + while (b != unsorted_chunks (&main_arena))
> + {
> + if (!in_smallbin_range (chunksize (b)))
> + {
> + b->fd_nextsize = NULL;
> + b->bk_nextsize = NULL;
> + }
> + b = b->fd;
> + }
> }
> - }
> mp_.sbrk_base = ms->sbrk_base;
> main_arena.system_mem = ms->sbrked_mem_bytes;
> mp_.trim_threshold = ms->trim_threshold;
> @@ -560,28 +617,31 @@ __malloc_set_state(void* msptr)
> mp_.mmapped_mem = ms->mmapped_mem;
> mp_.max_mmapped_mem = ms->max_mmapped_mem;
> /* add version-dependent code here */
> - if (ms->version >= 1) {
> - /* Check whether it is safe to enable malloc checking, or whether
> - it is necessary to disable it. */
> - if (ms->using_malloc_checking && !using_malloc_checking &&
> - !disallow_malloc_check)
> - __malloc_check_init ();
> - else if (!ms->using_malloc_checking && using_malloc_checking) {
> - __malloc_hook = NULL;
> - __free_hook = NULL;
> - __realloc_hook = NULL;
> - __memalign_hook = NULL;
> - using_malloc_checking = 0;
> + if (ms->version >= 1)
> + {
> + /* Check whether it is safe to enable malloc checking, or whether
> + it is necessary to disable it. */
> + if (ms->using_malloc_checking && !using_malloc_checking &&
> + !disallow_malloc_check)
> + __malloc_check_init ();
> + else if (!ms->using_malloc_checking && using_malloc_checking)
> + {
> + __malloc_hook = NULL;
> + __free_hook = NULL;
> + __realloc_hook = NULL;
> + __memalign_hook = NULL;
> + using_malloc_checking = 0;
> + }
> }
> - }
> - if (ms->version >= 4) {
> - mp_.arena_test = ms->arena_test;
> - mp_.arena_max = ms->arena_max;
> - narenas = ms->narenas;
> - }
> - check_malloc_state(&main_arena);
> -
> - (void)mutex_unlock(&main_arena.mutex);
> + if (ms->version >= 4)
> + {
> + mp_.arena_test = ms->arena_test;
> + mp_.arena_max = ms->arena_max;
> + narenas = ms->narenas;
> + }
> + check_malloc_state (&main_arena);
> +
> + (void) mutex_unlock (&main_arena.mutex);
> return 0;
> }
>
> diff --git a/malloc/malloc.c b/malloc/malloc.c
> index b1668b5..575adf7 100644
> --- a/malloc/malloc.c
> +++ b/malloc/malloc.c
> @@ -353,10 +353,10 @@ __malloc_assert (const char *assertion, const char *file, unsigned int line,
> malloc_set_state than will returning blocks not adequately aligned for
> long double objects under -mlong-double-128. */
>
> -# define MALLOC_ALIGNMENT (2 * SIZE_SZ < __alignof__ (long double) \
> - ? __alignof__ (long double) : 2 * SIZE_SZ)
> +# define MALLOC_ALIGNMENT (2 *SIZE_SZ < __alignof__ (long double) \
> + ? __alignof__ (long double) : 2 *SIZE_SZ)
> # else
> -# define MALLOC_ALIGNMENT (2 * SIZE_SZ)
> +# define MALLOC_ALIGNMENT (2 *SIZE_SZ)
> # endif
> #endif
>
> @@ -463,10 +463,10 @@ void *(*__morecore)(ptrdiff_t) = __default_morecore;
> some systems, if the application first decrements and then
> increments the break value, the contents of the reallocated space
> are unspecified.
> -*/
> + */
>
> #ifndef MORECORE_CLEARS
> -#define MORECORE_CLEARS 1
> +# define MORECORE_CLEARS 1
> #endif
>
>
> @@ -1232,11 +1232,11 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
> Check if a request is so large that it would wrap around zero when
> padded and aligned. To simplify some other code, the bound is made
> low enough so that adding MINSIZE will also not wrap around zero.
> -*/
> + */
>
> #define REQUEST_OUT_OF_RANGE(req) \
> - ((unsigned long)(req) >= \
> - (unsigned long)(INTERNAL_SIZE_T)(-2 * MINSIZE))
> + ((unsigned long) (req) >= \
> + (unsigned long) (INTERNAL_SIZE_T) (-2 * MINSIZE))
>
> /* pad request bytes into a usable size -- internal version */
>
> @@ -1248,15 +1248,15 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
> /* Same, except also perform argument check */
>
> #define checked_request2size(req, sz) \
> - if (REQUEST_OUT_OF_RANGE(req)) { \
> - __set_errno (ENOMEM); \
> - return 0; \
> - } \
> - (sz) = request2size(req);
> + if (REQUEST_OUT_OF_RANGE (req)) { \
> + __set_errno (ENOMEM); \
> + return 0; \
> + } \
> + (sz) = request2size (req);
>
> /*
> - --------------- Physical chunk operations ---------------
> -*/
> + --------------- Physical chunk operations ---------------
> + */
>
>
> /* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */
> @@ -1283,49 +1283,49 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
>
>
> /*
> - Bits to mask off when extracting size
> + Bits to mask off when extracting size
>
> - Note: IS_MMAPPED is intentionally not masked off from size field in
> - macros for which mmapped chunks should never be seen. This should
> - cause helpful core dumps to occur if it is tried by accident by
> - people extending or adapting this malloc.
> -*/
> -#define SIZE_BITS (PREV_INUSE|IS_MMAPPED|NON_MAIN_ARENA)
> + Note: IS_MMAPPED is intentionally not masked off from size field in
> + macros for which mmapped chunks should never be seen. This should
> + cause helpful core dumps to occur if it is tried by accident by
> + people extending or adapting this malloc.
> + */
> +#define SIZE_BITS (PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
>
> /* Get size, ignoring use bits */
> #define chunksize(p) ((p)->size & ~(SIZE_BITS))
>
>
> /* Ptr to next physical malloc_chunk. */
> -#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~SIZE_BITS) ))
> +#define next_chunk(p) ((mchunkptr) (((char *) (p)) + ((p)->size & ~SIZE_BITS)))
>
> /* Ptr to previous physical malloc_chunk */
> -#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_size) ))
> +#define prev_chunk(p) ((mchunkptr) (((char *) (p)) - ((p)->prev_size)))
>
> /* Treat space at ptr + offset as a chunk */
> -#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
> +#define chunk_at_offset(p, s) ((mchunkptr) (((char *) (p)) + (s)))
>
> /* extract p's inuse bit */
> -#define inuse(p)\
> -((((mchunkptr)(((char*)(p))+((p)->size & ~SIZE_BITS)))->size) & PREV_INUSE)
> +#define inuse(p) \
> + ((((mchunkptr) (((char *) (p)) + ((p)->size & ~SIZE_BITS)))->size) & PREV_INUSE)
>
> /* set/clear chunk as being inuse without otherwise disturbing */
> -#define set_inuse(p)\
> -((mchunkptr)(((char*)(p)) + ((p)->size & ~SIZE_BITS)))->size |= PREV_INUSE
> +#define set_inuse(p) \
> + ((mchunkptr) (((char *) (p)) + ((p)->size & ~SIZE_BITS)))->size |= PREV_INUSE
>
> -#define clear_inuse(p)\
> -((mchunkptr)(((char*)(p)) + ((p)->size & ~SIZE_BITS)))->size &= ~(PREV_INUSE)
> +#define clear_inuse(p) \
> + ((mchunkptr) (((char *) (p)) + ((p)->size & ~SIZE_BITS)))->size &= ~(PREV_INUSE)
>
>
> /* check/set/clear inuse bits in known places */
> -#define inuse_bit_at_offset(p, s)\
> - (((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE)
> +#define inuse_bit_at_offset(p, s) \
> + (((mchunkptr) (((char *) (p)) + (s)))->size & PREV_INUSE)
>
> -#define set_inuse_bit_at_offset(p, s)\
> - (((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE)
> +#define set_inuse_bit_at_offset(p, s) \
> + (((mchunkptr) (((char *) (p)) + (s)))->size |= PREV_INUSE)
>
> -#define clear_inuse_bit_at_offset(p, s)\
> - (((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE))
> +#define clear_inuse_bit_at_offset(p, s) \
> + (((mchunkptr) (((char *) (p)) + (s)))->size &= ~(PREV_INUSE))
>
>
> /* Set size at head, without disturbing its use bit */
> @@ -1335,26 +1335,26 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
> #define set_head(p, s) ((p)->size = (s))
>
> /* Set size at footer (only when chunk is not in use) */
> -#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s))
> +#define set_foot(p, s) (((mchunkptr) ((char *) (p) + (s)))->prev_size = (s))
>
>
> /*
> - -------------------- Internal data structures --------------------
> + -------------------- Internal data structures --------------------
>
> All internal state is held in an instance of malloc_state defined
> below. There are no other static variables, except in two optional
> cases:
> - * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
> - * If mmap doesn't support MAP_ANONYMOUS, a dummy file descriptor
> + * If USE_MALLOC_LOCK is defined, the mALLOC_MUTEx declared above.
> + * If mmap doesn't support MAP_ANONYMOUS, a dummy file descriptor
> for mmap.
>
> Beware of lots of tricks that minimize the total bookkeeping space
> requirements. The result is a little over 1K bytes (for 4byte
> pointers and size_t.)
> -*/
> + */
>
> /*
> - Bins
> + Bins
>
> An array of bin headers for free chunks. Each bin is doubly
> linked. The bins are approximately proportionally (log) spaced.
> @@ -1387,17 +1387,17 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
> But to conserve space and improve locality, we allocate
> only the fd/bk pointers of bins, and then use repositioning tricks
> to treat these as the fields of a malloc_chunk*.
> -*/
> + */
>
> -typedef struct malloc_chunk* mbinptr;
> +typedef struct malloc_chunk *mbinptr;
>
> /* addressing -- note that bin_at(0) does not exist */
> #define bin_at(m, i) \
> - (mbinptr) (((char *) &((m)->bins[((i) - 1) * 2])) \
> - - offsetof (struct malloc_chunk, fd))
> + (mbinptr) (((char *) &((m)->bins[((i) - 1) * 2])) \
> + - offsetof (struct malloc_chunk, fd))
>
> /* analog of ++bin */
> -#define next_bin(b) ((mbinptr)((char*)(b) + (sizeof(mchunkptr)<<1)))
> +#define next_bin(b) ((mbinptr) ((char *) (b) + (sizeof (mchunkptr) << 1)))
>
> /* Reminders about list directionality within bins */
> #define first(b) ((b)->fd)
> @@ -1405,36 +1405,36 @@ typedef struct malloc_chunk* mbinptr;
>
> /* Take a chunk off a bin list */
> #define unlink(P, BK, FD) { \
> - FD = P->fd; \
> - BK = P->bk; \
> - if (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \
> - malloc_printerr (check_action, "corrupted double-linked list", P); \
> - else { \
> - FD->bk = BK; \
> - BK->fd = FD; \
> - if (!in_smallbin_range (P->size) \
> - && __builtin_expect (P->fd_nextsize != NULL, 0)) { \
> - assert (P->fd_nextsize->bk_nextsize == P); \
> - assert (P->bk_nextsize->fd_nextsize == P); \
> - if (FD->fd_nextsize == NULL) { \
> - if (P->fd_nextsize == P) \
> - FD->fd_nextsize = FD->bk_nextsize = FD; \
> - else { \
> - FD->fd_nextsize = P->fd_nextsize; \
> - FD->bk_nextsize = P->bk_nextsize; \
> - P->fd_nextsize->bk_nextsize = FD; \
> - P->bk_nextsize->fd_nextsize = FD; \
> - } \
> - } else { \
> - P->fd_nextsize->bk_nextsize = P->bk_nextsize; \
> - P->bk_nextsize->fd_nextsize = P->fd_nextsize; \
> - } \
> - } \
> - } \
> + FD = P->fd; \
> + BK = P->bk; \
> + if (__builtin_expect (FD->bk != P || BK->fd != P, 0)) \
> + malloc_printerr (check_action, "corrupted double-linked list", P); \
> + else { \
> + FD->bk = BK; \
> + BK->fd = FD; \
> + if (!in_smallbin_range (P->size) \
> + && __builtin_expect (P->fd_nextsize != NULL, 0)) { \
> + assert (P->fd_nextsize->bk_nextsize == P); \
> + assert (P->bk_nextsize->fd_nextsize == P); \
> + if (FD->fd_nextsize == NULL) { \
> + if (P->fd_nextsize == P) \
> + FD->fd_nextsize = FD->bk_nextsize = FD; \
> + else { \
> + FD->fd_nextsize = P->fd_nextsize; \
> + FD->bk_nextsize = P->bk_nextsize; \
> + P->fd_nextsize->bk_nextsize = FD; \
> + P->bk_nextsize->fd_nextsize = FD; \
> + } \
> + } else { \
> + P->fd_nextsize->bk_nextsize = P->bk_nextsize; \
> + P->bk_nextsize->fd_nextsize = P->fd_nextsize; \
> + } \
> + } \
> + } \
> }
>
> /*
> - Indexing
> + Indexing
>
> Bins for sizes < 512 bytes contain chunks of all the same size, spaced
> 8 bytes apart. Larger bins are approximately logarithmically spaced:
> @@ -1455,7 +1455,7 @@ typedef struct malloc_chunk* mbinptr;
>
> Bin 0 does not exist. Bin 1 is the unordered list; if that would be
> a valid chunk size the small bins are bumped up one.
> -*/
> + */
>
> #define NBINS 128
> #define NSMALLBINS 64
> @@ -1464,38 +1464,38 @@ typedef struct malloc_chunk* mbinptr;
> #define MIN_LARGE_SIZE ((NSMALLBINS - SMALLBIN_CORRECTION) * SMALLBIN_WIDTH)
>
> #define in_smallbin_range(sz) \
> - ((unsigned long)(sz) < (unsigned long)MIN_LARGE_SIZE)
> + ((unsigned long) (sz) < (unsigned long) MIN_LARGE_SIZE)
>
> #define smallbin_index(sz) \
> - ((SMALLBIN_WIDTH == 16 ? (((unsigned)(sz)) >> 4) : (((unsigned)(sz)) >> 3)) \
> + ((SMALLBIN_WIDTH == 16 ? (((unsigned) (sz)) >> 4) : (((unsigned) (sz)) >> 3))\
> + SMALLBIN_CORRECTION)
>
> #define largebin_index_32(sz) \
> -(((((unsigned long)(sz)) >> 6) <= 38)? 56 + (((unsigned long)(sz)) >> 6): \
> - ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
> - ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
> - ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
> - ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
> - 126)
> + (((((unsigned long) (sz)) >> 6) <= 38) ? 56 + (((unsigned long) (sz)) >> 6) :\
> + ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\
> + ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
> + ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
> + ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
> + 126)
>
> #define largebin_index_32_big(sz) \
> -(((((unsigned long)(sz)) >> 6) <= 45)? 49 + (((unsigned long)(sz)) >> 6): \
> - ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
> - ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
> - ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
> - ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
> - 126)
> + (((((unsigned long) (sz)) >> 6) <= 45) ? 49 + (((unsigned long) (sz)) >> 6) :\
> + ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\
> + ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
> + ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
> + ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
> + 126)
>
> // XXX It remains to be seen whether it is good to keep the widths of
> // XXX the buckets the same or whether it should be scaled by a factor
> // XXX of two as well.
> #define largebin_index_64(sz) \
> -(((((unsigned long)(sz)) >> 6) <= 48)? 48 + (((unsigned long)(sz)) >> 6): \
> - ((((unsigned long)(sz)) >> 9) <= 20)? 91 + (((unsigned long)(sz)) >> 9): \
> - ((((unsigned long)(sz)) >> 12) <= 10)? 110 + (((unsigned long)(sz)) >> 12): \
> - ((((unsigned long)(sz)) >> 15) <= 4)? 119 + (((unsigned long)(sz)) >> 15): \
> - ((((unsigned long)(sz)) >> 18) <= 2)? 124 + (((unsigned long)(sz)) >> 18): \
> - 126)
> + (((((unsigned long) (sz)) >> 6) <= 48) ? 48 + (((unsigned long) (sz)) >> 6) :\
> + ((((unsigned long) (sz)) >> 9) <= 20) ? 91 + (((unsigned long) (sz)) >> 9) :\
> + ((((unsigned long) (sz)) >> 12) <= 10) ? 110 + (((unsigned long) (sz)) >> 12) :\
> + ((((unsigned long) (sz)) >> 15) <= 4) ? 119 + (((unsigned long) (sz)) >> 15) :\
> + ((((unsigned long) (sz)) >> 18) <= 2) ? 124 + (((unsigned long) (sz)) >> 18) :\
> + 126)
>
> #define largebin_index(sz) \
> (SIZE_SZ == 8 ? largebin_index_64 (sz) \
> @@ -1503,11 +1503,11 @@ typedef struct malloc_chunk* mbinptr;
> : largebin_index_32 (sz))
>
> #define bin_index(sz) \
> - ((in_smallbin_range(sz)) ? smallbin_index(sz) : largebin_index(sz))
> + ((in_smallbin_range (sz)) ? smallbin_index (sz) : largebin_index (sz))
>
>
> /*
> - Unsorted chunks
> + Unsorted chunks
>
> All remainders from chunk splits, as well as all returned chunks,
> are first placed in the "unsorted" bin. They are then placed
> @@ -1518,13 +1518,13 @@ typedef struct malloc_chunk* mbinptr;
>
> The NON_MAIN_ARENA flag is never set for unsorted chunks, so it
> does not have to be taken into account in size comparisons.
> -*/
> + */
>
> /* The otherwise unindexable 1-bin is used to hold unsorted chunks. */
> -#define unsorted_chunks(M) (bin_at(M, 1))
> +#define unsorted_chunks(M) (bin_at (M, 1))
>
> /*
> - Top
> + Top
>
> The top-most available chunk (i.e., the one bordering the end of
> available memory) is treated specially. It is never included in
> @@ -1539,13 +1539,13 @@ typedef struct malloc_chunk* mbinptr;
> interval between initialization and the first call to
> sysmalloc. (This is somewhat delicate, since it relies on
> the 2 preceding words to be zero during this interval as well.)
> -*/
> + */
>
> /* Conveniently, the unsorted bin can be used as dummy top on first call */
> -#define initial_top(M) (unsorted_chunks(M))
> +#define initial_top(M) (unsorted_chunks (M))
>
> /*
> - Binmap
> + Binmap
>
> To help compensate for the large number of bins, a one-level index
> structure is used for bin-by-bin searching. `binmap' is a
> @@ -1553,7 +1553,7 @@ typedef struct malloc_chunk* mbinptr;
> be skipped over during during traversals. The bits are NOT always
> cleared as soon as bins are empty, but instead only
> when they are noticed to be empty during traversal in malloc.
> -*/
> + */
>
> /* Conservatively use 32 bits per map word, even if on 64bit system */
> #define BINMAPSHIFT 5
> @@ -1561,14 +1561,14 @@ typedef struct malloc_chunk* mbinptr;
> #define BINMAPSIZE (NBINS / BITSPERMAP)
>
> #define idx2block(i) ((i) >> BINMAPSHIFT)
> -#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT)-1))))
> +#define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT) - 1))))
>
> -#define mark_bin(m,i) ((m)->binmap[idx2block(i)] |= idx2bit(i))
> -#define unmark_bin(m,i) ((m)->binmap[idx2block(i)] &= ~(idx2bit(i)))
> -#define get_binmap(m,i) ((m)->binmap[idx2block(i)] & idx2bit(i))
> +#define mark_bin(m, i) ((m)->binmap[idx2block (i)] |= idx2bit (i))
> +#define unmark_bin(m, i) ((m)->binmap[idx2block (i)] &= ~(idx2bit (i)))
> +#define get_binmap(m, i) ((m)->binmap[idx2block (i)] & idx2bit (i))
>
> /*
> - Fastbins
> + Fastbins
>
> An array of lists holding recently freed small chunks. Fastbins
> are not doubly linked. It is faster to single-link them, and
> @@ -1582,69 +1582,69 @@ typedef struct malloc_chunk* mbinptr;
> be consolidated with other free chunks. malloc_consolidate
> releases all chunks in fastbins and consolidates them with
> other free chunks.
> -*/
> + */
>
> -typedef struct malloc_chunk* mfastbinptr;
> +typedef struct malloc_chunk *mfastbinptr;
> #define fastbin(ar_ptr, idx) ((ar_ptr)->fastbinsY[idx])
>
> /* offset 2 to use otherwise unindexable first 2 bins */
> #define fastbin_index(sz) \
> - ((((unsigned int)(sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2)
> + ((((unsigned int) (sz)) >> (SIZE_SZ == 8 ? 4 : 3)) - 2)
>
>
> /* The maximum fastbin request size we support */
> #define MAX_FAST_SIZE (80 * SIZE_SZ / 4)
>
> -#define NFASTBINS (fastbin_index(request2size(MAX_FAST_SIZE))+1)
> +#define NFASTBINS (fastbin_index (request2size (MAX_FAST_SIZE)) + 1)
>
> /*
> - FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
> - that triggers automatic consolidation of possibly-surrounding
> - fastbin chunks. This is a heuristic, so the exact value should not
> - matter too much. It is defined at half the default trim threshold as a
> - compromise heuristic to only attempt consolidation if it is likely
> - to lead to trimming. However, it is not dynamically tunable, since
> - consolidation reduces fragmentation surrounding large chunks even
> - if trimming is not used.
> -*/
> + FASTBIN_CONSOLIDATION_THRESHOLD is the size of a chunk in free()
> + that triggers automatic consolidation of possibly-surrounding
> + fastbin chunks. This is a heuristic, so the exact value should not
> + matter too much. It is defined at half the default trim threshold as a
> + compromise heuristic to only attempt consolidation if it is likely
> + to lead to trimming. However, it is not dynamically tunable, since
> + consolidation reduces fragmentation surrounding large chunks even
> + if trimming is not used.
> + */
>
> #define FASTBIN_CONSOLIDATION_THRESHOLD (65536UL)
>
> /*
> - Since the lowest 2 bits in max_fast don't matter in size comparisons,
> - they are used as flags.
> -*/
> + Since the lowest 2 bits in max_fast don't matter in size comparisons,
> + they are used as flags.
> + */
>
> /*
> - FASTCHUNKS_BIT held in max_fast indicates that there are probably
> - some fastbin chunks. It is set true on entering a chunk into any
> - fastbin, and cleared only in malloc_consolidate.
> + FASTCHUNKS_BIT held in max_fast indicates that there are probably
> + some fastbin chunks. It is set true on entering a chunk into any
> + fastbin, and cleared only in malloc_consolidate.
>
> - The truth value is inverted so that have_fastchunks will be true
> - upon startup (since statics are zero-filled), simplifying
> - initialization checks.
> -*/
> + The truth value is inverted so that have_fastchunks will be true
> + upon startup (since statics are zero-filled), simplifying
> + initialization checks.
> + */
>
> #define FASTCHUNKS_BIT (1U)
>
> -#define have_fastchunks(M) (((M)->flags & FASTCHUNKS_BIT) == 0)
> +#define have_fastchunks(M) (((M)->flags & FASTCHUNKS_BIT) == 0)
> #define clear_fastchunks(M) catomic_or (&(M)->flags, FASTCHUNKS_BIT)
> #define set_fastchunks(M) catomic_and (&(M)->flags, ~FASTCHUNKS_BIT)
>
> /*
> - NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
> - regions. Otherwise, contiguity is exploited in merging together,
> - when possible, results from consecutive MORECORE calls.
> + NONCONTIGUOUS_BIT indicates that MORECORE does not return contiguous
> + regions. Otherwise, contiguity is exploited in merging together,
> + when possible, results from consecutive MORECORE calls.
>
> - The initial value comes from MORECORE_CONTIGUOUS, but is
> - changed dynamically if mmap is ever used as an sbrk substitute.
> -*/
> + The initial value comes from MORECORE_CONTIGUOUS, but is
> + changed dynamically if mmap is ever used as an sbrk substitute.
> + */
>
> #define NONCONTIGUOUS_BIT (2U)
>
> -#define contiguous(M) (((M)->flags & NONCONTIGUOUS_BIT) == 0)
> -#define noncontiguous(M) (((M)->flags & NONCONTIGUOUS_BIT) != 0)
> -#define set_noncontiguous(M) ((M)->flags |= NONCONTIGUOUS_BIT)
> +#define contiguous(M) (((M)->flags & NONCONTIGUOUS_BIT) == 0)
> +#define noncontiguous(M) (((M)->flags & NONCONTIGUOUS_BIT) != 0)
> +#define set_noncontiguous(M) ((M)->flags |= NONCONTIGUOUS_BIT)
> #define set_contiguous(M) ((M)->flags &= ~NONCONTIGUOUS_BIT)
>
> /*
> @@ -1652,19 +1652,20 @@ typedef struct malloc_chunk* mfastbinptr;
> Use impossibly small value if 0.
> Precondition: there are no existing fastbin chunks.
> Setting the value clears fastchunk bit but preserves noncontiguous bit.
> -*/
> + */
>
> #define set_max_fast(s) \
> - global_max_fast = (((s) == 0) \
> - ? SMALLBIN_WIDTH: ((s + SIZE_SZ) & ~MALLOC_ALIGN_MASK))
> + global_max_fast = (((s) == 0) \
> + ? SMALLBIN_WIDTH : ((s + SIZE_SZ) & ~MALLOC_ALIGN_MASK))
> #define get_max_fast() global_max_fast
>
>
> /*
> ----------- Internal state representation and initialization -----------
> -*/
> + */
>
> -struct malloc_state {
> +struct malloc_state
> +{
> /* Serialize access. */
> mutex_t mutex;
>
> @@ -1677,19 +1678,19 @@ struct malloc_state {
> #endif
>
> /* Fastbins */
> - mfastbinptr fastbinsY[NFASTBINS];
> + mfastbinptr fastbinsY[NFASTBINS];
>
> /* Base of the topmost chunk -- not otherwise kept in a bin */
> - mchunkptr top;
> + mchunkptr top;
>
> /* The remainder from the most recent split of a small request */
> - mchunkptr last_remainder;
> + mchunkptr last_remainder;
>
> /* Normal bins packed as described above */
> - mchunkptr bins[NBINS * 2 - 2];
> + mchunkptr bins[NBINS * 2 - 2];
>
> /* Bitmap of bins */
> - unsigned int binmap[BINMAPSIZE];
> + unsigned int binmap[BINMAPSIZE];
>
> /* Linked list */
> struct malloc_state *next;
> @@ -1702,32 +1703,33 @@ struct malloc_state {
> INTERNAL_SIZE_T max_system_mem;
> };
>
> -struct malloc_par {
> +struct malloc_par
> +{
> /* Tunable parameters */
> - unsigned long trim_threshold;
> - INTERNAL_SIZE_T top_pad;
> - INTERNAL_SIZE_T mmap_threshold;
> - INTERNAL_SIZE_T arena_test;
> - INTERNAL_SIZE_T arena_max;
> + unsigned long trim_threshold;
> + INTERNAL_SIZE_T top_pad;
> + INTERNAL_SIZE_T mmap_threshold;
> + INTERNAL_SIZE_T arena_test;
> + INTERNAL_SIZE_T arena_max;
>
> /* Memory map support */
> - int n_mmaps;
> - int n_mmaps_max;
> - int max_n_mmaps;
> + int n_mmaps;
> + int n_mmaps_max;
> + int max_n_mmaps;
> /* the mmap_threshold is dynamic, until the user sets
> it manually, at which point we need to disable any
> dynamic behavior. */
> - int no_dyn_threshold;
> + int no_dyn_threshold;
>
> /* Statistics */
> - INTERNAL_SIZE_T mmapped_mem;
> + INTERNAL_SIZE_T mmapped_mem;
> /*INTERNAL_SIZE_T sbrked_mem;*/
> /*INTERNAL_SIZE_T max_sbrked_mem;*/
> - INTERNAL_SIZE_T max_mmapped_mem;
> - INTERNAL_SIZE_T max_total_mem; /* only kept for NO_THREADS */
> + INTERNAL_SIZE_T max_mmapped_mem;
> + INTERNAL_SIZE_T max_total_mem; /* only kept for NO_THREADS */
>
> /* First address handed out by MORECORE/sbrk. */
> - char* sbrk_base;
> + char *sbrk_base;
> };
>
> /* There are several instances of this struct ("arenas") in this
> @@ -1737,22 +1739,22 @@ struct malloc_par {
> is initialized to all zeroes (as is true of C statics). */
>
> static struct malloc_state main_arena =
> - {
> - .mutex = MUTEX_INITIALIZER,
> - .next = &main_arena
> - };
> +{
> + .mutex = MUTEX_INITIALIZER,
> + .next = &main_arena
> +};
>
> /* There is only one instance of the malloc parameters. */
>
> static struct malloc_par mp_ =
> - {
> - .top_pad = DEFAULT_TOP_PAD,
> - .n_mmaps_max = DEFAULT_MMAP_MAX,
> - .mmap_threshold = DEFAULT_MMAP_THRESHOLD,
> - .trim_threshold = DEFAULT_TRIM_THRESHOLD,
> -# define NARENAS_FROM_NCORES(n) ((n) * (sizeof(long) == 4 ? 2 : 8))
> - .arena_test = NARENAS_FROM_NCORES (1)
> - };
> +{
> + .top_pad = DEFAULT_TOP_PAD,
> + .n_mmaps_max = DEFAULT_MMAP_MAX,
> + .mmap_threshold = DEFAULT_MMAP_THRESHOLD,
> + .trim_threshold = DEFAULT_TRIM_THRESHOLD,
> +#define NARENAS_FROM_NCORES(n) ((n) * (sizeof (long) == 4 ? 2 : 8))
> + .arena_test = NARENAS_FROM_NCORES (1)
> +};
>
>
> /* Non public mallopt parameters. */
> @@ -1764,44 +1766,46 @@ static struct malloc_par mp_ =
> static INTERNAL_SIZE_T global_max_fast;
>
> /*
> - Initialize a malloc_state struct.
> + Initialize a malloc_state struct.
>
> - This is called only from within malloc_consolidate, which needs
> - be called in the same contexts anyway. It is never called directly
> - outside of malloc_consolidate because some optimizing compilers try
> - to inline it at all call points, which turns out not to be an
> - optimization at all. (Inlining it in malloc_consolidate is fine though.)
> -*/
> + This is called only from within malloc_consolidate, which needs
> + be called in the same contexts anyway. It is never called directly
> + outside of malloc_consolidate because some optimizing compilers try
> + to inline it at all call points, which turns out not to be an
> + optimization at all. (Inlining it in malloc_consolidate is fine though.)
> + */
>
> -static void malloc_init_state(mstate av)
> +static void
> +malloc_init_state (mstate av)
> {
> - int i;
> + int i;
> mbinptr bin;
>
> /* Establish circular links for normal bins */
> - for (i = 1; i < NBINS; ++i) {
> - bin = bin_at(av,i);
> - bin->fd = bin->bk = bin;
> - }
> + for (i = 1; i < NBINS; ++i)
> + {
> + bin = bin_at (av, i);
> + bin->fd = bin->bk = bin;
> + }
>
> #if MORECORE_CONTIGUOUS
> if (av != &main_arena)
> #endif
> - set_noncontiguous(av);
> + set_noncontiguous (av);
> if (av == &main_arena)
> - set_max_fast(DEFAULT_MXFAST);
> + set_max_fast (DEFAULT_MXFAST);
> av->flags |= FASTCHUNKS_BIT;
>
> - av->top = initial_top(av);
> + av->top = initial_top (av);
> }
>
> /*
> Other internal utilities operating on mstates
> -*/
> + */
>
> -static void* sysmalloc(INTERNAL_SIZE_T, mstate);
> -static int systrim(size_t, mstate);
> -static void malloc_consolidate(mstate);
> +static void *sysmalloc (INTERNAL_SIZE_T, mstate);
> +static int systrim (size_t, mstate);
> +static void malloc_consolidate (mstate);
>
>
> /* -------------- Early definitions for debugging hooks ---------------- */
> @@ -1815,31 +1819,31 @@ static void malloc_consolidate(mstate);
> #endif
>
> /* Forward declarations. */
> -static void* malloc_hook_ini (size_t sz,
> - const void *caller) __THROW;
> -static void* realloc_hook_ini (void* ptr, size_t sz,
> - const void *caller) __THROW;
> -static void* memalign_hook_ini (size_t alignment, size_t sz,
> - const void *caller) __THROW;
> +static void *malloc_hook_ini (size_t sz,
> + const void *caller) __THROW;
> +static void *realloc_hook_ini (void *ptr, size_t sz,
> + const void *caller) __THROW;
> +static void *memalign_hook_ini (size_t alignment, size_t sz,
> + const void *caller) __THROW;
>
> void weak_variable (*__malloc_initialize_hook) (void) = NULL;
> void weak_variable (*__free_hook) (void *__ptr,
> - const void *) = NULL;
> + const void *) = NULL;
> void *weak_variable (*__malloc_hook)
> - (size_t __size, const void *) = malloc_hook_ini;
> + (size_t __size, const void *) = malloc_hook_ini;
> void *weak_variable (*__realloc_hook)
> - (void *__ptr, size_t __size, const void *)
> - = realloc_hook_ini;
> + (void *__ptr, size_t __size, const void *)
> + = realloc_hook_ini;
> void *weak_variable (*__memalign_hook)
> - (size_t __alignment, size_t __size, const void *)
> - = memalign_hook_ini;
> + (size_t __alignment, size_t __size, const void *)
> + = memalign_hook_ini;
> void weak_variable (*__after_morecore_hook) (void) = NULL;
>
>
> /* ---------------- Error behavior ------------------------------------ */
>
> #ifndef DEFAULT_CHECK_ACTION
> -#define DEFAULT_CHECK_ACTION 3
> +# define DEFAULT_CHECK_ACTION 3
> #endif
>
> static int check_action = DEFAULT_CHECK_ACTION;
> @@ -1871,207 +1875,220 @@ free_perturb (char *p, size_t n)
> #include "arena.c"
>
> /*
> - Debugging support
> + Debugging support
>
> - These routines make a number of assertions about the states
> - of data structures that should be true at all times. If any
> - are not true, it's very likely that a user program has somehow
> - trashed memory. (It's also possible that there is a coding error
> - in malloc. In which case, please report it!)
> -*/
> + These routines make a number of assertions about the states
> + of data structures that should be true at all times. If any
> + are not true, it's very likely that a user program has somehow
> + trashed memory. (It's also possible that there is a coding error
> + in malloc. In which case, please report it!)
> + */
>
> -#if ! MALLOC_DEBUG
> +#if !MALLOC_DEBUG
>
> -#define check_chunk(A,P)
> -#define check_free_chunk(A,P)
> -#define check_inuse_chunk(A,P)
> -#define check_remalloced_chunk(A,P,N)
> -#define check_malloced_chunk(A,P,N)
> -#define check_malloc_state(A)
> +# define check_chunk(A, P)
> +# define check_free_chunk(A, P)
> +# define check_inuse_chunk(A, P)
> +# define check_remalloced_chunk(A, P, N)
> +# define check_malloced_chunk(A, P, N)
> +# define check_malloc_state(A)
>
> #else
>
> -#define check_chunk(A,P) do_check_chunk(A,P)
> -#define check_free_chunk(A,P) do_check_free_chunk(A,P)
> -#define check_inuse_chunk(A,P) do_check_inuse_chunk(A,P)
> -#define check_remalloced_chunk(A,P,N) do_check_remalloced_chunk(A,P,N)
> -#define check_malloced_chunk(A,P,N) do_check_malloced_chunk(A,P,N)
> -#define check_malloc_state(A) do_check_malloc_state(A)
> +# define check_chunk(A, P) do_check_chunk (A, P)
> +# define check_free_chunk(A, P) do_check_free_chunk (A, P)
> +# define check_inuse_chunk(A, P) do_check_inuse_chunk (A, P)
> +# define check_remalloced_chunk(A, P, N) do_check_remalloced_chunk (A, P, N)
> +# define check_malloced_chunk(A, P, N) do_check_malloced_chunk (A, P, N)
> +# define check_malloc_state(A) do_check_malloc_state (A)
>
> /*
> - Properties of all chunks
> -*/
> + Properties of all chunks
> + */
>
> -static void do_check_chunk(mstate av, mchunkptr p)
> +static void
> +do_check_chunk (mstate av, mchunkptr p)
> {
> - unsigned long sz = chunksize(p);
> + unsigned long sz = chunksize (p);
> /* min and max possible addresses assuming contiguous allocation */
> - char* max_address = (char*)(av->top) + chunksize(av->top);
> - char* min_address = max_address - av->system_mem;
> -
> - if (!chunk_is_mmapped(p)) {
> + char *max_address = (char *) (av->top) + chunksize (av->top);
> + char *min_address = max_address - av->system_mem;
>
> - /* Has legal address ... */
> - if (p != av->top) {
> - if (contiguous(av)) {
> - assert(((char*)p) >= min_address);
> - assert(((char*)p + sz) <= ((char*)(av->top)));
> - }
> - }
> - else {
> - /* top size is always at least MINSIZE */
> - assert((unsigned long)(sz) >= MINSIZE);
> - /* top predecessor always marked inuse */
> - assert(prev_inuse(p));
> + if (!chunk_is_mmapped (p))
> + {
> + /* Has legal address ... */
> + if (p != av->top)
> + {
> + if (contiguous (av))
> + {
> + assert (((char *) p) >= min_address);
> + assert (((char *) p + sz) <= ((char *) (av->top)));
> + }
> + }
> + else
> + {
> + /* top size is always at least MINSIZE */
> + assert ((unsigned long) (sz) >= MINSIZE);
> + /* top predecessor always marked inuse */
> + assert (prev_inuse (p));
> + }
> }
> -
> - }
> - else {
> - /* address is outside main heap */
> - if (contiguous(av) && av->top != initial_top(av)) {
> - assert(((char*)p) < min_address || ((char*)p) >= max_address);
> + else
> + {
> + /* address is outside main heap */
> + if (contiguous (av) && av->top != initial_top (av))
> + {
> + assert (((char *) p) < min_address || ((char *) p) >= max_address);
> + }
> + /* chunk is page-aligned */
> + assert (((p->prev_size + sz) & (GLRO (dl_pagesize) - 1)) == 0);
> + /* mem is aligned */
> + assert (aligned_OK (chunk2mem (p)));
> }
> - /* chunk is page-aligned */
> - assert(((p->prev_size + sz) & (GLRO(dl_pagesize)-1)) == 0);
> - /* mem is aligned */
> - assert(aligned_OK(chunk2mem(p)));
> - }
> }
>
> /*
> - Properties of free chunks
> -*/
> + Properties of free chunks
> + */
>
> -static void do_check_free_chunk(mstate av, mchunkptr p)
> +static void
> +do_check_free_chunk (mstate av, mchunkptr p)
> {
> - INTERNAL_SIZE_T sz = p->size & ~(PREV_INUSE|NON_MAIN_ARENA);
> - mchunkptr next = chunk_at_offset(p, sz);
> + INTERNAL_SIZE_T sz = p->size & ~(PREV_INUSE | NON_MAIN_ARENA);
> + mchunkptr next = chunk_at_offset (p, sz);
>
> - do_check_chunk(av, p);
> + do_check_chunk (av, p);
>
> /* Chunk must claim to be free ... */
> - assert(!inuse(p));
> - assert (!chunk_is_mmapped(p));
> + assert (!inuse (p));
> + assert (!chunk_is_mmapped (p));
>
> /* Unless a special marker, must have OK fields */
> - if ((unsigned long)(sz) >= MINSIZE)
> - {
> - assert((sz & MALLOC_ALIGN_MASK) == 0);
> - assert(aligned_OK(chunk2mem(p)));
> - /* ... matching footer field */
> - assert(next->prev_size == sz);
> - /* ... and is fully consolidated */
> - assert(prev_inuse(p));
> - assert (next == av->top || inuse(next));
> -
> - /* ... and has minimally sane links */
> - assert(p->fd->bk == p);
> - assert(p->bk->fd == p);
> - }
> + if ((unsigned long) (sz) >= MINSIZE)
> + {
> + assert ((sz & MALLOC_ALIGN_MASK) == 0);
> + assert (aligned_OK (chunk2mem (p)));
> + /* ... matching footer field */
> + assert (next->prev_size == sz);
> + /* ... and is fully consolidated */
> + assert (prev_inuse (p));
> + assert (next == av->top || inuse (next));
> +
> + /* ... and has minimally sane links */
> + assert (p->fd->bk == p);
> + assert (p->bk->fd == p);
> + }
> else /* markers are always of size SIZE_SZ */
> - assert(sz == SIZE_SZ);
> + assert (sz == SIZE_SZ);
> }
>
> /*
> - Properties of inuse chunks
> -*/
> + Properties of inuse chunks
> + */
>
> -static void do_check_inuse_chunk(mstate av, mchunkptr p)
> +static void
> +do_check_inuse_chunk (mstate av, mchunkptr p)
> {
> mchunkptr next;
>
> - do_check_chunk(av, p);
> + do_check_chunk (av, p);
>
> - if (chunk_is_mmapped(p))
> + if (chunk_is_mmapped (p))
> return; /* mmapped chunks have no next/prev */
>
> /* Check whether it claims to be in use ... */
> - assert(inuse(p));
> + assert (inuse (p));
>
> - next = next_chunk(p);
> + next = next_chunk (p);
>
> /* ... and is surrounded by OK chunks.
> - Since more things can be checked with free chunks than inuse ones,
> - if an inuse chunk borders them and debug is on, it's worth doing them.
> - */
> - if (!prev_inuse(p)) {
> - /* Note that we cannot even look at prev unless it is not inuse */
> - mchunkptr prv = prev_chunk(p);
> - assert(next_chunk(prv) == p);
> - do_check_free_chunk(av, prv);
> - }
> + Since more things can be checked with free chunks than inuse ones,
> + if an inuse chunk borders them and debug is on, it's worth doing them.
> + */
> + if (!prev_inuse (p))
> + {
> + /* Note that we cannot even look at prev unless it is not inuse */
> + mchunkptr prv = prev_chunk (p);
> + assert (next_chunk (prv) == p);
> + do_check_free_chunk (av, prv);
> + }
>
> - if (next == av->top) {
> - assert(prev_inuse(next));
> - assert(chunksize(next) >= MINSIZE);
> - }
> - else if (!inuse(next))
> - do_check_free_chunk(av, next);
> + if (next == av->top)
> + {
> + assert (prev_inuse (next));
> + assert (chunksize (next) >= MINSIZE);
> + }
> + else if (!inuse (next))
> + do_check_free_chunk (av, next);
> }
>
> /*
> - Properties of chunks recycled from fastbins
> -*/
> + Properties of chunks recycled from fastbins
> + */
>
> -static void do_check_remalloced_chunk(mstate av, mchunkptr p, INTERNAL_SIZE_T s)
> +static void
> +do_check_remalloced_chunk (mstate av, mchunkptr p, INTERNAL_SIZE_T s)
> {
> - INTERNAL_SIZE_T sz = p->size & ~(PREV_INUSE|NON_MAIN_ARENA);
> + INTERNAL_SIZE_T sz = p->size & ~(PREV_INUSE | NON_MAIN_ARENA);
>
> - if (!chunk_is_mmapped(p)) {
> - assert(av == arena_for_chunk(p));
> - if (chunk_non_main_arena(p))
> - assert(av != &main_arena);
> - else
> - assert(av == &main_arena);
> - }
> + if (!chunk_is_mmapped (p))
> + {
> + assert (av == arena_for_chunk (p));
> + if (chunk_non_main_arena (p))
> + assert (av != &main_arena);
> + else
> + assert (av == &main_arena);
> + }
>
> - do_check_inuse_chunk(av, p);
> + do_check_inuse_chunk (av, p);
>
> /* Legal size ... */
> - assert((sz & MALLOC_ALIGN_MASK) == 0);
> - assert((unsigned long)(sz) >= MINSIZE);
> + assert ((sz & MALLOC_ALIGN_MASK) == 0);
> + assert ((unsigned long) (sz) >= MINSIZE);
> /* ... and alignment */
> - assert(aligned_OK(chunk2mem(p)));
> + assert (aligned_OK (chunk2mem (p)));
> /* chunk is less than MINSIZE more than request */
> - assert((long)(sz) - (long)(s) >= 0);
> - assert((long)(sz) - (long)(s + MINSIZE) < 0);
> + assert ((long) (sz) - (long) (s) >= 0);
> + assert ((long) (sz) - (long) (s + MINSIZE) < 0);
> }
>
> /*
> - Properties of nonrecycled chunks at the point they are malloced
> -*/
> + Properties of nonrecycled chunks at the point they are malloced
> + */
>
> -static void do_check_malloced_chunk(mstate av, mchunkptr p, INTERNAL_SIZE_T s)
> +static void
> +do_check_malloced_chunk (mstate av, mchunkptr p, INTERNAL_SIZE_T s)
> {
> /* same as recycled case ... */
> - do_check_remalloced_chunk(av, p, s);
> + do_check_remalloced_chunk (av, p, s);
>
> /*
> - ... plus, must obey implementation invariant that prev_inuse is
> - always true of any allocated chunk; i.e., that each allocated
> - chunk borders either a previously allocated and still in-use
> - chunk, or the base of its memory arena. This is ensured
> - by making all allocations from the `lowest' part of any found
> - chunk. This does not necessarily hold however for chunks
> - recycled via fastbins.
> - */
> -
> - assert(prev_inuse(p));
> + ... plus, must obey implementation invariant that prev_inuse is
> + always true of any allocated chunk; i.e., that each allocated
> + chunk borders either a previously allocated and still in-use
> + chunk, or the base of its memory arena. This is ensured
> + by making all allocations from the `lowest' part of any found
> + chunk. This does not necessarily hold however for chunks
> + recycled via fastbins.
> + */
> +
> + assert (prev_inuse (p));
> }
>
>
> /*
> - Properties of malloc_state.
> + Properties of malloc_state.
>
> - This may be useful for debugging malloc, as well as detecting user
> - programmer errors that somehow write into malloc_state.
> + This may be useful for debugging malloc, as well as detecting user
> + programmer errors that somehow write into malloc_state.
>
> - If you are extending or experimenting with this malloc, you can
> - probably figure out how to hack this routine to print out or
> - display chunk addresses, sizes, bins, and other instrumentation.
> -*/
> + If you are extending or experimenting with this malloc, you can
> + probably figure out how to hack this routine to print out or
> + display chunk addresses, sizes, bins, and other instrumentation.
> + */
>
> -static void do_check_malloc_state(mstate av)
> +static void
> +do_check_malloc_state (mstate av)
> {
> int i;
> mchunkptr p;
> @@ -2083,126 +2100,132 @@ static void do_check_malloc_state(mstate av)
> int max_fast_bin;
>
> /* internal size_t must be no wider than pointer type */
> - assert(sizeof(INTERNAL_SIZE_T) <= sizeof(char*));
> + assert (sizeof (INTERNAL_SIZE_T) <= sizeof (char *));
>
> /* alignment is a power of 2 */
> - assert((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-1)) == 0);
> + assert ((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT - 1)) == 0);
>
> /* cannot run remaining checks until fully initialized */
> - if (av->top == 0 || av->top == initial_top(av))
> + if (av->top == 0 || av->top == initial_top (av))
> return;
>
> /* pagesize is a power of 2 */
> - assert((GLRO(dl_pagesize) & (GLRO(dl_pagesize)-1)) == 0);
> + assert ((GLRO (dl_pagesize) & (GLRO (dl_pagesize) - 1)) == 0);
>
> /* A contiguous main_arena is consistent with sbrk_base. */
> - if (av == &main_arena && contiguous(av))
> - assert((char*)mp_.sbrk_base + av->system_mem ==
> - (char*)av->top + chunksize(av->top));
> + if (av == &main_arena && contiguous (av))
> + assert ((char *) mp_.sbrk_base + av->system_mem ==
> + (char *) av->top + chunksize (av->top));
>
> /* properties of fastbins */
>
> /* max_fast is in allowed range */
> - assert((get_max_fast () & ~1) <= request2size(MAX_FAST_SIZE));
> -
> - max_fast_bin = fastbin_index(get_max_fast ());
> -
> - for (i = 0; i < NFASTBINS; ++i) {
> - p = fastbin (av, i);
> -
> - /* The following test can only be performed for the main arena.
> - While mallopt calls malloc_consolidate to get rid of all fast
> - bins (especially those larger than the new maximum) this does
> - only happen for the main arena. Trying to do this for any
> - other arena would mean those arenas have to be locked and
> - malloc_consolidate be called for them. This is excessive. And
> - even if this is acceptable to somebody it still cannot solve
> - the problem completely since if the arena is locked a
> - concurrent malloc call might create a new arena which then
> - could use the newly invalid fast bins. */
> -
> - /* all bins past max_fast are empty */
> - if (av == &main_arena && i > max_fast_bin)
> - assert(p == 0);
> -
> - while (p != 0) {
> - /* each chunk claims to be inuse */
> - do_check_inuse_chunk(av, p);
> - total += chunksize(p);
> - /* chunk belongs in this bin */
> - assert(fastbin_index(chunksize(p)) == i);
> - p = p->fd;
> + assert ((get_max_fast () & ~1) <= request2size (MAX_FAST_SIZE));
> +
> + max_fast_bin = fastbin_index (get_max_fast ());
> +
> + for (i = 0; i < NFASTBINS; ++i)
> + {
> + p = fastbin (av, i);
> +
> + /* The following test can only be performed for the main arena.
> + While mallopt calls malloc_consolidate to get rid of all fast
> + bins (especially those larger than the new maximum) this does
> + only happen for the main arena. Trying to do this for any
> + other arena would mean those arenas have to be locked and
> + malloc_consolidate be called for them. This is excessive. And
> + even if this is acceptable to somebody it still cannot solve
> + the problem completely since if the arena is locked a
> + concurrent malloc call might create a new arena which then
> + could use the newly invalid fast bins. */
> +
> + /* all bins past max_fast are empty */
> + if (av == &main_arena && i > max_fast_bin)
> + assert (p == 0);
> +
> + while (p != 0)
> + {
> + /* each chunk claims to be inuse */
> + do_check_inuse_chunk (av, p);
> + total += chunksize (p);
> + /* chunk belongs in this bin */
> + assert (fastbin_index (chunksize (p)) == i);
> + p = p->fd;
> + }
> }
> - }
>
> if (total != 0)
> - assert(have_fastchunks(av));
> - else if (!have_fastchunks(av))
> - assert(total == 0);
> + assert (have_fastchunks (av));
> + else if (!have_fastchunks (av))
> + assert (total == 0);
>
> /* check normal bins */
> - for (i = 1; i < NBINS; ++i) {
> - b = bin_at(av,i);
> -
> - /* binmap is accurate (except for bin 1 == unsorted_chunks) */
> - if (i >= 2) {
> - unsigned int binbit = get_binmap(av,i);
> - int empty = last(b) == b;
> - if (!binbit)
> - assert(empty);
> - else if (!empty)
> - assert(binbit);
> - }
> -
> - for (p = last(b); p != b; p = p->bk) {
> - /* each chunk claims to be free */
> - do_check_free_chunk(av, p);
> - size = chunksize(p);
> - total += size;
> - if (i >= 2) {
> - /* chunk belongs in bin */
> - idx = bin_index(size);
> - assert(idx == i);
> - /* lists are sorted */
> - assert(p->bk == b ||
> - (unsigned long)chunksize(p->bk) >= (unsigned long)chunksize(p));
> -
> - if (!in_smallbin_range(size))
> - {
> - if (p->fd_nextsize != NULL)
> - {
> - if (p->fd_nextsize == p)
> - assert (p->bk_nextsize == p);
> - else
> - {
> - if (p->fd_nextsize == first (b))
> - assert (chunksize (p) < chunksize (p->fd_nextsize));
> - else
> - assert (chunksize (p) > chunksize (p->fd_nextsize));
> -
> - if (p == first (b))
> - assert (chunksize (p) > chunksize (p->bk_nextsize));
> - else
> - assert (chunksize (p) < chunksize (p->bk_nextsize));
> - }
> - }
> - else
> - assert (p->bk_nextsize == NULL);
> - }
> - } else if (!in_smallbin_range(size))
> - assert (p->fd_nextsize == NULL && p->bk_nextsize == NULL);
> - /* chunk is followed by a legal chain of inuse chunks */
> - for (q = next_chunk(p);
> - (q != av->top && inuse(q) &&
> - (unsigned long)(chunksize(q)) >= MINSIZE);
> - q = next_chunk(q))
> - do_check_inuse_chunk(av, q);
> + for (i = 1; i < NBINS; ++i)
> + {
> + b = bin_at (av, i);
> +
> + /* binmap is accurate (except for bin 1 == unsorted_chunks) */
> + if (i >= 2)
> + {
> + unsigned int binbit = get_binmap (av, i);
> + int empty = last (b) == b;
> + if (!binbit)
> + assert (empty);
> + else if (!empty)
> + assert (binbit);
> + }
> +
> + for (p = last (b); p != b; p = p->bk)
> + {
> + /* each chunk claims to be free */
> + do_check_free_chunk (av, p);
> + size = chunksize (p);
> + total += size;
> + if (i >= 2)
> + {
> + /* chunk belongs in bin */
> + idx = bin_index (size);
> + assert (idx == i);
> + /* lists are sorted */
> + assert (p->bk == b ||
> + (unsigned long) chunksize (p->bk) >= (unsigned long) chunksize (p));
> +
> + if (!in_smallbin_range (size))
> + {
> + if (p->fd_nextsize != NULL)
> + {
> + if (p->fd_nextsize == p)
> + assert (p->bk_nextsize == p);
> + else
> + {
> + if (p->fd_nextsize == first (b))
> + assert (chunksize (p) < chunksize (p->fd_nextsize));
> + else
> + assert (chunksize (p) > chunksize (p->fd_nextsize));
> +
> + if (p == first (b))
> + assert (chunksize (p) > chunksize (p->bk_nextsize));
> + else
> + assert (chunksize (p) < chunksize (p->bk_nextsize));
> + }
> + }
> + else
> + assert (p->bk_nextsize == NULL);
> + }
> + }
> + else if (!in_smallbin_range (size))
> + assert (p->fd_nextsize == NULL && p->bk_nextsize == NULL);
> + /* chunk is followed by a legal chain of inuse chunks */
> + for (q = next_chunk (p);
> + (q != av->top && inuse (q) &&
> + (unsigned long) (chunksize (q)) >= MINSIZE);
> + q = next_chunk (q))
> + do_check_inuse_chunk (av, q);
> + }
> }
> - }
>
> /* top chunk is OK */
> - check_chunk(av, av->top);
> -
> + check_chunk (av, av->top);
> }
> #endif
>
> @@ -2214,461 +2237,482 @@ static void do_check_malloc_state(mstate av)
> /* ----------- Routines dealing with system allocation -------------- */
>
> /*
> - sysmalloc handles malloc cases requiring more memory from the system.
> - On entry, it is assumed that av->top does not have enough
> - space to service request for nb bytes, thus requiring that av->top
> - be extended or replaced.
> -*/
> + sysmalloc handles malloc cases requiring more memory from the system.
> + On entry, it is assumed that av->top does not have enough
> + space to service request for nb bytes, thus requiring that av->top
> + 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 */
> - char* old_end; /* its end address */
> + char *old_end; /* its end address */
>
> - long size; /* arg to first MORECORE or mmap call */
> - char* brk; /* return value from MORECORE */
> + long size; /* arg to first MORECORE or mmap call */
> + char *brk; /* return value from MORECORE */
>
> - long correction; /* arg to 2nd MORECORE call */
> - char* snd_brk; /* 2nd return val */
> + long correction; /* arg to 2nd MORECORE call */
> + char *snd_brk; /* 2nd return val */
>
> INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of new space */
> INTERNAL_SIZE_T end_misalign; /* partial page left at end of new space */
> - char* aligned_brk; /* aligned offset into brk */
> + char *aligned_brk; /* aligned offset into brk */
>
> - mchunkptr p; /* the allocated/returned chunk */
> - mchunkptr remainder; /* remainder from allocation */
> - unsigned long remainder_size; /* its size */
> + mchunkptr p; /* the allocated/returned chunk */
> + mchunkptr remainder; /* remainder from allocation */
> + unsigned long remainder_size; /* its size */
>
>
> - size_t pagemask = GLRO(dl_pagesize) - 1;
> - bool tried_mmap = false;
> + size_t pagemask = GLRO (dl_pagesize) - 1;
> + bool tried_mmap = false;
>
>
> /*
> - If have mmap, and the request size meets the mmap threshold, and
> - the system supports mmap, and there are few enough currently
> - allocated mmapped regions, try to directly map this request
> - rather than expanding top.
> - */
> -
> - if ((unsigned long)(nb) >= (unsigned long)(mp_.mmap_threshold) &&
> - (mp_.n_mmaps < mp_.n_mmaps_max)) {
> -
> - char* mm; /* return value from mmap call*/
> -
> - try_mmap:
> - /*
> - Round up size to nearest page. For mmapped chunks, the overhead
> - is one SIZE_SZ unit larger than for normal chunks, because there
> - is no following chunk whose prev_size field could be used.
> -
> - See the front_misalign handling below, for glibc there is no
> - need for further alignments unless we have have high alignment.
> - */
> - if (MALLOC_ALIGNMENT == 2 * SIZE_SZ)
> - size = (nb + SIZE_SZ + pagemask) & ~pagemask;
> - else
> - size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
> - tried_mmap = true;
> -
> - /* Don't try if size wraps around 0 */
> - if ((unsigned long)(size) > (unsigned long)(nb)) {
> -
> - mm = (char*)(MMAP(0, size, PROT_READ|PROT_WRITE, 0));
> -
> - if (mm != MAP_FAILED) {
> -
> - /*
> - The offset to the start of the mmapped region is stored
> - in the prev_size field of the chunk. This allows us to adjust
> - returned start address to meet alignment requirements here
> - and in memalign(), and still be able to compute proper
> - address argument for later munmap in free() and realloc().
> - */
> -
> - if (MALLOC_ALIGNMENT == 2 * SIZE_SZ)
> - {
> - /* For glibc, chunk2mem increases the address by 2*SIZE_SZ and
> - MALLOC_ALIGN_MASK is 2*SIZE_SZ-1. Each mmap'ed area is page
> - aligned and therefore definitely MALLOC_ALIGN_MASK-aligned. */
> - assert (((INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK) == 0);
> - front_misalign = 0;
> - }
> - else
> - front_misalign = (INTERNAL_SIZE_T)chunk2mem(mm) & MALLOC_ALIGN_MASK;
> - if (front_misalign > 0) {
> - correction = MALLOC_ALIGNMENT - front_misalign;
> - p = (mchunkptr)(mm + correction);
> - p->prev_size = correction;
> - set_head(p, (size - correction) |IS_MMAPPED);
> - }
> - else
> - {
> - p = (mchunkptr)mm;
> - set_head(p, size|IS_MMAPPED);
> - }
> -
> - /* update statistics */
> -
> - int new = atomic_exchange_and_add (&mp_.n_mmaps, 1) + 1;
> - atomic_max (&mp_.max_n_mmaps, new);
> -
> - unsigned long sum;
> - sum = atomic_exchange_and_add(&mp_.mmapped_mem, size) + size;
> - atomic_max (&mp_.max_mmapped_mem, sum);
> -
> - check_chunk(av, p);
> -
> - return chunk2mem(p);
> - }
> + If have mmap, and the request size meets the mmap threshold, and
> + the system supports mmap, and there are few enough currently
> + allocated mmapped regions, try to directly map this request
> + rather than expanding top.
> + */
> +
> + if ((unsigned long) (nb) >= (unsigned long) (mp_.mmap_threshold) &&
> + (mp_.n_mmaps < mp_.n_mmaps_max))
> + {
> + char *mm; /* return value from mmap call*/
> +
> + try_mmap:
> + /*
> + Round up size to nearest page. For mmapped chunks, the overhead
> + is one SIZE_SZ unit larger than for normal chunks, because there
> + is no following chunk whose prev_size field could be used.
> +
> + See the front_misalign handling below, for glibc there is no
> + need for further alignments unless we have have high alignment.
> + */
> + if (MALLOC_ALIGNMENT == 2 * SIZE_SZ)
> + size = (nb + SIZE_SZ + pagemask) & ~pagemask;
> + else
> + size = (nb + SIZE_SZ + MALLOC_ALIGN_MASK + pagemask) & ~pagemask;
> + tried_mmap = true;
> +
> + /* Don't try if size wraps around 0 */
> + if ((unsigned long) (size) > (unsigned long) (nb))
> + {
> + mm = (char *) (MMAP (0, size, PROT_READ | PROT_WRITE, 0));
> +
> + if (mm != MAP_FAILED)
> + {
> + /*
> + The offset to the start of the mmapped region is stored
> + in the prev_size field of the chunk. This allows us to adjust
> + returned start address to meet alignment requirements here
> + and in memalign(), and still be able to compute proper
> + address argument for later munmap in free() and realloc().
> + */
> +
> + if (MALLOC_ALIGNMENT == 2 * SIZE_SZ)
> + {
> + /* For glibc, chunk2mem increases the address by 2*SIZE_SZ and
> + MALLOC_ALIGN_MASK is 2*SIZE_SZ-1. Each mmap'ed area is page
> + aligned and therefore definitely MALLOC_ALIGN_MASK-aligned. */
> + assert (((INTERNAL_SIZE_T) chunk2mem (mm) & MALLOC_ALIGN_MASK) == 0);
> + front_misalign = 0;
> + }
> + else
> + front_misalign = (INTERNAL_SIZE_T) chunk2mem (mm) & MALLOC_ALIGN_MASK;
> + if (front_misalign > 0)
> + {
> + correction = MALLOC_ALIGNMENT - front_misalign;
> + p = (mchunkptr) (mm + correction);
> + p->prev_size = correction;
> + set_head (p, (size - correction) | IS_MMAPPED);
> + }
> + else
> + {
> + p = (mchunkptr) mm;
> + set_head (p, size | IS_MMAPPED);
> + }
> +
> + /* update statistics */
> +
> + int new = atomic_exchange_and_add (&mp_.n_mmaps, 1) + 1;
> + atomic_max (&mp_.max_n_mmaps, new);
> +
> + unsigned long sum;
> + sum = atomic_exchange_and_add (&mp_.mmapped_mem, size) + size;
> + atomic_max (&mp_.max_mmapped_mem, sum);
> +
> + check_chunk (av, p);
> +
> + return chunk2mem (p);
> + }
> + }
> }
> - }
>
> /* Record incoming configuration of top */
>
> - old_top = av->top;
> - old_size = chunksize(old_top);
> - old_end = (char*)(chunk_at_offset(old_top, old_size));
> + old_top = av->top;
> + old_size = chunksize (old_top);
> + old_end = (char *) (chunk_at_offset (old_top, old_size));
>
> - brk = snd_brk = (char*)(MORECORE_FAILURE);
> + brk = snd_brk = (char *) (MORECORE_FAILURE);
>
> /*
> If not the first time through, we require old_size to be
> at least MINSIZE and to have prev_inuse set.
> - */
> + */
>
> - assert((old_top == initial_top(av) && old_size == 0) ||
> - ((unsigned long) (old_size) >= MINSIZE &&
> - prev_inuse(old_top) &&
> - ((unsigned long)old_end & pagemask) == 0));
> + assert ((old_top == initial_top (av) && old_size == 0) ||
> + ((unsigned long) (old_size) >= MINSIZE &&
> + prev_inuse (old_top) &&
> + ((unsigned long) old_end & pagemask) == 0));
>
> /* Precondition: not enough current space to satisfy nb request */
> - assert((unsigned long)(old_size) < (unsigned long)(nb + MINSIZE));
> -
> -
> - if (av != &main_arena) {
> -
> - heap_info *old_heap, *heap;
> - size_t old_heap_size;
> -
> - /* First try to extend the current heap. */
> - old_heap = heap_for_ptr(old_top);
> - old_heap_size = old_heap->size;
> - if ((long) (MINSIZE + nb - old_size) > 0
> - && grow_heap(old_heap, MINSIZE + nb - old_size) == 0) {
> - av->system_mem += old_heap->size - old_heap_size;
> - arena_mem += old_heap->size - old_heap_size;
> - set_head(old_top, (((char *)old_heap + old_heap->size) - (char *)old_top)
> - | PREV_INUSE);
> - }
> - else if ((heap = new_heap(nb + (MINSIZE + sizeof(*heap)), mp_.top_pad))) {
> - /* Use a newly allocated heap. */
> - heap->ar_ptr = av;
> - heap->prev = old_heap;
> - av->system_mem += heap->size;
> - arena_mem += heap->size;
> - /* Set up the new top. */
> - top(av) = chunk_at_offset(heap, sizeof(*heap));
> - set_head(top(av), (heap->size - sizeof(*heap)) | PREV_INUSE);
> -
> - /* Setup fencepost and free the old top chunk with a multiple of
> - MALLOC_ALIGNMENT in size. */
> - /* The fencepost takes at least MINSIZE bytes, because it might
> - become the top chunk again later. Note that a footer is set
> - up, too, although the chunk is marked in use. */
> - old_size = (old_size - MINSIZE) & ~MALLOC_ALIGN_MASK;
> - set_head(chunk_at_offset(old_top, old_size + 2*SIZE_SZ), 0|PREV_INUSE);
> - if (old_size >= MINSIZE) {
> - set_head(chunk_at_offset(old_top, old_size), (2*SIZE_SZ)|PREV_INUSE);
> - set_foot(chunk_at_offset(old_top, old_size), (2*SIZE_SZ));
> - set_head(old_top, old_size|PREV_INUSE|NON_MAIN_ARENA);
> - _int_free(av, old_top, 1);
> - } else {
> - set_head(old_top, (old_size + 2*SIZE_SZ)|PREV_INUSE);
> - set_foot(old_top, (old_size + 2*SIZE_SZ));
> - }
> - }
> - else if (!tried_mmap)
> - /* We can at least try to use to mmap memory. */
> - goto try_mmap;
> -
> - } else { /* av == main_arena */
> -
> -
> - /* Request enough space for nb + pad + overhead */
> -
> - size = nb + mp_.top_pad + MINSIZE;
> + assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));
>
> - /*
> - If contiguous, we can subtract out existing space that we hope to
> - combine with new space. We add it back later only if
> - we don't actually get contiguous space.
> - */
> -
> - if (contiguous(av))
> - size -= old_size;
> -
> - /*
> - Round to a multiple of page size.
> - If MORECORE is not contiguous, this ensures that we only call it
> - with whole-page arguments. And if MORECORE is contiguous and
> - this is not first time through, this preserves page-alignment of
> - previous calls. Otherwise, we correct to page-align below.
> - */
> -
> - size = (size + pagemask) & ~pagemask;
> -
> - /*
> - Don't try to call MORECORE if argument is so big as to appear
> - negative. Note that since mmap takes size_t arg, it may succeed
> - below even if we cannot call MORECORE.
> - */
> -
> - if (size > 0) {
> - brk = (char*)(MORECORE(size));
> - LIBC_PROBE (memory_sbrk_more, 2, brk, size);
> - }
>
> - if (brk != (char*)(MORECORE_FAILURE)) {
> - /* Call the `morecore' hook if necessary. */
> - void (*hook) (void) = atomic_forced_read (__after_morecore_hook);
> - if (__builtin_expect (hook != NULL, 0))
> - (*hook) ();
> - } else {
> - /*
> - If have mmap, try using it as a backup when MORECORE fails or
> - cannot be used. This is worth doing on systems that have "holes" in
> - address space, so sbrk cannot extend to give contiguous space, but
> - space is available elsewhere. Note that we ignore mmap max count
> - and threshold limits, since the space will not be used as a
> - segregated mmap region.
> - */
> -
> - /* Cannot merge with old top, so add its size back in */
> - if (contiguous(av))
> - size = (size + old_size + pagemask) & ~pagemask;
> -
> - /* If we are relying on mmap as backup, then use larger units */
> - if ((unsigned long)(size) < (unsigned long)(MMAP_AS_MORECORE_SIZE))
> - size = MMAP_AS_MORECORE_SIZE;
> -
> - /* 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, 0));
> -
> - if (mbrk != MAP_FAILED) {
> -
> - /* We do not need, and cannot use, another sbrk call to find end */
> - brk = mbrk;
> - snd_brk = brk + size;
> -
> - /*
> - Record that we no longer have a contiguous sbrk region.
> - After the first time mmap is used as backup, we do not
> - ever rely on contiguous space since this could incorrectly
> - bridge regions.
> - */
> - set_noncontiguous(av);
> - }
> + if (av != &main_arena)
> + {
> + heap_info *old_heap, *heap;
> + size_t old_heap_size;
> +
> + /* First try to extend the current heap. */
> + old_heap = heap_for_ptr (old_top);
> + old_heap_size = old_heap->size;
> + if ((long) (MINSIZE + nb - old_size) > 0
> + && grow_heap (old_heap, MINSIZE + nb - old_size) == 0)
> + {
> + av->system_mem += old_heap->size - old_heap_size;
> + arena_mem += old_heap->size - old_heap_size;
> + set_head (old_top, (((char *) old_heap + old_heap->size) - (char *) old_top)
> + | PREV_INUSE);
> + }
> + else if ((heap = new_heap (nb + (MINSIZE + sizeof (*heap)), mp_.top_pad)))
> + {
> + /* Use a newly allocated heap. */
> + heap->ar_ptr = av;
> + heap->prev = old_heap;
> + av->system_mem += heap->size;
> + arena_mem += heap->size;
> + /* Set up the new top. */
> + top (av) = chunk_at_offset (heap, sizeof (*heap));
> + set_head (top (av), (heap->size - sizeof (*heap)) | PREV_INUSE);
> +
> + /* Setup fencepost and free the old top chunk with a multiple of
> + MALLOC_ALIGNMENT in size. */
> + /* The fencepost takes at least MINSIZE bytes, because it might
> + become the top chunk again later. Note that a footer is set
> + up, too, although the chunk is marked in use. */
> + old_size = (old_size - MINSIZE) & ~MALLOC_ALIGN_MASK;
> + set_head (chunk_at_offset (old_top, old_size + 2 * SIZE_SZ), 0 | PREV_INUSE);
> + if (old_size >= MINSIZE)
> + {
> + set_head (chunk_at_offset (old_top, old_size), (2 * SIZE_SZ) | PREV_INUSE);
> + set_foot (chunk_at_offset (old_top, old_size), (2 * SIZE_SZ));
> + set_head (old_top, old_size | PREV_INUSE | NON_MAIN_ARENA);
> + _int_free (av, old_top, 1);
> + }
> + else
> + {
> + set_head (old_top, (old_size + 2 * SIZE_SZ) | PREV_INUSE);
> + set_foot (old_top, (old_size + 2 * SIZE_SZ));
> + }
> + }
> + else if (!tried_mmap)
> + /* We can at least try to use to mmap memory. */
> + goto try_mmap;
> }
> - }
> -
> - if (brk != (char*)(MORECORE_FAILURE)) {
> - if (mp_.sbrk_base == 0)
> - mp_.sbrk_base = brk;
> - av->system_mem += size;
> + else /* av == main_arena */
>
> - /*
> - If MORECORE extends previous space, we can likewise extend top size.
> - */
>
> - if (brk == old_end && snd_brk == (char*)(MORECORE_FAILURE))
> - set_head(old_top, (size + old_size) | PREV_INUSE);
> + { /* Request enough space for nb + pad + overhead */
> + size = nb + mp_.top_pad + MINSIZE;
>
> - else if (contiguous(av) && old_size && brk < old_end) {
> - /* Oops! Someone else killed our space.. Can't touch anything. */
> - malloc_printerr (3, "break adjusted to free malloc space", brk);
> - }
> + /*
> + If contiguous, we can subtract out existing space that we hope to
> + combine with new space. We add it back later only if
> + we don't actually get contiguous space.
> + */
>
> - /*
> - Otherwise, make adjustments:
> -
> - * If the first time through or noncontiguous, we need to call sbrk
> - just to find out where the end of memory lies.
> -
> - * We need to ensure that all returned chunks from malloc will meet
> - MALLOC_ALIGNMENT
> -
> - * If there was an intervening foreign sbrk, we need to adjust sbrk
> - request size to account for fact that we will not be able to
> - combine new space with existing space in old_top.
> -
> - * Almost all systems internally allocate whole pages at a time, in
> - which case we might as well use the whole last page of request.
> - So we allocate enough more memory to hit a page boundary now,
> - which in turn causes future contiguous calls to page-align.
> - */
> -
> - else {
> - front_misalign = 0;
> - end_misalign = 0;
> - correction = 0;
> - aligned_brk = brk;
> -
> - /* handle contiguous cases */
> - if (contiguous(av)) {
> -
> - /* Count foreign sbrk as system_mem. */
> - if (old_size)
> - av->system_mem += brk - old_end;
> -
> - /* Guarantee alignment of first new chunk made from this space */
> -
> - front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
> - if (front_misalign > 0) {
> -
> - /*
> - Skip over some bytes to arrive at an aligned position.
> - We don't need to specially mark these wasted front bytes.
> - They will never be accessed anyway because
> - prev_inuse of av->top (and any chunk created from its start)
> - is always true after initialization.
> - */
> -
> - correction = MALLOC_ALIGNMENT - front_misalign;
> - aligned_brk += correction;
> - }
> -
> - /*
> - If this isn't adjacent to existing space, then we will not
> - be able to merge with old_top space, so must add to 2nd request.
> - */
> -
> - correction += old_size;
> -
> - /* Extend the end address to hit a page boundary */
> - end_misalign = (INTERNAL_SIZE_T)(brk + size + correction);
> - correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
> -
> - assert(correction >= 0);
> - snd_brk = (char*)(MORECORE(correction));
> -
> - /*
> - If can't allocate correction, try to at least find out current
> - brk. It might be enough to proceed without failing.
> -
> - Note that if second sbrk did NOT fail, we assume that space
> - is contiguous with first sbrk. This is a safe assumption unless
> - program is multithreaded but doesn't use locks and a foreign sbrk
> - occurred between our first and second calls.
> - */
> -
> - if (snd_brk == (char*)(MORECORE_FAILURE)) {
> - correction = 0;
> - snd_brk = (char*)(MORECORE(0));
> - } else {
> - /* Call the `morecore' hook if necessary. */
> - void (*hook) (void) = atomic_forced_read (__after_morecore_hook);
> - if (__builtin_expect (hook != NULL, 0))
> - (*hook) ();
> - }
> - }
> + if (contiguous (av))
> + size -= old_size;
>
> - /* handle non-contiguous cases */
> - else {
> - if (MALLOC_ALIGNMENT == 2 * SIZE_SZ)
> - /* MORECORE/mmap must correctly align */
> - assert(((unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK) == 0);
> - else {
> - front_misalign = (INTERNAL_SIZE_T)chunk2mem(brk) & MALLOC_ALIGN_MASK;
> - if (front_misalign > 0) {
> -
> - /*
> - Skip over some bytes to arrive at an aligned position.
> - We don't need to specially mark these wasted front bytes.
> - They will never be accessed anyway because
> - prev_inuse of av->top (and any chunk created from its start)
> - is always true after initialization.
> - */
> -
> - aligned_brk += MALLOC_ALIGNMENT - front_misalign;
> - }
> - }
> -
> - /* Find out current end of memory */
> - if (snd_brk == (char*)(MORECORE_FAILURE)) {
> - snd_brk = (char*)(MORECORE(0));
> - }
> - }
> -
> - /* Adjust top based on results of second sbrk */
> - if (snd_brk != (char*)(MORECORE_FAILURE)) {
> - av->top = (mchunkptr)aligned_brk;
> - set_head(av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
> - av->system_mem += correction;
> -
> - /*
> - If not the first time through, we either have a
> - gap due to foreign sbrk or a non-contiguous region. Insert a
> - double fencepost at old_top to prevent consolidation with space
> - we don't own. These fenceposts are artificial chunks that are
> - marked as inuse and are in any case too small to use. We need
> - two to make sizes and alignments work out.
> - */
> -
> - if (old_size != 0) {
> - /*
> - Shrink old_top to insert fenceposts, keeping size a
> - multiple of MALLOC_ALIGNMENT. We know there is at least
> - enough space in old_top to do this.
> - */
> - old_size = (old_size - 4*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
> - set_head(old_top, old_size | PREV_INUSE);
> -
> - /*
> - Note that the following assignments completely overwrite
> - old_top when old_size was previously MINSIZE. This is
> - intentional. We need the fencepost, even if old_top otherwise gets
> - lost.
> - */
> - chunk_at_offset(old_top, old_size )->size =
> - (2*SIZE_SZ)|PREV_INUSE;
> -
> - chunk_at_offset(old_top, old_size + 2*SIZE_SZ)->size =
> - (2*SIZE_SZ)|PREV_INUSE;
> -
> - /* If possible, release the rest. */
> - if (old_size >= MINSIZE) {
> - _int_free(av, old_top, 1);
> - }
> -
> - }
> - }
> - }
> - }
> + /*
> + Round to a multiple of page size.
> + If MORECORE is not contiguous, this ensures that we only call it
> + with whole-page arguments. And if MORECORE is contiguous and
> + this is not first time through, this preserves page-alignment of
> + previous calls. Otherwise, we correct to page-align below.
> + */
>
> - } /* if (av != &main_arena) */
> + size = (size + pagemask) & ~pagemask;
>
> - if ((unsigned long)av->system_mem > (unsigned long)(av->max_system_mem))
> + /*
> + Don't try to call MORECORE if argument is so big as to appear
> + negative. Note that since mmap takes size_t arg, it may succeed
> + below even if we cannot call MORECORE.
> + */
> +
> + if (size > 0)
> + {
> + brk = (char *) (MORECORE (size));
> + LIBC_PROBE (memory_sbrk_more, 2, brk, size);
> + }
> +
> + if (brk != (char *) (MORECORE_FAILURE))
> + {
> + /* Call the `morecore' hook if necessary. */
> + void (*hook) (void) = atomic_forced_read (__after_morecore_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + (*hook)();
> + }
> + else
> + {
> + /*
> + If have mmap, try using it as a backup when MORECORE fails or
> + cannot be used. This is worth doing on systems that have "holes" in
> + address space, so sbrk cannot extend to give contiguous space, but
> + space is available elsewhere. Note that we ignore mmap max count
> + and threshold limits, since the space will not be used as a
> + segregated mmap region.
> + */
> +
> + /* Cannot merge with old top, so add its size back in */
> + if (contiguous (av))
> + size = (size + old_size + pagemask) & ~pagemask;
> +
> + /* If we are relying on mmap as backup, then use larger units */
> + if ((unsigned long) (size) < (unsigned long) (MMAP_AS_MORECORE_SIZE))
> + size = MMAP_AS_MORECORE_SIZE;
> +
> + /* 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, 0));
> +
> + if (mbrk != MAP_FAILED)
> + {
> + /* We do not need, and cannot use, another sbrk call to find end */
> + brk = mbrk;
> + snd_brk = brk + size;
> +
> + /*
> + Record that we no longer have a contiguous sbrk region.
> + After the first time mmap is used as backup, we do not
> + ever rely on contiguous space since this could incorrectly
> + bridge regions.
> + */
> + set_noncontiguous (av);
> + }
> + }
> + }
> +
> + if (brk != (char *) (MORECORE_FAILURE))
> + {
> + if (mp_.sbrk_base == 0)
> + mp_.sbrk_base = brk;
> + av->system_mem += size;
> +
> + /*
> + If MORECORE extends previous space, we can likewise extend top size.
> + */
> +
> + if (brk == old_end && snd_brk == (char *) (MORECORE_FAILURE))
> + set_head (old_top, (size + old_size) | PREV_INUSE);
> +
> + else if (contiguous (av) && old_size && brk < old_end)
> + {
> + /* Oops! Someone else killed our space.. Can't touch anything. */
> + malloc_printerr (3, "break adjusted to free malloc space", brk);
> + }
> +
> + /*
> + Otherwise, make adjustments:
> +
> + * If the first time through or noncontiguous, we need to call sbrk
> + just to find out where the end of memory lies.
> +
> + * We need to ensure that all returned chunks from malloc will meet
> + MALLOC_ALIGNMENT
> +
> + * If there was an intervening foreign sbrk, we need to adjust sbrk
> + request size to account for fact that we will not be able to
> + combine new space with existing space in old_top.
> +
> + * Almost all systems internally allocate whole pages at a time, in
> + which case we might as well use the whole last page of request.
> + So we allocate enough more memory to hit a page boundary now,
> + which in turn causes future contiguous calls to page-align.
> + */
> +
> + else
> + {
> + front_misalign = 0;
> + end_misalign = 0;
> + correction = 0;
> + aligned_brk = brk;
> +
> + /* handle contiguous cases */
> + if (contiguous (av))
> + {
> + /* Count foreign sbrk as system_mem. */
> + if (old_size)
> + av->system_mem += brk - old_end;
> +
> + /* Guarantee alignment of first new chunk made from this space */
> +
> + front_misalign = (INTERNAL_SIZE_T) chunk2mem (brk) & MALLOC_ALIGN_MASK;
> + if (front_misalign > 0)
> + {
> + /*
> + Skip over some bytes to arrive at an aligned position.
> + We don't need to specially mark these wasted front bytes.
> + They will never be accessed anyway because
> + prev_inuse of av->top (and any chunk created from its start)
> + is always true after initialization.
> + */
> +
> + correction = MALLOC_ALIGNMENT - front_misalign;
> + aligned_brk += correction;
> + }
> +
> + /*
> + If this isn't adjacent to existing space, then we will not
> + be able to merge with old_top space, so must add to 2nd request.
> + */
> +
> + correction += old_size;
> +
> + /* Extend the end address to hit a page boundary */
> + end_misalign = (INTERNAL_SIZE_T) (brk + size + correction);
> + correction += ((end_misalign + pagemask) & ~pagemask) - end_misalign;
> +
> + assert (correction >= 0);
> + snd_brk = (char *) (MORECORE (correction));
> +
> + /*
> + If can't allocate correction, try to at least find out current
> + brk. It might be enough to proceed without failing.
> +
> + Note that if second sbrk did NOT fail, we assume that space
> + is contiguous with first sbrk. This is a safe assumption unless
> + program is multithreaded but doesn't use locks and a foreign sbrk
> + occurred between our first and second calls.
> + */
> +
> + if (snd_brk == (char *) (MORECORE_FAILURE))
> + {
> + correction = 0;
> + snd_brk = (char *) (MORECORE (0));
> + }
> + else
> + {
> + /* Call the `morecore' hook if necessary. */
> + void (*hook) (void) = atomic_forced_read (__after_morecore_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + (*hook)();
> + }
> + }
> +
> + /* handle non-contiguous cases */
> + else
> + {
> + if (MALLOC_ALIGNMENT == 2 * SIZE_SZ)
> + /* MORECORE/mmap must correctly align */
> + assert (((unsigned long) chunk2mem (brk) & MALLOC_ALIGN_MASK) == 0);
> + else
> + {
> + front_misalign = (INTERNAL_SIZE_T) chunk2mem (brk) & MALLOC_ALIGN_MASK;
> + if (front_misalign > 0)
> + {
> + /*
> + Skip over some bytes to arrive at an aligned position.
> + We don't need to specially mark these wasted front bytes.
> + They will never be accessed anyway because
> + prev_inuse of av->top (and any chunk created from its start)
> + is always true after initialization.
> + */
> +
> + aligned_brk += MALLOC_ALIGNMENT - front_misalign;
> + }
> + }
> +
> + /* Find out current end of memory */
> + if (snd_brk == (char *) (MORECORE_FAILURE))
> + {
> + snd_brk = (char *) (MORECORE (0));
> + }
> + }
> +
> + /* Adjust top based on results of second sbrk */
> + if (snd_brk != (char *) (MORECORE_FAILURE))
> + {
> + av->top = (mchunkptr) aligned_brk;
> + set_head (av->top, (snd_brk - aligned_brk + correction) | PREV_INUSE);
> + av->system_mem += correction;
> +
> + /*
> + If not the first time through, we either have a
> + gap due to foreign sbrk or a non-contiguous region. Insert a
> + double fencepost at old_top to prevent consolidation with space
> + we don't own. These fenceposts are artificial chunks that are
> + marked as inuse and are in any case too small to use. We need
> + two to make sizes and alignments work out.
> + */
> +
> + if (old_size != 0)
> + {
> + /*
> + Shrink old_top to insert fenceposts, keeping size a
> + multiple of MALLOC_ALIGNMENT. We know there is at least
> + enough space in old_top to do this.
> + */
> + old_size = (old_size - 4 * SIZE_SZ) & ~MALLOC_ALIGN_MASK;
> + set_head (old_top, old_size | PREV_INUSE);
> +
> + /*
> + Note that the following assignments completely overwrite
> + old_top when old_size was previously MINSIZE. This is
> + intentional. We need the fencepost, even if old_top otherwise gets
> + lost.
> + */
> + chunk_at_offset (old_top, old_size)->size =
> + (2 * SIZE_SZ) | PREV_INUSE;
> +
> + chunk_at_offset (old_top, old_size + 2 * SIZE_SZ)->size =
> + (2 * SIZE_SZ) | PREV_INUSE;
> +
> + /* If possible, release the rest. */
> + if (old_size >= MINSIZE)
> + {
> + _int_free (av, old_top, 1);
> + }
> + }
> + }
> + }
> + }
> + } /* if (av != &main_arena) */
> +
> + if ((unsigned long) av->system_mem > (unsigned long) (av->max_system_mem))
> av->max_system_mem = av->system_mem;
> - check_malloc_state(av);
> + check_malloc_state (av);
>
> /* finally, do the allocation */
> p = av->top;
> - size = chunksize(p);
> + size = chunksize (p);
>
> /* check that one of the above allocation paths succeeded */
> - if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
> - remainder_size = size - nb;
> - remainder = chunk_at_offset(p, nb);
> - av->top = remainder;
> - set_head(p, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_head(remainder, remainder_size | PREV_INUSE);
> - check_malloced_chunk(av, p, nb);
> - return chunk2mem(p);
> - }
> + if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
> + {
> + remainder_size = size - nb;
> + remainder = chunk_at_offset (p, nb);
> + av->top = remainder;
> + set_head (p, nb | PREV_INUSE | (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_head (remainder, remainder_size | PREV_INUSE);
> + check_malloced_chunk (av, p, nb);
> + return chunk2mem (p);
> + }
>
> /* catch all failure paths */
> __set_errno (ENOMEM);
> @@ -2677,26 +2721,27 @@ static void* sysmalloc(INTERNAL_SIZE_T nb, mstate av)
>
>
> /*
> - 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
> - threshold. It is also called by the public malloc_trim routine. It
> - returns 1 if it actually released any memory, else 0.
> -*/
> -
> -static int systrim(size_t pad, mstate av)
> + 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
> + threshold. It is also called by the public malloc_trim routine. It
> + returns 1 if it actually released any memory, else 0.
> + */
> +
> +static int
> +systrim (size_t pad, mstate av)
> {
> - long top_size; /* Amount of top-most memory */
> - long extra; /* Amount to release */
> - long released; /* Amount actually released */
> - char* current_brk; /* address returned by pre-check sbrk call */
> - char* new_brk; /* address returned by post-check sbrk call */
> + long top_size; /* Amount of top-most memory */
> + long extra; /* Amount to release */
> + long released; /* Amount actually released */
> + char *current_brk; /* address returned by pre-check sbrk call */
> + char *new_brk; /* address returned by post-check sbrk call */
> size_t pagesz;
> - long top_area;
> + long top_area;
>
> - pagesz = GLRO(dl_pagesize);
> - top_size = chunksize(av->top);
> + pagesz = GLRO (dl_pagesize);
> + top_size = chunksize (av->top);
>
> top_area = top_size - MINSIZE - 1;
> if (top_area <= pad)
> @@ -2706,53 +2751,55 @@ static int systrim(size_t pad, mstate av)
> extra = (top_area - pad) & ~(pagesz - 1);
>
> /*
> - Only proceed if end of memory is where we last set it.
> - This avoids problems if there were foreign sbrk calls.
> - */
> - current_brk = (char*)(MORECORE(0));
> - if (current_brk == (char*)(av->top) + top_size) {
> -
> - /*
> - Attempt to release memory. We ignore MORECORE return value,
> - and instead call again to find out where new end of memory is.
> - This avoids problems if first call releases less than we asked,
> - of if failure somehow altered brk value. (We could still
> - encounter problems if it altered brk in some very bad way,
> - but the only thing we can do is adjust anyway, which will cause
> - some downstream failure.)
> - */
> -
> - MORECORE(-extra);
> - /* Call the `morecore' hook if necessary. */
> - void (*hook) (void) = atomic_forced_read (__after_morecore_hook);
> - if (__builtin_expect (hook != NULL, 0))
> - (*hook) ();
> - new_brk = (char*)(MORECORE(0));
> -
> - LIBC_PROBE (memory_sbrk_less, 2, new_brk, extra);
> -
> - if (new_brk != (char*)MORECORE_FAILURE) {
> - released = (long)(current_brk - new_brk);
> -
> - if (released != 0) {
> - /* Success. Adjust top. */
> - av->system_mem -= released;
> - set_head(av->top, (top_size - released) | PREV_INUSE);
> - check_malloc_state(av);
> - return 1;
> - }
> + Only proceed if end of memory is where we last set it.
> + This avoids problems if there were foreign sbrk calls.
> + */
> + current_brk = (char *) (MORECORE (0));
> + if (current_brk == (char *) (av->top) + top_size)
> + {
> + /*
> + Attempt to release memory. We ignore MORECORE return value,
> + and instead call again to find out where new end of memory is.
> + This avoids problems if first call releases less than we asked,
> + of if failure somehow altered brk value. (We could still
> + encounter problems if it altered brk in some very bad way,
> + but the only thing we can do is adjust anyway, which will cause
> + some downstream failure.)
> + */
> +
> + MORECORE (-extra);
> + /* Call the `morecore' hook if necessary. */
> + void (*hook) (void) = atomic_forced_read (__after_morecore_hook);
> + if (__builtin_expect (hook != NULL, 0))
> + (*hook)();
> + new_brk = (char *) (MORECORE (0));
> +
> + LIBC_PROBE (memory_sbrk_less, 2, new_brk, extra);
> +
> + if (new_brk != (char *) MORECORE_FAILURE)
> + {
> + released = (long) (current_brk - new_brk);
> +
> + if (released != 0)
> + {
> + /* Success. Adjust top. */
> + av->system_mem -= released;
> + set_head (av->top, (top_size - released) | PREV_INUSE);
> + check_malloc_state (av);
> + return 1;
> + }
> + }
> }
> - }
> return 0;
> }
>
> static void
> internal_function
> -munmap_chunk(mchunkptr p)
> +munmap_chunk (mchunkptr p)
> {
> - INTERNAL_SIZE_T size = chunksize(p);
> + INTERNAL_SIZE_T size = chunksize (p);
>
> - assert (chunk_is_mmapped(p));
> + assert (chunk_is_mmapped (p));
>
> uintptr_t block = (uintptr_t) p - p->prev_size;
> size_t total_size = p->prev_size + size;
> @@ -2761,10 +2808,10 @@ munmap_chunk(mchunkptr p)
> page size. But gcc does not recognize the optimization possibility
> (in the moment at least) so we combine the two values into one before
> the bit test. */
> - if (__builtin_expect (((block | total_size) & (GLRO(dl_pagesize) - 1)) != 0, 0))
> + if (__builtin_expect (((block | total_size) & (GLRO (dl_pagesize) - 1)) != 0, 0))
> {
> malloc_printerr (check_action, "munmap_chunk(): invalid pointer",
> - chunk2mem (p));
> + chunk2mem (p));
> return;
> }
>
> @@ -2774,22 +2821,22 @@ 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
>
> static mchunkptr
> internal_function
> -mremap_chunk(mchunkptr p, size_t new_size)
> +mremap_chunk (mchunkptr p, size_t new_size)
> {
> - size_t page_mask = GLRO(dl_pagesize) - 1;
> + size_t page_mask = GLRO (dl_pagesize) - 1;
> INTERNAL_SIZE_T offset = p->prev_size;
> - INTERNAL_SIZE_T size = chunksize(p);
> + INTERNAL_SIZE_T size = chunksize (p);
> char *cp;
>
> - assert (chunk_is_mmapped(p));
> - assert(((size + offset) & (GLRO(dl_pagesize)-1)) == 0);
> + assert (chunk_is_mmapped (p));
> + assert (((size + offset) & (GLRO (dl_pagesize) - 1)) == 0);
>
> /* Note the extra SIZE_SZ overhead as in mmap_chunk(). */
> new_size = (new_size + offset + SIZE_SZ + page_mask) & ~page_mask;
> @@ -2798,31 +2845,31 @@ 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;
> + if (cp == MAP_FAILED)
> + return 0;
>
> - p = (mchunkptr)(cp + offset);
> + p = (mchunkptr) (cp + offset);
>
> - assert(aligned_OK(chunk2mem(p)));
> + assert (aligned_OK (chunk2mem (p)));
>
> - assert((p->prev_size == offset));
> - set_head(p, (new_size - offset)|IS_MMAPPED);
> + assert ((p->prev_size == offset));
> + set_head (p, (new_size - offset) | IS_MMAPPED);
>
> INTERNAL_SIZE_T new;
> new = atomic_exchange_and_add (&mp_.mmapped_mem, new_size - size - offset)
> - + new_size - size - offset;
> + + new_size - size - offset;
> atomic_max (&mp_.max_mmapped_mem, new);
> return p;
> }
> -
> #endif /* HAVE_MREMAP */
>
> /*------------------------ Public wrappers. --------------------------------*/
>
> -void*
> -__libc_malloc(size_t bytes)
> +void *
> +__libc_malloc (size_t bytes)
> {
> mstate ar_ptr;
> void *victim;
> @@ -2832,73 +2879,78 @@ __libc_malloc(size_t bytes)
> if (__builtin_expect (hook != NULL, 0))
> return (*hook)(bytes, RETURN_ADDRESS (0));
>
> - arena_lookup(ar_ptr);
> + arena_lookup (ar_ptr);
>
> - arena_lock(ar_ptr, bytes);
> - if(!ar_ptr)
> + arena_lock (ar_ptr, bytes);
> + if (!ar_ptr)
> return 0;
> - victim = _int_malloc(ar_ptr, bytes);
> - if(!victim) {
> - LIBC_PROBE (memory_malloc_retry, 1, bytes);
> - ar_ptr = arena_get_retry(ar_ptr, bytes);
> - if (__builtin_expect(ar_ptr != NULL, 1)) {
> - victim = _int_malloc(ar_ptr, bytes);
> - (void)mutex_unlock(&ar_ptr->mutex);
> +
> + victim = _int_malloc (ar_ptr, bytes);
> + if (!victim)
> + {
> + LIBC_PROBE (memory_malloc_retry, 1, bytes);
> + ar_ptr = arena_get_retry (ar_ptr, bytes);
> + if (__builtin_expect (ar_ptr != NULL, 1))
> + {
> + victim = _int_malloc (ar_ptr, bytes);
> + (void) mutex_unlock (&ar_ptr->mutex);
> + }
> }
> - } else
> - (void)mutex_unlock(&ar_ptr->mutex);
> - assert(!victim || chunk_is_mmapped(mem2chunk(victim)) ||
> - ar_ptr == arena_for_chunk(mem2chunk(victim)));
> + else
> + (void) mutex_unlock (&ar_ptr->mutex);
> + assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
> + ar_ptr == arena_for_chunk (mem2chunk (victim)));
> return victim;
> }
> -libc_hidden_def(__libc_malloc)
> +libc_hidden_def (__libc_malloc)
>
> void
> -__libc_free(void* mem)
> +__libc_free (void *mem)
> {
> mstate ar_ptr;
> mchunkptr p; /* chunk corresponding to mem */
>
> void (*hook) (void *, const void *)
> = atomic_forced_read (__free_hook);
> - if (__builtin_expect (hook != NULL, 0)) {
> - (*hook)(mem, RETURN_ADDRESS (0));
> - return;
> - }
> + if (__builtin_expect (hook != NULL, 0))
> + {
> + (*hook)(mem, RETURN_ADDRESS (0));
> + return;
> + }
>
> if (mem == 0) /* free(0) has no effect */
> return;
>
> - p = mem2chunk(mem);
> + p = mem2chunk (mem);
>
> - if (chunk_is_mmapped(p)) /* release mmapped memory. */
> - {
> - /* see if the dynamic brk/mmap threshold needs adjusting */
> - if (!mp_.no_dyn_threshold
> - && p->size > mp_.mmap_threshold
> - && p->size <= DEFAULT_MMAP_THRESHOLD_MAX)
> - {
> - mp_.mmap_threshold = chunksize (p);
> - mp_.trim_threshold = 2 * mp_.mmap_threshold;
> - LIBC_PROBE (memory_mallopt_free_dyn_thresholds, 2,
> - mp_.mmap_threshold, mp_.trim_threshold);
> - }
> - munmap_chunk(p);
> - return;
> - }
> + if (chunk_is_mmapped (p)) /* release mmapped memory. */
> + {
> + /* see if the dynamic brk/mmap threshold needs adjusting */
> + if (!mp_.no_dyn_threshold
> + && p->size > mp_.mmap_threshold
> + && p->size <= DEFAULT_MMAP_THRESHOLD_MAX)
> + {
> + mp_.mmap_threshold = chunksize (p);
> + mp_.trim_threshold = 2 * mp_.mmap_threshold;
> + LIBC_PROBE (memory_mallopt_free_dyn_thresholds, 2,
> + mp_.mmap_threshold, mp_.trim_threshold);
> + }
> + munmap_chunk (p);
> + return;
> + }
>
> - ar_ptr = arena_for_chunk(p);
> - _int_free(ar_ptr, p, 0);
> + ar_ptr = arena_for_chunk (p);
> + _int_free (ar_ptr, p, 0);
> }
> libc_hidden_def (__libc_free)
>
> -void*
> -__libc_realloc(void* oldmem, size_t bytes)
> +void *
> +__libc_realloc (void *oldmem, size_t bytes)
> {
> mstate ar_ptr;
> - INTERNAL_SIZE_T nb; /* padded request size */
> + INTERNAL_SIZE_T nb; /* padded request size */
>
> - void* newp; /* chunk to return */
> + void *newp; /* chunk to return */
>
> void *(*hook) (void *, size_t, const void *) =
> atomic_forced_read (__realloc_hook);
> @@ -2906,16 +2958,20 @@ __libc_realloc(void* oldmem, size_t bytes)
> return (*hook)(oldmem, bytes, RETURN_ADDRESS (0));
>
> #if REALLOC_ZERO_BYTES_FREES
> - if (bytes == 0 && oldmem != NULL) { __libc_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 __libc_malloc(bytes);
> + if (oldmem == 0)
> + return __libc_malloc (bytes);
>
> /* chunk corresponding to oldmem */
> - const mchunkptr oldp = mem2chunk(oldmem);
> + const mchunkptr oldp = mem2chunk (oldmem);
> /* its size */
> - const INTERNAL_SIZE_T oldsize = chunksize(oldp);
> + const INTERNAL_SIZE_T oldsize = chunksize (oldp);
>
> /* Little security check which won't hurt performance: the
> allocator never wrapps around at the end of the address space.
> @@ -2928,63 +2984,69 @@ __libc_realloc(void* oldmem, size_t bytes)
> return NULL;
> }
>
> - checked_request2size(bytes, nb);
> + checked_request2size (bytes, nb);
>
> - if (chunk_is_mmapped(oldp))
> - {
> - void* newmem;
> + if (chunk_is_mmapped (oldp))
> + {
> + void *newmem;
>
> #if HAVE_MREMAP
> - newp = mremap_chunk(oldp, nb);
> - if(newp) return chunk2mem(newp);
> + newp = mremap_chunk (oldp, nb);
> + if (newp)
> + return chunk2mem (newp);
> #endif
> - /* Note the extra SIZE_SZ overhead. */
> - if(oldsize - SIZE_SZ >= nb) return oldmem; /* do nothing */
> - /* Must alloc, copy, free. */
> - newmem = __libc_malloc(bytes);
> - if (newmem == 0) return 0; /* propagate failure */
> - memcpy(newmem, oldmem, oldsize - 2*SIZE_SZ);
> - munmap_chunk(oldp);
> - return newmem;
> - }
> + /* Note the extra SIZE_SZ overhead. */
> + if (oldsize - SIZE_SZ >= nb)
> + return oldmem; /* do nothing */
> +
> + /* Must alloc, copy, free. */
> + newmem = __libc_malloc (bytes);
> + if (newmem == 0)
> + return 0; /* propagate failure */
>
> - ar_ptr = arena_for_chunk(oldp);
> + memcpy (newmem, oldmem, oldsize - 2 * SIZE_SZ);
> + munmap_chunk (oldp);
> + return newmem;
> + }
> +
> + ar_ptr = arena_for_chunk (oldp);
> #if THREAD_STATS
> - if(!mutex_trylock(&ar_ptr->mutex))
> + if (!mutex_trylock (&ar_ptr->mutex))
> ++(ar_ptr->stat_lock_direct);
> - else {
> - (void)mutex_lock(&ar_ptr->mutex);
> - ++(ar_ptr->stat_lock_wait);
> - }
> + else
> + {
> + (void) mutex_lock (&ar_ptr->mutex);
> + ++(ar_ptr->stat_lock_wait);
> + }
> #else
> - (void)mutex_lock(&ar_ptr->mutex);
> + (void) mutex_lock (&ar_ptr->mutex);
> #endif
>
>
> - newp = _int_realloc(ar_ptr, oldp, oldsize, nb);
> + newp = _int_realloc (ar_ptr, oldp, oldsize, nb);
>
> - (void)mutex_unlock(&ar_ptr->mutex);
> - assert(!newp || chunk_is_mmapped(mem2chunk(newp)) ||
> - ar_ptr == arena_for_chunk(mem2chunk(newp)));
> + (void) mutex_unlock (&ar_ptr->mutex);
> + assert (!newp || chunk_is_mmapped (mem2chunk (newp)) ||
> + ar_ptr == arena_for_chunk (mem2chunk (newp)));
>
> if (newp == NULL)
> {
> /* Try harder to allocate memory in other arenas. */
> LIBC_PROBE (memory_realloc_retry, 2, bytes, oldmem);
> - newp = __libc_malloc(bytes);
> + newp = __libc_malloc (bytes);
> if (newp != NULL)
> - {
> - memcpy (newp, oldmem, oldsize - SIZE_SZ);
> - _int_free(ar_ptr, oldp, 0);
> - }
> + {
> + memcpy (newp, oldmem, oldsize - SIZE_SZ);
> + _int_free (ar_ptr, oldp, 0);
> + }
> }
>
> return newp;
> }
> libc_hidden_def (__libc_realloc)
>
> -void*
> -__libc_memalign(size_t alignment, size_t bytes)
> +void *
> +__libc_memalign (size_t alignment, size_t bytes)
> {
> void *address = RETURN_ADDRESS (0);
> return _mid_memalign (alignment, bytes, address);
> @@ -3002,10 +3064,12 @@ _mid_memalign (size_t alignment, size_t bytes, void *address)
> return (*hook)(alignment, bytes, address);
>
> /* If we need less alignment than we give anyway, just relay to malloc. */
> - if (alignment <= MALLOC_ALIGNMENT) return __libc_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;
> + if (alignment < MINSIZE)
> + alignment = MINSIZE;
>
> /* If the alignment is greater than SIZE_MAX / 2 + 1 it cannot be a
> power of 2 and will cause overflow in the check below. */
> @@ -3024,58 +3088,63 @@ _mid_memalign (size_t alignment, size_t bytes, void *address)
>
>
> /* Make sure alignment is power of 2. */
> - if (!powerof2(alignment)) {
> - size_t a = MALLOC_ALIGNMENT * 2;
> - while (a < alignment) a <<= 1;
> - alignment = a;
> - }
> + if (!powerof2 (alignment))
> + {
> + size_t a = MALLOC_ALIGNMENT * 2;
> + while (a < alignment)
> + a <<= 1;
> + alignment = a;
> + }
>
> - arena_get(ar_ptr, bytes + alignment + MINSIZE);
> - if(!ar_ptr)
> + arena_get (ar_ptr, bytes + alignment + MINSIZE);
> + if (!ar_ptr)
> return 0;
> - p = _int_memalign(ar_ptr, alignment, bytes);
> - if(!p) {
> - LIBC_PROBE (memory_memalign_retry, 2, bytes, alignment);
> - ar_ptr = arena_get_retry (ar_ptr, bytes);
> - if (__builtin_expect(ar_ptr != NULL, 1)) {
> - p = _int_memalign(ar_ptr, alignment, bytes);
> - (void)mutex_unlock(&ar_ptr->mutex);
> +
> + p = _int_memalign (ar_ptr, alignment, bytes);
> + if (!p)
> + {
> + LIBC_PROBE (memory_memalign_retry, 2, bytes, alignment);
> + ar_ptr = arena_get_retry (ar_ptr, bytes);
> + if (__builtin_expect (ar_ptr != NULL, 1))
> + {
> + p = _int_memalign (ar_ptr, alignment, bytes);
> + (void) mutex_unlock (&ar_ptr->mutex);
> + }
> }
> - } else
> - (void)mutex_unlock(&ar_ptr->mutex);
> - assert(!p || chunk_is_mmapped(mem2chunk(p)) ||
> - ar_ptr == arena_for_chunk(mem2chunk(p)));
> + else
> + (void) mutex_unlock (&ar_ptr->mutex);
> + assert (!p || chunk_is_mmapped (mem2chunk (p)) ||
> + ar_ptr == arena_for_chunk (mem2chunk (p)));
> return p;
> }
> /* For ISO C11. */
> weak_alias (__libc_memalign, aligned_alloc)
> libc_hidden_def (__libc_memalign)
>
> -void*
> -__libc_valloc(size_t bytes)
> +void *
> +__libc_valloc (size_t bytes)
> {
> - if(__malloc_initialized < 0)
> + if (__malloc_initialized < 0)
> ptmalloc_init ();
>
> void *address = RETURN_ADDRESS (0);
> - size_t pagesz = GLRO(dl_pagesize);
> + size_t pagesz = GLRO (dl_pagesize);
> return _mid_memalign (pagesz, bytes, address);
> }
>
> -void*
> -__libc_pvalloc(size_t bytes)
> +void *
> +__libc_pvalloc (size_t bytes)
> {
> -
> - if(__malloc_initialized < 0)
> + if (__malloc_initialized < 0)
> ptmalloc_init ();
>
> void *address = RETURN_ADDRESS (0);
> - size_t pagesz = GLRO(dl_pagesize);
> - size_t page_mask = GLRO(dl_pagesize) - 1;
> + size_t pagesz = GLRO (dl_pagesize);
> + size_t page_mask = GLRO (dl_pagesize) - 1;
> size_t rounded_bytes = (bytes + page_mask) & ~(page_mask);
>
> /* Check for overflow. */
> - if (bytes > SIZE_MAX - 2*pagesz - MINSIZE)
> + if (bytes > SIZE_MAX - 2 * pagesz - MINSIZE)
> {
> __set_errno (ENOMEM);
> return 0;
> @@ -3084,235 +3153,254 @@ __libc_pvalloc(size_t bytes)
> return _mid_memalign (pagesz, rounded_bytes, address);
> }
>
> -void*
> -__libc_calloc(size_t n, size_t elem_size)
> +void *
> +__libc_calloc (size_t n, size_t elem_size)
> {
> mstate av;
> mchunkptr oldtop, p;
> INTERNAL_SIZE_T bytes, sz, csz, oldtopsize;
> - void* mem;
> + void *mem;
> unsigned long clearsize;
> unsigned long nclears;
> - INTERNAL_SIZE_T* d;
> + INTERNAL_SIZE_T *d;
>
> /* size_t is unsigned so the behavior on overflow is defined. */
> bytes = n * elem_size;
> #define HALF_INTERNAL_SIZE_T \
> (((INTERNAL_SIZE_T) 1) << (8 * sizeof (INTERNAL_SIZE_T) / 2))
> - if (__builtin_expect ((n | elem_size) >= HALF_INTERNAL_SIZE_T, 0)) {
> - if (elem_size != 0 && bytes / elem_size != n) {
> - __set_errno (ENOMEM);
> - return 0;
> + if (__builtin_expect ((n | elem_size) >= HALF_INTERNAL_SIZE_T, 0))
> + {
> + if (elem_size != 0 && bytes / elem_size != n)
> + {
> + __set_errno (ENOMEM);
> + return 0;
> + }
> }
> - }
>
> void *(*hook) (size_t, const void *) =
> atomic_forced_read (__malloc_hook);
> - if (__builtin_expect (hook != NULL, 0)) {
> - sz = bytes;
> - mem = (*hook)(sz, RETURN_ADDRESS (0));
> - if(mem == 0)
> - return 0;
> - return memset(mem, 0, sz);
> - }
> + if (__builtin_expect (hook != NULL, 0))
> + {
> + sz = bytes;
> + mem = (*hook)(sz, RETURN_ADDRESS (0));
> + if (mem == 0)
> + return 0;
> +
> + return memset (mem, 0, sz);
> + }
>
> sz = bytes;
>
> - arena_get(av, sz);
> - if(!av)
> + arena_get (av, sz);
> + if (!av)
> return 0;
>
> /* Check if we hand out the top chunk, in which case there may be no
> need to clear. */
> #if MORECORE_CLEARS
> - oldtop = top(av);
> - oldtopsize = chunksize(top(av));
> -#if MORECORE_CLEARS < 2
> + oldtop = top (av);
> + oldtopsize = chunksize (top (av));
> +# if MORECORE_CLEARS < 2
> /* Only newly allocated memory is guaranteed to be cleared. */
> if (av == &main_arena &&
> - oldtopsize < mp_.sbrk_base + av->max_system_mem - (char *)oldtop)
> - oldtopsize = (mp_.sbrk_base + av->max_system_mem - (char *)oldtop);
> -#endif
> + oldtopsize < mp_.sbrk_base + av->max_system_mem - (char *) oldtop)
> + oldtopsize = (mp_.sbrk_base + av->max_system_mem - (char *) oldtop);
> +# endif
> if (av != &main_arena)
> {
> heap_info *heap = heap_for_ptr (oldtop);
> if (oldtopsize < (char *) heap + heap->mprotect_size - (char *) oldtop)
> - oldtopsize = (char *) heap + heap->mprotect_size - (char *) oldtop;
> + oldtopsize = (char *) heap + heap->mprotect_size - (char *) oldtop;
> }
> #endif
> - mem = _int_malloc(av, sz);
> + mem = _int_malloc (av, sz);
>
>
> - assert(!mem || chunk_is_mmapped(mem2chunk(mem)) ||
> - av == arena_for_chunk(mem2chunk(mem)));
> + assert (!mem || chunk_is_mmapped (mem2chunk (mem)) ||
> + av == arena_for_chunk (mem2chunk (mem)));
>
> - if (mem == 0) {
> - LIBC_PROBE (memory_calloc_retry, 1, sz);
> - av = arena_get_retry (av, sz);
> - if (__builtin_expect(av != NULL, 1)) {
> - mem = _int_malloc(av, sz);
> - (void)mutex_unlock(&av->mutex);
> + if (mem == 0)
> + {
> + LIBC_PROBE (memory_calloc_retry, 1, sz);
> + av = arena_get_retry (av, sz);
> + if (__builtin_expect (av != NULL, 1))
> + {
> + mem = _int_malloc (av, sz);
> + (void) mutex_unlock (&av->mutex);
> + }
> + if (mem == 0)
> + return 0;
> }
> - if (mem == 0) return 0;
> - } else
> - (void)mutex_unlock(&av->mutex);
> - p = mem2chunk(mem);
> + else
> + (void) mutex_unlock (&av->mutex);
> + p = mem2chunk (mem);
>
> /* Two optional cases in which clearing not necessary */
> if (chunk_is_mmapped (p))
> {
> if (__builtin_expect (perturb_byte, 0))
> - return memset (mem, 0, sz);
> + return memset (mem, 0, sz);
> +
> return mem;
> }
>
> - csz = chunksize(p);
> + csz = chunksize (p);
>
> #if MORECORE_CLEARS
> - if (perturb_byte == 0 && (p == oldtop && csz > oldtopsize)) {
> - /* clear only the bytes from non-freshly-sbrked memory */
> - csz = oldtopsize;
> - }
> + if (perturb_byte == 0 && (p == oldtop && csz > oldtopsize))
> + {
> + /* clear only the bytes from non-freshly-sbrked memory */
> + csz = oldtopsize;
> + }
> #endif
>
> /* Unroll clear of <= 36 bytes (72 if 8byte sizes). We know that
> contents have an odd number of INTERNAL_SIZE_T-sized words;
> minimally 3. */
> - d = (INTERNAL_SIZE_T*)mem;
> + d = (INTERNAL_SIZE_T *) mem;
> clearsize = csz - SIZE_SZ;
> - nclears = clearsize / sizeof(INTERNAL_SIZE_T);
> - assert(nclears >= 3);
> + nclears = clearsize / sizeof (INTERNAL_SIZE_T);
> + assert (nclears >= 3);
>
> if (nclears > 9)
> - return memset(d, 0, clearsize);
> -
> - else {
> - *(d+0) = 0;
> - *(d+1) = 0;
> - *(d+2) = 0;
> - if (nclears > 4) {
> - *(d+3) = 0;
> - *(d+4) = 0;
> - if (nclears > 6) {
> - *(d+5) = 0;
> - *(d+6) = 0;
> - if (nclears > 8) {
> - *(d+7) = 0;
> - *(d+8) = 0;
> - }
> - }
> + return memset (d, 0, clearsize);
> +
> + else
> + {
> + *(d + 0) = 0;
> + *(d + 1) = 0;
> + *(d + 2) = 0;
> + if (nclears > 4)
> + {
> + *(d + 3) = 0;
> + *(d + 4) = 0;
> + if (nclears > 6)
> + {
> + *(d + 5) = 0;
> + *(d + 6) = 0;
> + if (nclears > 8)
> + {
> + *(d + 7) = 0;
> + *(d + 8) = 0;
> + }
> + }
> + }
> }
> - }
>
> return mem;
> }
>
> /*
> - ------------------------------ malloc ------------------------------
> -*/
> + ------------------------------ malloc ------------------------------
> + */
>
> -static void*
> -_int_malloc(mstate av, size_t bytes)
> +static void *
> +_int_malloc (mstate av, size_t bytes)
> {
> INTERNAL_SIZE_T nb; /* normalized request size */
> - unsigned int idx; /* associated bin index */
> - mbinptr bin; /* associated bin */
> + unsigned int idx; /* associated bin index */
> + mbinptr bin; /* associated bin */
>
> - mchunkptr victim; /* inspected/selected chunk */
> + mchunkptr victim; /* inspected/selected chunk */
> INTERNAL_SIZE_T size; /* its size */
> - int victim_index; /* its bin index */
> + int victim_index; /* its bin index */
>
> - mchunkptr remainder; /* remainder from a split */
> - unsigned long remainder_size; /* its size */
> + mchunkptr remainder; /* remainder from a split */
> + unsigned long remainder_size; /* its size */
>
> - unsigned int block; /* bit map traverser */
> - unsigned int bit; /* bit map traverser */
> - unsigned int map; /* current word of binmap */
> + unsigned int block; /* bit map traverser */
> + unsigned int bit; /* bit map traverser */
> + unsigned int map; /* current word of binmap */
>
> - mchunkptr fwd; /* misc temp for linking */
> - mchunkptr bck; /* misc temp for linking */
> + mchunkptr fwd; /* misc temp for linking */
> + mchunkptr bck; /* misc temp for linking */
>
> const char *errstr = NULL;
>
> /*
> - Convert request size to internal form by adding SIZE_SZ bytes
> - overhead plus possibly more to obtain necessary alignment and/or
> - to obtain a size of at least MINSIZE, the smallest allocatable
> - size. Also, checked_request2size traps (returning 0) request sizes
> - that are so large that they wrap around zero when padded and
> - aligned.
> - */
> + Convert request size to internal form by adding SIZE_SZ bytes
> + overhead plus possibly more to obtain necessary alignment and/or
> + to obtain a size of at least MINSIZE, the smallest allocatable
> + size. Also, checked_request2size traps (returning 0) request sizes
> + that are so large that they wrap around zero when padded and
> + aligned.
> + */
>
> - checked_request2size(bytes, nb);
> + checked_request2size (bytes, nb);
>
> /*
> - If the size qualifies as a fastbin, first check corresponding bin.
> - This code is safe to execute even if av is not yet initialized, so we
> - can try it without checking, which saves some time on this fast path.
> - */
> -
> - if ((unsigned long)(nb) <= (unsigned long)(get_max_fast ())) {
> - idx = fastbin_index(nb);
> - mfastbinptr* fb = &fastbin (av, idx);
> - mchunkptr pp = *fb;
> - do
> - {
> - victim = pp;
> - if (victim == NULL)
> - break;
> - }
> - while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
> - != victim);
> - if (victim != 0) {
> - if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
> - {
> - errstr = "malloc(): memory corruption (fast)";
> - errout:
> - malloc_printerr (check_action, errstr, chunk2mem (victim));
> - return NULL;
> - }
> - check_remalloced_chunk(av, victim, nb);
> - void *p = chunk2mem(victim);
> - alloc_perturb (p, bytes);
> - return p;
> + If the size qualifies as a fastbin, first check corresponding bin.
> + This code is safe to execute even if av is not yet initialized, so we
> + can try it without checking, which saves some time on this fast path.
> + */
> +
> + if ((unsigned long) (nb) <= (unsigned long) (get_max_fast ()))
> + {
> + idx = fastbin_index (nb);
> + mfastbinptr *fb = &fastbin (av, idx);
> + mchunkptr pp = *fb;
> + do
> + {
> + victim = pp;
> + if (victim == NULL)
> + break;
> + }
> + while ((pp = catomic_compare_and_exchange_val_acq (fb, victim->fd, victim))
> + != victim);
> + if (victim != 0)
> + {
> + if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
> + {
> + errstr = "malloc(): memory corruption (fast)";
> + errout:
> + malloc_printerr (check_action, errstr, chunk2mem (victim));
> + return NULL;
> + }
> + check_remalloced_chunk (av, victim, nb);
> + void *p = chunk2mem (victim);
> + alloc_perturb (p, bytes);
> + return p;
> + }
> }
> - }
>
> /*
> - If a small request, check regular bin. Since these "smallbins"
> - hold one size each, no searching within bins is necessary.
> - (For a large request, we need to wait until unsorted chunks are
> - processed to find best fit. But for small ones, fits are exact
> - anyway, so we can check now, which is faster.)
> - */
> -
> - if (in_smallbin_range(nb)) {
> - idx = smallbin_index(nb);
> - bin = bin_at(av,idx);
> -
> - if ( (victim = last(bin)) != bin) {
> - if (victim == 0) /* initialization check */
> - malloc_consolidate(av);
> - else {
> - bck = victim->bk;
> - if (__builtin_expect (bck->fd != victim, 0))
> - {
> - errstr = "malloc(): smallbin double linked list corrupted";
> - goto errout;
> - }
> - set_inuse_bit_at_offset(victim, nb);
> - bin->bk = bck;
> - bck->fd = bin;
> -
> - if (av != &main_arena)
> - victim->size |= NON_MAIN_ARENA;
> - check_malloced_chunk(av, victim, nb);
> - void *p = chunk2mem(victim);
> - alloc_perturb (p, bytes);
> - return p;
> - }
> + If a small request, check regular bin. Since these "smallbins"
> + hold one size each, no searching within bins is necessary.
> + (For a large request, we need to wait until unsorted chunks are
> + processed to find best fit. But for small ones, fits are exact
> + anyway, so we can check now, which is faster.)
> + */
> +
> + if (in_smallbin_range (nb))
> + {
> + idx = smallbin_index (nb);
> + bin = bin_at (av, idx);
> +
> + if ((victim = last (bin)) != bin)
> + {
> + if (victim == 0) /* initialization check */
> + malloc_consolidate (av);
> + else
> + {
> + bck = victim->bk;
> + if (__builtin_expect (bck->fd != victim, 0))
> + {
> + errstr = "malloc(): smallbin double linked list corrupted";
> + goto errout;
> + }
> + set_inuse_bit_at_offset (victim, nb);
> + bin->bk = bck;
> + bck->fd = bin;
> +
> + if (av != &main_arena)
> + victim->size |= NON_MAIN_ARENA;
> + check_malloced_chunk (av, victim, nb);
> + void *p = chunk2mem (victim);
> + alloc_perturb (p, bytes);
> + return p;
> + }
> + }
> }
> - }
>
> /*
> If this is a large request, consolidate fastbins before continuing.
> @@ -3323,394 +3411,417 @@ _int_malloc(mstate av, size_t bytes)
> large requests, but less often mixtures, so consolidation is not
> invoked all that often in most programs. And the programs that
> it is called frequently in otherwise tend to fragment.
> - */
> + */
>
> - else {
> - idx = largebin_index(nb);
> - if (have_fastchunks(av))
> - malloc_consolidate(av);
> - }
> + else
> + {
> + idx = largebin_index (nb);
> + if (have_fastchunks (av))
> + malloc_consolidate (av);
> + }
>
> /*
> - Process recently freed or remaindered chunks, taking one only if
> - it is exact fit, or, if this a small request, the chunk is remainder from
> - the most recent non-exact fit. Place other traversed chunks in
> - bins. Note that this step is the only place in any routine where
> - chunks are placed in bins.
> -
> - The outer loop here is needed because we might not realize until
> - near the end of malloc that we should have consolidated, so must
> - do so and retry. This happens at most once, and only when we would
> - otherwise need to expand memory to service a "small" request.
> - */
> -
> - for(;;) {
> -
> - int iters = 0;
> - while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) {
> - bck = victim->bk;
> - if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)
> - || __builtin_expect (victim->size > av->system_mem, 0))
> - malloc_printerr (check_action, "malloc(): memory corruption",
> - chunk2mem (victim));
> - size = chunksize(victim);
> + Process recently freed or remaindered chunks, taking one only if
> + it is exact fit, or, if this a small request, the chunk is remainder from
> + the most recent non-exact fit. Place other traversed chunks in
> + bins. Note that this step is the only place in any routine where
> + chunks are placed in bins.
> +
> + The outer loop here is needed because we might not realize until
> + near the end of malloc that we should have consolidated, so must
> + do so and retry. This happens at most once, and only when we would
> + otherwise need to expand memory to service a "small" request.
> + */
> +
> + for (;; )
> + {
> + int iters = 0;
> + while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
> + {
> + bck = victim->bk;
> + if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)
> + || __builtin_expect (victim->size > av->system_mem, 0))
> + malloc_printerr (check_action, "malloc(): memory corruption",
> + chunk2mem (victim));
> + size = chunksize (victim);
> +
> + /*
> + If a small request, try to use last remainder if it is the
> + only chunk in unsorted bin. This helps promote locality for
> + runs of consecutive small requests. This is the only
> + exception to best-fit, and applies only when there is
> + no exact fit for a small chunk.
> + */
> +
> + if (in_smallbin_range (nb) &&
> + bck == unsorted_chunks (av) &&
> + victim == av->last_remainder &&
> + (unsigned long) (size) > (unsigned long) (nb + MINSIZE))
> + {
> + /* split and reattach remainder */
> + remainder_size = size - nb;
> + remainder = chunk_at_offset (victim, nb);
> + unsorted_chunks (av)->bk = unsorted_chunks (av)->fd = remainder;
> + av->last_remainder = remainder;
> + remainder->bk = remainder->fd = unsorted_chunks (av);
> + if (!in_smallbin_range (remainder_size))
> + {
> + remainder->fd_nextsize = NULL;
> + remainder->bk_nextsize = NULL;
> + }
> +
> + set_head (victim, nb | PREV_INUSE |
> + (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_head (remainder, remainder_size | PREV_INUSE);
> + set_foot (remainder, remainder_size);
> +
> + check_malloced_chunk (av, victim, nb);
> + void *p = chunk2mem (victim);
> + alloc_perturb (p, bytes);
> + return p;
> + }
> +
> + /* remove from unsorted list */
> + unsorted_chunks (av)->bk = bck;
> + bck->fd = unsorted_chunks (av);
> +
> + /* Take now instead of binning if exact fit */
> +
> + if (size == nb)
> + {
> + set_inuse_bit_at_offset (victim, size);
> + if (av != &main_arena)
> + victim->size |= NON_MAIN_ARENA;
> + check_malloced_chunk (av, victim, nb);
> + void *p = chunk2mem (victim);
> + alloc_perturb (p, bytes);
> + return p;
> + }
> +
> + /* place chunk in bin */
> +
> + if (in_smallbin_range (size))
> + {
> + victim_index = smallbin_index (size);
> + bck = bin_at (av, victim_index);
> + fwd = bck->fd;
> + }
> + else
> + {
> + victim_index = largebin_index (size);
> + bck = bin_at (av, victim_index);
> + fwd = bck->fd;
> +
> + /* maintain large bins in sorted order */
> + if (fwd != bck)
> + {
> + /* Or with inuse bit to speed comparisons */
> + size |= PREV_INUSE;
> + /* if smaller than smallest, bypass loop below */
> + assert ((bck->bk->size & NON_MAIN_ARENA) == 0);
> + if ((unsigned long) (size) < (unsigned long) (bck->bk->size))
> + {
> + fwd = bck;
> + bck = bck->bk;
> +
> + victim->fd_nextsize = fwd->fd;
> + victim->bk_nextsize = fwd->fd->bk_nextsize;
> + fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
> + }
> + else
> + {
> + assert ((fwd->size & NON_MAIN_ARENA) == 0);
> + while ((unsigned long) size < fwd->size)
> + {
> + fwd = fwd->fd_nextsize;
> + assert ((fwd->size & NON_MAIN_ARENA) == 0);
> + }
> +
> + if ((unsigned long) size == (unsigned long) fwd->size)
> + /* Always insert in the second position. */
> + fwd = fwd->fd;
> + else
> + {
> + victim->fd_nextsize = fwd;
> + victim->bk_nextsize = fwd->bk_nextsize;
> + fwd->bk_nextsize = victim;
> + victim->bk_nextsize->fd_nextsize = victim;
> + }
> + bck = fwd->bk;
> + }
> + }
> + else
> + victim->fd_nextsize = victim->bk_nextsize = victim;
> + }
> +
> + mark_bin (av, victim_index);
> + victim->bk = bck;
> + victim->fd = fwd;
> + fwd->bk = victim;
> + bck->fd = victim;
> +
> +#define MAX_ITERS 10000
> + if (++iters >= MAX_ITERS)
> + break;
> + }
>
> /*
> - If a small request, try to use last remainder if it is the
> - only chunk in unsorted bin. This helps promote locality for
> - runs of consecutive small requests. This is the only
> - exception to best-fit, and applies only when there is
> - no exact fit for a small chunk.
> - */
> -
> - if (in_smallbin_range(nb) &&
> - bck == unsorted_chunks(av) &&
> - victim == av->last_remainder &&
> - (unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
> -
> - /* split and reattach remainder */
> - remainder_size = size - nb;
> - remainder = chunk_at_offset(victim, nb);
> - unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
> - av->last_remainder = remainder;
> - remainder->bk = remainder->fd = unsorted_chunks(av);
> - if (!in_smallbin_range(remainder_size))
> - {
> - remainder->fd_nextsize = NULL;
> - remainder->bk_nextsize = NULL;
> - }
> -
> - set_head(victim, nb | PREV_INUSE |
> - (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_head(remainder, remainder_size | PREV_INUSE);
> - set_foot(remainder, remainder_size);
> -
> - check_malloced_chunk(av, victim, nb);
> - void *p = chunk2mem(victim);
> - alloc_perturb (p, bytes);
> - return p;
> - }
> -
> - /* remove from unsorted list */
> - unsorted_chunks(av)->bk = bck;
> - bck->fd = unsorted_chunks(av);
> -
> - /* Take now instead of binning if exact fit */
> -
> - if (size == nb) {
> - set_inuse_bit_at_offset(victim, size);
> - if (av != &main_arena)
> - victim->size |= NON_MAIN_ARENA;
> - check_malloced_chunk(av, victim, nb);
> - void *p = chunk2mem(victim);
> - alloc_perturb (p, bytes);
> - return p;
> - }
> -
> - /* place chunk in bin */
> -
> - if (in_smallbin_range(size)) {
> - victim_index = smallbin_index(size);
> - bck = bin_at(av, victim_index);
> - fwd = bck->fd;
> - }
> - else {
> - victim_index = largebin_index(size);
> - bck = bin_at(av, victim_index);
> - fwd = bck->fd;
> -
> - /* maintain large bins in sorted order */
> - if (fwd != bck) {
> - /* Or with inuse bit to speed comparisons */
> - size |= PREV_INUSE;
> - /* if smaller than smallest, bypass loop below */
> - assert((bck->bk->size & NON_MAIN_ARENA) == 0);
> - if ((unsigned long)(size) < (unsigned long)(bck->bk->size)) {
> - fwd = bck;
> - bck = bck->bk;
> -
> - victim->fd_nextsize = fwd->fd;
> - victim->bk_nextsize = fwd->fd->bk_nextsize;
> - fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
> - }
> - else {
> - assert((fwd->size & NON_MAIN_ARENA) == 0);
> - while ((unsigned long) size < fwd->size)
> - {
> - fwd = fwd->fd_nextsize;
> - assert((fwd->size & NON_MAIN_ARENA) == 0);
> - }
> -
> - if ((unsigned long) size == (unsigned long) fwd->size)
> - /* Always insert in the second position. */
> - fwd = fwd->fd;
> - else
> - {
> - victim->fd_nextsize = fwd;
> - victim->bk_nextsize = fwd->bk_nextsize;
> - fwd->bk_nextsize = victim;
> - victim->bk_nextsize->fd_nextsize = victim;
> - }
> - bck = fwd->bk;
> - }
> - } else
> - victim->fd_nextsize = victim->bk_nextsize = victim;
> - }
> -
> - mark_bin(av, victim_index);
> - victim->bk = bck;
> - victim->fd = fwd;
> - fwd->bk = victim;
> - bck->fd = victim;
> -
> -#define MAX_ITERS 10000
> - if (++iters >= MAX_ITERS)
> - break;
> - }
> -
> - /*
> - If a large request, scan through the chunks of current bin in
> - sorted order to find smallest that fits. Use the skip list for this.
> - */
> -
> - if (!in_smallbin_range(nb)) {
> - bin = bin_at(av, idx);
> -
> - /* skip scan if empty or largest chunk is too small */
> - if ((victim = first(bin)) != bin &&
> - (unsigned long)(victim->size) >= (unsigned long)(nb)) {
> -
> - victim = victim->bk_nextsize;
> - while (((unsigned long)(size = chunksize(victim)) <
> - (unsigned long)(nb)))
> - victim = victim->bk_nextsize;
> -
> - /* Avoid removing the first entry for a size so that the skip
> - list does not have to be rerouted. */
> - if (victim != last(bin) && victim->size == victim->fd->size)
> - victim = victim->fd;
> -
> - remainder_size = size - nb;
> - unlink(victim, bck, fwd);
> -
> - /* Exhaust */
> - if (remainder_size < MINSIZE) {
> - set_inuse_bit_at_offset(victim, size);
> - if (av != &main_arena)
> - victim->size |= NON_MAIN_ARENA;
> - }
> - /* Split */
> - else {
> - remainder = chunk_at_offset(victim, nb);
> - /* We cannot assume the unsorted list is empty and therefore
> - have to perform a complete insert here. */
> - bck = unsorted_chunks(av);
> - fwd = bck->fd;
> - if (__builtin_expect (fwd->bk != bck, 0))
> - {
> - errstr = "malloc(): corrupted unsorted chunks";
> - goto errout;
> - }
> - remainder->bk = bck;
> - remainder->fd = fwd;
> - bck->fd = remainder;
> - fwd->bk = remainder;
> - if (!in_smallbin_range(remainder_size))
> - {
> - remainder->fd_nextsize = NULL;
> - remainder->bk_nextsize = NULL;
> - }
> - set_head(victim, nb | PREV_INUSE |
> - (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_head(remainder, remainder_size | PREV_INUSE);
> - set_foot(remainder, remainder_size);
> - }
> - check_malloced_chunk(av, victim, nb);
> - void *p = chunk2mem(victim);
> - alloc_perturb (p, bytes);
> - return p;
> - }
> - }
> -
> - /*
> - Search for a chunk by scanning bins, starting with next largest
> - bin. This search is strictly by best-fit; i.e., the smallest
> - (with ties going to approximately the least recently used) chunk
> - that fits is selected.
> -
> - The bitmap avoids needing to check that most blocks are nonempty.
> - The particular case of skipping all bins during warm-up phases
> - when no chunks have been returned yet is faster than it might look.
> - */
> -
> - ++idx;
> - bin = bin_at(av,idx);
> - block = idx2block(idx);
> - map = av->binmap[block];
> - bit = idx2bit(idx);
> -
> - for (;;) {
> -
> - /* Skip rest of block if there are no more set bits in this block. */
> - if (bit > map || bit == 0) {
> - do {
> - if (++block >= BINMAPSIZE) /* out of bins */
> - goto use_top;
> - } while ( (map = av->binmap[block]) == 0);
> -
> - bin = bin_at(av, (block << BINMAPSHIFT));
> - bit = 1;
> - }
> -
> - /* Advance to bin with set bit. There must be one. */
> - while ((bit & map) == 0) {
> - bin = next_bin(bin);
> - bit <<= 1;
> - assert(bit != 0);
> - }
> -
> - /* Inspect the bin. It is likely to be non-empty */
> - victim = last(bin);
> -
> - /* If a false alarm (empty bin), clear the bit. */
> - if (victim == bin) {
> - av->binmap[block] = map &= ~bit; /* Write through */
> - bin = next_bin(bin);
> - bit <<= 1;
> - }
> -
> - else {
> - size = chunksize(victim);
> -
> - /* We know the first chunk in this bin is big enough to use. */
> - assert((unsigned long)(size) >= (unsigned long)(nb));
> -
> - remainder_size = size - nb;
> -
> - /* unlink */
> - unlink(victim, bck, fwd);
> -
> - /* Exhaust */
> - if (remainder_size < MINSIZE) {
> - set_inuse_bit_at_offset(victim, size);
> - if (av != &main_arena)
> - victim->size |= NON_MAIN_ARENA;
> - }
> -
> - /* Split */
> - else {
> - remainder = chunk_at_offset(victim, nb);
> -
> - /* We cannot assume the unsorted list is empty and therefore
> - have to perform a complete insert here. */
> - bck = unsorted_chunks(av);
> - fwd = bck->fd;
> - if (__builtin_expect (fwd->bk != bck, 0))
> - {
> - errstr = "malloc(): corrupted unsorted chunks 2";
> - goto errout;
> - }
> - remainder->bk = bck;
> - remainder->fd = fwd;
> - bck->fd = remainder;
> - fwd->bk = remainder;
> -
> - /* advertise as last remainder */
> - if (in_smallbin_range(nb))
> - av->last_remainder = remainder;
> - if (!in_smallbin_range(remainder_size))
> - {
> - remainder->fd_nextsize = NULL;
> - remainder->bk_nextsize = NULL;
> - }
> - set_head(victim, nb | PREV_INUSE |
> - (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_head(remainder, remainder_size | PREV_INUSE);
> - set_foot(remainder, remainder_size);
> - }
> - check_malloced_chunk(av, victim, nb);
> - void *p = chunk2mem(victim);
> - alloc_perturb (p, bytes);
> - return p;
> - }
> - }
> + If a large request, scan through the chunks of current bin in
> + sorted order to find smallest that fits. Use the skip list for this.
> + */
> +
> + if (!in_smallbin_range (nb))
> + {
> + bin = bin_at (av, idx);
> +
> + /* skip scan if empty or largest chunk is too small */
> + if ((victim = first (bin)) != bin &&
> + (unsigned long) (victim->size) >= (unsigned long) (nb))
> + {
> + victim = victim->bk_nextsize;
> + while (((unsigned long) (size = chunksize (victim)) <
> + (unsigned long) (nb)))
> + victim = victim->bk_nextsize;
> +
> + /* Avoid removing the first entry for a size so that the skip
> + list does not have to be rerouted. */
> + if (victim != last (bin) && victim->size == victim->fd->size)
> + victim = victim->fd;
> +
> + remainder_size = size - nb;
> + unlink (victim, bck, fwd);
> +
> + /* Exhaust */
> + if (remainder_size < MINSIZE)
> + {
> + set_inuse_bit_at_offset (victim, size);
> + if (av != &main_arena)
> + victim->size |= NON_MAIN_ARENA;
> + }
> + /* Split */
> + else
> + {
> + remainder = chunk_at_offset (victim, nb);
> + /* We cannot assume the unsorted list is empty and therefore
> + have to perform a complete insert here. */
> + bck = unsorted_chunks (av);
> + fwd = bck->fd;
> + if (__builtin_expect (fwd->bk != bck, 0))
> + {
> + errstr = "malloc(): corrupted unsorted chunks";
> + goto errout;
> + }
> + remainder->bk = bck;
> + remainder->fd = fwd;
> + bck->fd = remainder;
> + fwd->bk = remainder;
> + if (!in_smallbin_range (remainder_size))
> + {
> + remainder->fd_nextsize = NULL;
> + remainder->bk_nextsize = NULL;
> + }
> + set_head (victim, nb | PREV_INUSE |
> + (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_head (remainder, remainder_size | PREV_INUSE);
> + set_foot (remainder, remainder_size);
> + }
> + check_malloced_chunk (av, victim, nb);
> + void *p = chunk2mem (victim);
> + alloc_perturb (p, bytes);
> + return p;
> + }
> + }
>
> - use_top:
> - /*
> - If large enough, split off the chunk bordering the end of memory
> - (held in av->top). Note that this is in accord with the best-fit
> - search rule. In effect, av->top is treated as larger (and thus
> - less well fitting) than any other available chunk since it can
> - be extended to be as large as necessary (up to system
> - limitations).
> -
> - We require that av->top always exists (i.e., has size >=
> - MINSIZE) after initialization, so if it would otherwise be
> - exhausted by current request, it is replenished. (The main
> - reason for ensuring it exists is that we may need MINSIZE space
> - to put in fenceposts in sysmalloc.)
> - */
> -
> - victim = av->top;
> - size = chunksize(victim);
> -
> - if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE)) {
> - remainder_size = size - nb;
> - remainder = chunk_at_offset(victim, nb);
> - av->top = remainder;
> - set_head(victim, nb | PREV_INUSE |
> - (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_head(remainder, remainder_size | PREV_INUSE);
> -
> - check_malloced_chunk(av, victim, nb);
> - void *p = chunk2mem(victim);
> - alloc_perturb (p, bytes);
> - return p;
> - }
> + /*
> + Search for a chunk by scanning bins, starting with next largest
> + bin. This search is strictly by best-fit; i.e., the smallest
> + (with ties going to approximately the least recently used) chunk
> + that fits is selected.
> +
> + The bitmap avoids needing to check that most blocks are nonempty.
> + The particular case of skipping all bins during warm-up phases
> + when no chunks have been returned yet is faster than it might look.
> + */
> +
> + ++idx;
> + bin = bin_at (av, idx);
> + block = idx2block (idx);
> + map = av->binmap[block];
> + bit = idx2bit (idx);
> +
> + for (;; )
> + {
> + /* Skip rest of block if there are no more set bits in this block. */
> + if (bit > map || bit == 0)
> + {
> + do
> + {
> + if (++block >= BINMAPSIZE) /* out of bins */
> + goto use_top;
> + }
> + while ((map = av->binmap[block]) == 0);
> +
> + bin = bin_at (av, (block << BINMAPSHIFT));
> + bit = 1;
> + }
> +
> + /* Advance to bin with set bit. There must be one. */
> + while ((bit & map) == 0)
> + {
> + bin = next_bin (bin);
> + bit <<= 1;
> + assert (bit != 0);
> + }
> +
> + /* Inspect the bin. It is likely to be non-empty */
> + victim = last (bin);
> +
> + /* If a false alarm (empty bin), clear the bit. */
> + if (victim == bin)
> + {
> + av->binmap[block] = map &= ~bit; /* Write through */
> + bin = next_bin (bin);
> + bit <<= 1;
> + }
> +
> + else
> + {
> + size = chunksize (victim);
> +
> + /* We know the first chunk in this bin is big enough to use. */
> + assert ((unsigned long) (size) >= (unsigned long) (nb));
> +
> + remainder_size = size - nb;
> +
> + /* unlink */
> + unlink (victim, bck, fwd);
> +
> + /* Exhaust */
> + if (remainder_size < MINSIZE)
> + {
> + set_inuse_bit_at_offset (victim, size);
> + if (av != &main_arena)
> + victim->size |= NON_MAIN_ARENA;
> + }
> +
> + /* Split */
> + else
> + {
> + remainder = chunk_at_offset (victim, nb);
> +
> + /* We cannot assume the unsorted list is empty and therefore
> + have to perform a complete insert here. */
> + bck = unsorted_chunks (av);
> + fwd = bck->fd;
> + if (__builtin_expect (fwd->bk != bck, 0))
> + {
> + errstr = "malloc(): corrupted unsorted chunks 2";
> + goto errout;
> + }
> + remainder->bk = bck;
> + remainder->fd = fwd;
> + bck->fd = remainder;
> + fwd->bk = remainder;
> +
> + /* advertise as last remainder */
> + if (in_smallbin_range (nb))
> + av->last_remainder = remainder;
> + if (!in_smallbin_range (remainder_size))
> + {
> + remainder->fd_nextsize = NULL;
> + remainder->bk_nextsize = NULL;
> + }
> + set_head (victim, nb | PREV_INUSE |
> + (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_head (remainder, remainder_size | PREV_INUSE);
> + set_foot (remainder, remainder_size);
> + }
> + check_malloced_chunk (av, victim, nb);
> + void *p = chunk2mem (victim);
> + alloc_perturb (p, bytes);
> + return p;
> + }
> + }
> +
> + use_top:
> + /*
> + If large enough, split off the chunk bordering the end of memory
> + (held in av->top). Note that this is in accord with the best-fit
> + search rule. In effect, av->top is treated as larger (and thus
> + less well fitting) than any other available chunk since it can
> + be extended to be as large as necessary (up to system
> + limitations).
> +
> + We require that av->top always exists (i.e., has size >=
> + MINSIZE) after initialization, so if it would otherwise be
> + exhausted by current request, it is replenished. (The main
> + reason for ensuring it exists is that we may need MINSIZE space
> + to put in fenceposts in sysmalloc.)
> + */
> +
> + victim = av->top;
> + size = chunksize (victim);
> +
> + if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
> + {
> + remainder_size = size - nb;
> + remainder = chunk_at_offset (victim, nb);
> + av->top = remainder;
> + set_head (victim, nb | PREV_INUSE |
> + (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_head (remainder, remainder_size | PREV_INUSE);
> +
> + check_malloced_chunk (av, victim, nb);
> + void *p = chunk2mem (victim);
> + alloc_perturb (p, bytes);
> + return p;
> + }
> +
> + /* When we are using atomic ops to free fast chunks we can get
> + here for all block sizes. */
> + else if (have_fastchunks (av))
> + {
> + malloc_consolidate (av);
> + /* restore original bin index */
> + if (in_smallbin_range (nb))
> + idx = smallbin_index (nb);
> + else
> + idx = largebin_index (nb);
> + }
>
> - /* When we are using atomic ops to free fast chunks we can get
> - here for all block sizes. */
> - else if (have_fastchunks(av)) {
> - malloc_consolidate(av);
> - /* restore original bin index */
> - if (in_smallbin_range(nb))
> - idx = smallbin_index(nb);
> + /*
> + Otherwise, relay to handle system-dependent cases
> + */
> else
> - idx = largebin_index(nb);
> + {
> + void *p = sysmalloc (nb, av);
> + if (p != NULL)
> + alloc_perturb (p, bytes);
> + return p;
> + }
> }
> -
> - /*
> - Otherwise, relay to handle system-dependent cases
> - */
> - else {
> - void *p = sysmalloc(nb, av);
> - if (p != NULL)
> - alloc_perturb (p, bytes);
> - return p;
> - }
> - }
> }
>
> /*
> - ------------------------------ free ------------------------------
> -*/
> + ------------------------------ free ------------------------------
> + */
>
> static void
> -_int_free(mstate av, mchunkptr p, int have_lock)
> +_int_free (mstate av, mchunkptr p, int have_lock)
> {
> INTERNAL_SIZE_T size; /* its size */
> - mfastbinptr* fb; /* associated fastbin */
> - mchunkptr nextchunk; /* next contiguous chunk */
> + mfastbinptr *fb; /* associated fastbin */
> + mchunkptr nextchunk; /* next contiguous chunk */
> INTERNAL_SIZE_T nextsize; /* its size */
> - int nextinuse; /* true if nextchunk is used */
> + int nextinuse; /* true if nextchunk is used */
> INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
> - mchunkptr bck; /* misc temp for linking */
> - mchunkptr fwd; /* misc temp for linking */
> + mchunkptr bck; /* misc temp for linking */
> + mchunkptr fwd; /* misc temp for linking */
>
> const char *errstr = NULL;
> int locked = 0;
>
> - size = chunksize(p);
> + size = chunksize (p);
>
> /* Little security check which won't hurt performance: the
> allocator never wrapps around at the end of the address space.
> @@ -3721,9 +3832,9 @@ _int_free(mstate av, mchunkptr p, int have_lock)
> {
> errstr = "free(): invalid pointer";
> errout:
> - if (! have_lock && locked)
> - (void)mutex_unlock(&av->mutex);
> - malloc_printerr (check_action, errstr, chunk2mem(p));
> + if (!have_lock && locked)
> + (void) mutex_unlock (&av->mutex);
> + malloc_printerr (check_action, errstr, chunk2mem (p));
> return;
> }
> /* We know that each chunk is at least MINSIZE bytes in size or a
> @@ -3734,376 +3845,401 @@ _int_free(mstate av, mchunkptr p, int have_lock)
> goto errout;
> }
>
> - check_inuse_chunk(av, p);
> + check_inuse_chunk (av, p);
>
> /*
> - If eligible, place chunk on a fastbin so it can be found
> - and used quickly in malloc.
> - */
> + If eligible, place chunk on a fastbin so it can be found
> + and used quickly in malloc.
> + */
>
> - if ((unsigned long)(size) <= (unsigned long)(get_max_fast ())
> + if ((unsigned long) (size) <= (unsigned long) (get_max_fast ())
>
> #if TRIM_FASTBINS
> /*
> - If TRIM_FASTBINS set, don't place chunks
> - bordering top into fastbins
> - */
> - && (chunk_at_offset(p, size) != av->top)
> + If TRIM_FASTBINS set, don't place chunks
> + bordering top into fastbins
> + */
> + && (chunk_at_offset (p, size) != av->top)
> #endif
> - ) {
> -
> - if (__builtin_expect (chunk_at_offset (p, size)->size <= 2 * SIZE_SZ, 0)
> - || __builtin_expect (chunksize (chunk_at_offset (p, size))
> - >= av->system_mem, 0))
> - {
> - /* We might not have a lock at this point and concurrent modifications
> - of system_mem might have let to a false positive. Redo the test
> - after getting the lock. */
> - if (have_lock
> - || ({ assert (locked == 0);
> - mutex_lock(&av->mutex);
> - locked = 1;
> - chunk_at_offset (p, size)->size <= 2 * SIZE_SZ
> - || chunksize (chunk_at_offset (p, size)) >= av->system_mem;
> - }))
> - {
> - errstr = "free(): invalid next size (fast)";
> - goto errout;
> - }
> - if (! have_lock)
> - {
> - (void)mutex_unlock(&av->mutex);
> - locked = 0;
> - }
> - }
> -
> - free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);
> -
> - set_fastchunks(av);
> - unsigned int idx = fastbin_index(size);
> - fb = &fastbin (av, idx);
> -
> - mchunkptr fd;
> - mchunkptr old = *fb;
> - unsigned int old_idx = ~0u;
> - do
> - {
> - /* Another simple check: make sure the top of the bin is not the
> - record we are going to add (i.e., double free). */
> - if (__builtin_expect (old == p, 0))
> - {
> - errstr = "double free or corruption (fasttop)";
> - goto errout;
> - }
> - if (old != NULL)
> - old_idx = fastbin_index(chunksize(old));
> - p->fd = fd = old;
> - }
> - while ((old = catomic_compare_and_exchange_val_rel (fb, p, fd)) != fd);
> -
> - if (fd != NULL && __builtin_expect (old_idx != idx, 0))
> - {
> - errstr = "invalid fastbin entry (free)";
> - goto errout;
> - }
> - }
> + )
> + {
> + if (__builtin_expect (chunk_at_offset (p, size)->size <= 2 * SIZE_SZ, 0)
> + || __builtin_expect (chunksize (chunk_at_offset (p, size))
> + >= av->system_mem, 0))
> + {
> + /* We might not have a lock at this point and concurrent modifications
> + of system_mem might have let to a false positive. Redo the test
> + after getting the lock. */
> + if (have_lock
> + || ({ assert (locked == 0);
> + mutex_lock (&av->mutex);
> + locked = 1;
> + chunk_at_offset (p, size)->size <= 2 * SIZE_SZ
> + || chunksize (chunk_at_offset (p, size)) >= av->system_mem; }))
> + {
> + errstr = "free(): invalid next size (fast)";
> + goto errout;
> + }
> + if (!have_lock)
> + {
> + (void) mutex_unlock (&av->mutex);
> + locked = 0;
> + }
> + }
> +
> + free_perturb (chunk2mem (p), size - 2 * SIZE_SZ);
> +
> + set_fastchunks (av);
> + unsigned int idx = fastbin_index (size);
> + fb = &fastbin (av, idx);
> +
> + mchunkptr fd;
> + mchunkptr old = *fb;
> + unsigned int old_idx = ~0u;
> + do
> + {
> + /* Another simple check: make sure the top of the bin is not the
> + record we are going to add (i.e., double free). */
> + if (__builtin_expect (old == p, 0))
> + {
> + errstr = "double free or corruption (fasttop)";
> + goto errout;
> + }
> + if (old != NULL)
> + old_idx = fastbin_index (chunksize (old));
> + p->fd = fd = old;
> + }
> + while ((old = catomic_compare_and_exchange_val_rel (fb, p, fd)) != fd);
> +
> + if (fd != NULL && __builtin_expect (old_idx != idx, 0))
> + {
> + errstr = "invalid fastbin entry (free)";
> + goto errout;
> + }
> + }
>
> /*
> - Consolidate other non-mmapped chunks as they arrive.
> - */
> + Consolidate other non-mmapped chunks as they arrive.
> + */
>
> - else if (!chunk_is_mmapped(p)) {
> - if (! have_lock) {
> + else if (!chunk_is_mmapped (p))
> + {
> + if (!have_lock)
> + {
> #if THREAD_STATS
> - if(!mutex_trylock(&av->mutex))
> - ++(av->stat_lock_direct);
> - else {
> - (void)mutex_lock(&av->mutex);
> - ++(av->stat_lock_wait);
> - }
> + if (!mutex_trylock (&av->mutex))
> + ++(av->stat_lock_direct);
> + else
> + {
> + (void) mutex_lock (&av->mutex);
> + ++(av->stat_lock_wait);
> + }
> #else
> - (void)mutex_lock(&av->mutex);
> + (void) mutex_lock (&av->mutex);
> #endif
> - locked = 1;
> - }
> -
> - nextchunk = chunk_at_offset(p, size);
> -
> - /* Lightweight tests: check whether the block is already the
> - top block. */
> - if (__builtin_expect (p == av->top, 0))
> - {
> - errstr = "double free or corruption (top)";
> - goto errout;
> - }
> - /* Or whether the next chunk is beyond the boundaries of the arena. */
> - if (__builtin_expect (contiguous (av)
> - && (char *) nextchunk
> - >= ((char *) av->top + chunksize(av->top)), 0))
> - {
> - errstr = "double free or corruption (out)";
> - goto errout;
> - }
> - /* Or whether the block is actually not marked used. */
> - if (__builtin_expect (!prev_inuse(nextchunk), 0))
> - {
> - errstr = "double free or corruption (!prev)";
> - goto errout;
> - }
> -
> - nextsize = chunksize(nextchunk);
> - if (__builtin_expect (nextchunk->size <= 2 * SIZE_SZ, 0)
> - || __builtin_expect (nextsize >= av->system_mem, 0))
> - {
> - errstr = "free(): invalid next size (normal)";
> - goto errout;
> - }
> -
> - free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);
> -
> - /* consolidate backward */
> - if (!prev_inuse(p)) {
> - prevsize = p->prev_size;
> - size += prevsize;
> - p = chunk_at_offset(p, -((long) prevsize));
> - unlink(p, bck, fwd);
> - }
> -
> - if (nextchunk != av->top) {
> - /* get and clear inuse bit */
> - nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
> -
> - /* consolidate forward */
> - if (!nextinuse) {
> - unlink(nextchunk, bck, fwd);
> - size += nextsize;
> - } else
> - clear_inuse_bit_at_offset(nextchunk, 0);
> + locked = 1;
> + }
> +
> + nextchunk = chunk_at_offset (p, size);
> +
> + /* Lightweight tests: check whether the block is already the
> + top block. */
> + if (__builtin_expect (p == av->top, 0))
> + {
> + errstr = "double free or corruption (top)";
> + goto errout;
> + }
> + /* Or whether the next chunk is beyond the boundaries of the arena. */
> + if (__builtin_expect (contiguous (av)
> + && (char *) nextchunk
> + >= ((char *) av->top + chunksize (av->top)), 0))
> + {
> + errstr = "double free or corruption (out)";
> + goto errout;
> + }
> + /* Or whether the block is actually not marked used. */
> + if (__builtin_expect (!prev_inuse (nextchunk), 0))
> + {
> + errstr = "double free or corruption (!prev)";
> + goto errout;
> + }
> +
> + nextsize = chunksize (nextchunk);
> + if (__builtin_expect (nextchunk->size <= 2 * SIZE_SZ, 0)
> + || __builtin_expect (nextsize >= av->system_mem, 0))
> + {
> + errstr = "free(): invalid next size (normal)";
> + goto errout;
> + }
> +
> + free_perturb (chunk2mem (p), size - 2 * SIZE_SZ);
> +
> + /* consolidate backward */
> + if (!prev_inuse (p))
> + {
> + prevsize = p->prev_size;
> + size += prevsize;
> + p = chunk_at_offset (p, -((long) prevsize));
> + unlink (p, bck, fwd);
> + }
> +
> + if (nextchunk != av->top)
> + {
> + /* get and clear inuse bit */
> + nextinuse = inuse_bit_at_offset (nextchunk, nextsize);
> +
> + /* consolidate forward */
> + if (!nextinuse)
> + {
> + unlink (nextchunk, bck, fwd);
> + size += nextsize;
> + }
> + else
> + clear_inuse_bit_at_offset (nextchunk, 0);
> +
> + /*
> + Place the chunk in unsorted chunk list. Chunks are
> + not placed into regular bins until after they have
> + been given one chance to be used in malloc.
> + */
> +
> + bck = unsorted_chunks (av);
> + fwd = bck->fd;
> + if (__builtin_expect (fwd->bk != bck, 0))
> + {
> + errstr = "free(): corrupted unsorted chunks";
> + goto errout;
> + }
> + p->fd = fwd;
> + p->bk = bck;
> + if (!in_smallbin_range (size))
> + {
> + p->fd_nextsize = NULL;
> + p->bk_nextsize = NULL;
> + }
> + bck->fd = p;
> + fwd->bk = p;
> +
> + set_head (p, size | PREV_INUSE);
> + set_foot (p, size);
> +
> + check_free_chunk (av, p);
> + }
>
> /*
> - Place the chunk in unsorted chunk list. Chunks are
> - not placed into regular bins until after they have
> - been given one chance to be used in malloc.
> - */
> -
> - bck = unsorted_chunks(av);
> - fwd = bck->fd;
> - if (__builtin_expect (fwd->bk != bck, 0))
> - {
> - errstr = "free(): corrupted unsorted chunks";
> - goto errout;
> - }
> - p->fd = fwd;
> - p->bk = bck;
> - if (!in_smallbin_range(size))
> - {
> - p->fd_nextsize = NULL;
> - p->bk_nextsize = NULL;
> - }
> - bck->fd = p;
> - fwd->bk = p;
> -
> - set_head(p, size | PREV_INUSE);
> - set_foot(p, size);
> -
> - check_free_chunk(av, p);
> - }
> -
> - /*
> - If the chunk borders the current high end of memory,
> - consolidate into top
> - */
> -
> - else {
> - size += nextsize;
> - set_head(p, size | PREV_INUSE);
> - av->top = p;
> - check_chunk(av, p);
> - }
> -
> - /*
> - If freeing a large space, consolidate possibly-surrounding
> - chunks. Then, if the total unused topmost memory exceeds trim
> - threshold, ask malloc_trim to reduce top.
> + If the chunk borders the current high end of memory,
> + consolidate into top
> + */
>
> - Unless max_fast is 0, we don't know if there are fastbins
> - bordering top, so we cannot tell for sure whether threshold
> - has been reached unless fastbins are consolidated. But we
> - don't want to consolidate on each free. As a compromise,
> - consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
> - is reached.
> - */
> -
> - if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) {
> - if (have_fastchunks(av))
> - malloc_consolidate(av);
> + else
> + {
> + size += nextsize;
> + set_head (p, size | PREV_INUSE);
> + av->top = p;
> + check_chunk (av, p);
> + }
>
> - if (av == &main_arena) {
> + /*
> + If freeing a large space, consolidate possibly-surrounding
> + chunks. Then, if the total unused topmost memory exceeds trim
> + threshold, ask malloc_trim to reduce top.
> +
> + Unless max_fast is 0, we don't know if there are fastbins
> + bordering top, so we cannot tell for sure whether threshold
> + has been reached unless fastbins are consolidated. But we
> + don't want to consolidate on each free. As a compromise,
> + consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD
> + is reached.
> + */
> +
> + if ((unsigned long) (size) >= FASTBIN_CONSOLIDATION_THRESHOLD)
> + {
> + if (have_fastchunks (av))
> + malloc_consolidate (av);
> +
> + if (av == &main_arena)
> + {
> #ifndef MORECORE_CANNOT_TRIM
> - if ((unsigned long)(chunksize(av->top)) >=
> - (unsigned long)(mp_.trim_threshold))
> - systrim(mp_.top_pad, av);
> + if ((unsigned long) (chunksize (av->top)) >=
> + (unsigned long) (mp_.trim_threshold))
> + systrim (mp_.top_pad, av);
> #endif
> - } else {
> - /* Always try heap_trim(), even if the top chunk is not
> - large, because the corresponding heap might go away. */
> - heap_info *heap = heap_for_ptr(top(av));
> -
> - assert(heap->ar_ptr == av);
> - heap_trim(heap, mp_.top_pad);
> - }
> - }
> -
> - if (! have_lock) {
> - assert (locked);
> - (void)mutex_unlock(&av->mutex);
> + }
> + else
> + {
> + /* Always try heap_trim(), even if the top chunk is not
> + large, because the corresponding heap might go away. */
> + heap_info *heap = heap_for_ptr (top (av));
> +
> + assert (heap->ar_ptr == av);
> + heap_trim (heap, mp_.top_pad);
> + }
> + }
> +
> + if (!have_lock)
> + {
> + assert (locked);
> + (void) mutex_unlock (&av->mutex);
> + }
> }
> - }
> /*
> - If the chunk was allocated via mmap, release via munmap().
> - */
> + If the chunk was allocated via mmap, release via munmap().
> + */
>
> - else {
> - munmap_chunk (p);
> - }
> + else
> + {
> + munmap_chunk (p);
> + }
> }
>
> /*
> - ------------------------- malloc_consolidate -------------------------
> + ------------------------- malloc_consolidate -------------------------
>
> - malloc_consolidate is a specialized version of free() that tears
> - down chunks held in fastbins. Free itself cannot be used for this
> - purpose since, among other things, it might place chunks back onto
> - fastbins. So, instead, we need to use a minor variant of the same
> - code.
> + malloc_consolidate is a specialized version of free() that tears
> + down chunks held in fastbins. Free itself cannot be used for this
> + purpose since, among other things, it might place chunks back onto
> + fastbins. So, instead, we need to use a minor variant of the same
> + code.
>
> - Also, because this routine needs to be called the first time through
> - malloc anyway, it turns out to be the perfect place to trigger
> - initialization code.
> -*/
> + Also, because this routine needs to be called the first time through
> + malloc anyway, it turns out to be the perfect place to trigger
> + initialization code.
> + */
>
> -static void malloc_consolidate(mstate av)
> +static void
> +malloc_consolidate (mstate av)
> {
> - mfastbinptr* fb; /* current fastbin being consolidated */
> - mfastbinptr* maxfb; /* last fastbin (for loop control) */
> - mchunkptr p; /* current chunk being consolidated */
> - mchunkptr nextp; /* next chunk to consolidate */
> - mchunkptr unsorted_bin; /* bin header */
> - mchunkptr first_unsorted; /* chunk to link to */
> + mfastbinptr *fb; /* current fastbin being consolidated */
> + mfastbinptr *maxfb; /* last fastbin (for loop control) */
> + mchunkptr p; /* current chunk being consolidated */
> + mchunkptr nextp; /* next chunk to consolidate */
> + mchunkptr unsorted_bin; /* bin header */
> + mchunkptr first_unsorted; /* chunk to link to */
>
> /* These have same use as in free() */
> - mchunkptr nextchunk;
> + mchunkptr nextchunk;
> INTERNAL_SIZE_T size;
> INTERNAL_SIZE_T nextsize;
> INTERNAL_SIZE_T prevsize;
> - int nextinuse;
> - mchunkptr bck;
> - mchunkptr fwd;
> + int nextinuse;
> + mchunkptr bck;
> + mchunkptr fwd;
>
> /*
> - If max_fast is 0, we know that av hasn't
> - yet been initialized, in which case do so below
> - */
> -
> - if (get_max_fast () != 0) {
> - clear_fastchunks(av);
> -
> - unsorted_bin = unsorted_chunks(av);
> -
> - /*
> - Remove each chunk from fast bin and consolidate it, placing it
> - then in unsorted bin. Among other reasons for doing this,
> - placing in unsorted bin avoids needing to calculate actual bins
> - until malloc is sure that chunks aren't immediately going to be
> - reused anyway.
> - */
> -
> - maxfb = &fastbin (av, NFASTBINS - 1);
> - fb = &fastbin (av, 0);
> - do {
> - p = atomic_exchange_acq (fb, 0);
> - if (p != 0) {
> - do {
> - check_inuse_chunk(av, p);
> - nextp = p->fd;
> -
> - /* Slightly streamlined version of consolidation code in free() */
> - size = p->size & ~(PREV_INUSE|NON_MAIN_ARENA);
> - nextchunk = chunk_at_offset(p, size);
> - nextsize = chunksize(nextchunk);
> -
> - if (!prev_inuse(p)) {
> - prevsize = p->prev_size;
> - size += prevsize;
> - p = chunk_at_offset(p, -((long) prevsize));
> - unlink(p, bck, fwd);
> - }
> -
> - if (nextchunk != av->top) {
> - nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
> -
> - if (!nextinuse) {
> - size += nextsize;
> - unlink(nextchunk, bck, fwd);
> - } else
> - clear_inuse_bit_at_offset(nextchunk, 0);
> -
> - first_unsorted = unsorted_bin->fd;
> - unsorted_bin->fd = p;
> - first_unsorted->bk = p;
> -
> - if (!in_smallbin_range (size)) {
> - p->fd_nextsize = NULL;
> - p->bk_nextsize = NULL;
> - }
> -
> - set_head(p, size | PREV_INUSE);
> - p->bk = unsorted_bin;
> - p->fd = first_unsorted;
> - set_foot(p, size);
> - }
> -
> - else {
> - size += nextsize;
> - set_head(p, size | PREV_INUSE);
> - av->top = p;
> - }
> -
> - } while ( (p = nextp) != 0);
> + If max_fast is 0, we know that av hasn't
> + yet been initialized, in which case do so below
> + */
>
> - }
> - } while (fb++ != maxfb);
> - }
> - else {
> - malloc_init_state(av);
> - check_malloc_state(av);
> - }
> + if (get_max_fast () != 0)
> + {
> + clear_fastchunks (av);
> +
> + unsorted_bin = unsorted_chunks (av);
> +
> + /*
> + Remove each chunk from fast bin and consolidate it, placing it
> + then in unsorted bin. Among other reasons for doing this,
> + placing in unsorted bin avoids needing to calculate actual bins
> + until malloc is sure that chunks aren't immediately going to be
> + reused anyway.
> + */
> +
> + maxfb = &fastbin (av, NFASTBINS - 1);
> + fb = &fastbin (av, 0);
> + do
> + {
> + p = atomic_exchange_acq (fb, 0);
> + if (p != 0)
> + {
> + do
> + {
> + check_inuse_chunk (av, p);
> + nextp = p->fd;
> +
> + /* Slightly streamlined version of consolidation code in free() */
> + size = p->size & ~(PREV_INUSE | NON_MAIN_ARENA);
> + nextchunk = chunk_at_offset (p, size);
> + nextsize = chunksize (nextchunk);
> +
> + if (!prev_inuse (p))
> + {
> + prevsize = p->prev_size;
> + size += prevsize;
> + p = chunk_at_offset (p, -((long) prevsize));
> + unlink (p, bck, fwd);
> + }
> +
> + if (nextchunk != av->top)
> + {
> + nextinuse = inuse_bit_at_offset (nextchunk, nextsize);
> +
> + if (!nextinuse)
> + {
> + size += nextsize;
> + unlink (nextchunk, bck, fwd);
> + }
> + else
> + clear_inuse_bit_at_offset (nextchunk, 0);
> +
> + first_unsorted = unsorted_bin->fd;
> + unsorted_bin->fd = p;
> + first_unsorted->bk = p;
> +
> + if (!in_smallbin_range (size))
> + {
> + p->fd_nextsize = NULL;
> + p->bk_nextsize = NULL;
> + }
> +
> + set_head (p, size | PREV_INUSE);
> + p->bk = unsorted_bin;
> + p->fd = first_unsorted;
> + set_foot (p, size);
> + }
> +
> + else
> + {
> + size += nextsize;
> + set_head (p, size | PREV_INUSE);
> + av->top = p;
> + }
> + }
> + while ((p = nextp) != 0);
> + }
> + }
> + while (fb++ != maxfb);
> + }
> + else
> + {
> + malloc_init_state (av);
> + check_malloc_state (av);
> + }
> }
>
> /*
> - ------------------------------ realloc ------------------------------
> -*/
> + ------------------------------ realloc ------------------------------
> + */
>
> -void*
> -_int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize,
> - INTERNAL_SIZE_T nb)
> +void *
> +_int_realloc (mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize,
> + INTERNAL_SIZE_T nb)
> {
> - mchunkptr newp; /* chunk to return */
> - INTERNAL_SIZE_T newsize; /* its size */
> - void* newmem; /* corresponding user mem */
> + mchunkptr newp; /* chunk to return */
> + INTERNAL_SIZE_T newsize; /* its size */
> + void *newmem; /* corresponding user mem */
>
> - mchunkptr next; /* next contiguous chunk after oldp */
> + mchunkptr next; /* next contiguous chunk after oldp */
>
> - mchunkptr remainder; /* extra space at end of newp */
> - unsigned long remainder_size; /* its size */
> + mchunkptr remainder; /* extra space at end of newp */
> + unsigned long remainder_size; /* its size */
>
> - mchunkptr bck; /* misc temp for linking */
> - mchunkptr fwd; /* misc temp for linking */
> + mchunkptr bck; /* misc temp for linking */
> + mchunkptr fwd; /* misc temp for linking */
>
> - unsigned long copysize; /* bytes to copy */
> - unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
> - INTERNAL_SIZE_T* s; /* copy source */
> - INTERNAL_SIZE_T* d; /* copy destination */
> + unsigned long copysize; /* bytes to copy */
> + unsigned int ncopies; /* INTERNAL_SIZE_T words to copy */
> + INTERNAL_SIZE_T *s; /* copy source */
> + INTERNAL_SIZE_T *d; /* copy destination */
>
> const char *errstr = NULL;
>
> @@ -4113,17 +4249,17 @@ _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize,
> {
> errstr = "realloc(): invalid old size";
> errout:
> - malloc_printerr (check_action, errstr, chunk2mem(oldp));
> + malloc_printerr (check_action, errstr, chunk2mem (oldp));
> return NULL;
> }
>
> - check_inuse_chunk(av, oldp);
> + check_inuse_chunk (av, oldp);
>
> /* All callers already filter out mmap'ed chunks. */
> - assert (!chunk_is_mmapped(oldp));
> + assert (!chunk_is_mmapped (oldp));
>
> - next = chunk_at_offset(oldp, oldsize);
> - INTERNAL_SIZE_T nextsize = chunksize(next);
> + next = chunk_at_offset (oldp, oldsize);
> + INTERNAL_SIZE_T nextsize = chunksize (next);
> if (__builtin_expect (next->size <= 2 * SIZE_SZ, 0)
> || __builtin_expect (nextsize >= av->system_mem, 0))
> {
> @@ -4131,216 +4267,233 @@ _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize,
> goto errout;
> }
>
> - if ((unsigned long)(oldsize) >= (unsigned long)(nb)) {
> - /* already big enough; split below */
> - newp = oldp;
> - newsize = oldsize;
> - }
> -
> - else {
> - /* Try to expand forward into top */
> - if (next == av->top &&
> - (unsigned long)(newsize = oldsize + nextsize) >=
> - (unsigned long)(nb + MINSIZE)) {
> - set_head_size(oldp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0));
> - av->top = chunk_at_offset(oldp, nb);
> - set_head(av->top, (newsize - nb) | PREV_INUSE);
> - check_inuse_chunk(av, oldp);
> - return chunk2mem(oldp);
> - }
> -
> - /* Try to expand forward into next chunk; split off remainder below */
> - else if (next != av->top &&
> - !inuse(next) &&
> - (unsigned long)(newsize = oldsize + nextsize) >=
> - (unsigned long)(nb)) {
> + if ((unsigned long) (oldsize) >= (unsigned long) (nb))
> + {
> + /* already big enough; split below */
> newp = oldp;
> - unlink(next, bck, fwd);
> + newsize = oldsize;
> }
>
> - /* allocate, copy, free */
> - else {
> - newmem = _int_malloc(av, nb - MALLOC_ALIGN_MASK);
> - if (newmem == 0)
> - return 0; /* propagate failure */
> -
> - newp = mem2chunk(newmem);
> - newsize = chunksize(newp);
> -
> - /*
> - Avoid copy if newp is next chunk after oldp.
> - */
> - if (newp == next) {
> - newsize += oldsize;
> - newp = oldp;
> - }
> - else {
> - /*
> - Unroll copy of <= 36 bytes (72 if 8byte sizes)
> - We know that contents have an odd number of
> - INTERNAL_SIZE_T-sized words; minimally 3.
> - */
> -
> - copysize = oldsize - SIZE_SZ;
> - s = (INTERNAL_SIZE_T*)(chunk2mem(oldp));
> - d = (INTERNAL_SIZE_T*)(newmem);
> - ncopies = copysize / sizeof(INTERNAL_SIZE_T);
> - assert(ncopies >= 3);
> -
> - if (ncopies > 9)
> - memcpy(d, s, copysize);
> -
> - else {
> - *(d+0) = *(s+0);
> - *(d+1) = *(s+1);
> - *(d+2) = *(s+2);
> - if (ncopies > 4) {
> - *(d+3) = *(s+3);
> - *(d+4) = *(s+4);
> - if (ncopies > 6) {
> - *(d+5) = *(s+5);
> - *(d+6) = *(s+6);
> - if (ncopies > 8) {
> - *(d+7) = *(s+7);
> - *(d+8) = *(s+8);
> - }
> - }
> - }
> - }
> -
> - _int_free(av, oldp, 1);
> - check_inuse_chunk(av, newp);
> - return chunk2mem(newp);
> - }
> + else
> + {
> + /* Try to expand forward into top */
> + if (next == av->top &&
> + (unsigned long) (newsize = oldsize + nextsize) >=
> + (unsigned long) (nb + MINSIZE))
> + {
> + set_head_size (oldp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0));
> + av->top = chunk_at_offset (oldp, nb);
> + set_head (av->top, (newsize - nb) | PREV_INUSE);
> + check_inuse_chunk (av, oldp);
> + return chunk2mem (oldp);
> + }
> +
> + /* Try to expand forward into next chunk; split off remainder below */
> + else if (next != av->top &&
> + !inuse (next) &&
> + (unsigned long) (newsize = oldsize + nextsize) >=
> + (unsigned long) (nb))
> + {
> + newp = oldp;
> + unlink (next, bck, fwd);
> + }
> +
> + /* allocate, copy, free */
> + else
> + {
> + newmem = _int_malloc (av, nb - MALLOC_ALIGN_MASK);
> + if (newmem == 0)
> + return 0; /* propagate failure */
> +
> + newp = mem2chunk (newmem);
> + newsize = chunksize (newp);
> +
> + /*
> + Avoid copy if newp is next chunk after oldp.
> + */
> + if (newp == next)
> + {
> + newsize += oldsize;
> + newp = oldp;
> + }
> + else
> + {
> + /*
> + Unroll copy of <= 36 bytes (72 if 8byte sizes)
> + We know that contents have an odd number of
> + INTERNAL_SIZE_T-sized words; minimally 3.
> + */
> +
> + copysize = oldsize - SIZE_SZ;
> + s = (INTERNAL_SIZE_T *) (chunk2mem (oldp));
> + d = (INTERNAL_SIZE_T *) (newmem);
> + ncopies = copysize / sizeof (INTERNAL_SIZE_T);
> + assert (ncopies >= 3);
> +
> + if (ncopies > 9)
> + memcpy (d, s, copysize);
> +
> + else
> + {
> + *(d + 0) = *(s + 0);
> + *(d + 1) = *(s + 1);
> + *(d + 2) = *(s + 2);
> + if (ncopies > 4)
> + {
> + *(d + 3) = *(s + 3);
> + *(d + 4) = *(s + 4);
> + if (ncopies > 6)
> + {
> + *(d + 5) = *(s + 5);
> + *(d + 6) = *(s + 6);
> + if (ncopies > 8)
> + {
> + *(d + 7) = *(s + 7);
> + *(d + 8) = *(s + 8);
> + }
> + }
> + }
> + }
> +
> + _int_free (av, oldp, 1);
> + check_inuse_chunk (av, newp);
> + return chunk2mem (newp);
> + }
> + }
> }
> - }
>
> /* If possible, free extra space in old or extended chunk */
>
> - assert((unsigned long)(newsize) >= (unsigned long)(nb));
> + assert ((unsigned long) (newsize) >= (unsigned long) (nb));
>
> remainder_size = newsize - nb;
>
> - if (remainder_size < MINSIZE) { /* not enough extra to split off */
> - set_head_size(newp, newsize | (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_inuse_bit_at_offset(newp, newsize);
> - }
> - else { /* split remainder */
> - remainder = chunk_at_offset(newp, nb);
> - set_head_size(newp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_head(remainder, remainder_size | PREV_INUSE |
> - (av != &main_arena ? NON_MAIN_ARENA : 0));
> - /* Mark remainder as inuse so free() won't complain */
> - set_inuse_bit_at_offset(remainder, remainder_size);
> - _int_free(av, remainder, 1);
> - }
> + if (remainder_size < MINSIZE) /* not enough extra to split off */
> + {
> + set_head_size (newp, newsize | (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_inuse_bit_at_offset (newp, newsize);
> + }
> + else /* split remainder */
> + {
> + remainder = chunk_at_offset (newp, nb);
> + set_head_size (newp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_head (remainder, remainder_size | PREV_INUSE |
> + (av != &main_arena ? NON_MAIN_ARENA : 0));
> + /* Mark remainder as inuse so free() won't complain */
> + set_inuse_bit_at_offset (remainder, remainder_size);
> + _int_free (av, remainder, 1);
> + }
>
> - check_inuse_chunk(av, newp);
> - return chunk2mem(newp);
> + check_inuse_chunk (av, newp);
> + return chunk2mem (newp);
> }
>
> /*
> - ------------------------------ memalign ------------------------------
> -*/
> + ------------------------------ memalign ------------------------------
> + */
>
> -static void*
> -_int_memalign(mstate av, size_t alignment, size_t bytes)
> +static void *
> +_int_memalign (mstate av, size_t alignment, size_t bytes)
> {
> INTERNAL_SIZE_T nb; /* padded request size */
> - char* m; /* memory returned by malloc call */
> - mchunkptr p; /* corresponding chunk */
> - char* brk; /* alignment point within p */
> - mchunkptr newp; /* chunk to return */
> + char *m; /* memory returned by malloc call */
> + mchunkptr p; /* corresponding chunk */
> + char *brk; /* alignment point within p */
> + mchunkptr newp; /* chunk to return */
> INTERNAL_SIZE_T newsize; /* its size */
> INTERNAL_SIZE_T leadsize; /* leading space before alignment point */
> - mchunkptr remainder; /* spare room at end to split off */
> - unsigned long remainder_size; /* its size */
> + mchunkptr remainder; /* spare room at end to split off */
> + unsigned long remainder_size; /* its size */
> INTERNAL_SIZE_T size;
>
>
>
> - checked_request2size(bytes, nb);
> + checked_request2size (bytes, nb);
>
> /*
> - Strategy: find a spot within that chunk that meets the alignment
> - request, and then possibly free the leading and trailing space.
> - */
> + Strategy: find a spot within that chunk that meets the alignment
> + request, and then possibly free the leading and trailing space.
> + */
>
>
> /* Call malloc with worst case padding to hit alignment. */
>
> - m = (char*)(_int_malloc(av, nb + alignment + MINSIZE));
> -
> - if (m == 0) return 0; /* propagate failure */
> -
> - p = mem2chunk(m);
> -
> - if ((((unsigned long)(m)) % alignment) != 0) { /* misaligned */
> -
> - /*
> - Find an aligned spot inside chunk. Since we need to give back
> - leading space in a chunk of at least MINSIZE, if the first
> - calculation places us at a spot with less than MINSIZE leader,
> - we can move to the next aligned spot -- we've allocated enough
> - total room so that this is always possible.
> - */
> -
> - brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) &
> - -((signed long) alignment));
> - if ((unsigned long)(brk - (char*)(p)) < MINSIZE)
> - brk += alignment;
> -
> - newp = (mchunkptr)brk;
> - leadsize = brk - (char*)(p);
> - newsize = chunksize(p) - leadsize;
> -
> - /* For mmapped chunks, just adjust offset */
> - if (chunk_is_mmapped(p)) {
> - newp->prev_size = p->prev_size + leadsize;
> - set_head(newp, newsize|IS_MMAPPED);
> - return chunk2mem(newp);
> + m = (char *) (_int_malloc (av, nb + alignment + MINSIZE));
> +
> + if (m == 0)
> + return 0; /* propagate failure */
> +
> + p = mem2chunk (m);
> +
> + if ((((unsigned long) (m)) % alignment) != 0) /* misaligned */
> +
> + { /*
> + Find an aligned spot inside chunk. Since we need to give back
> + leading space in a chunk of at least MINSIZE, if the first
> + calculation places us at a spot with less than MINSIZE leader,
> + we can move to the next aligned spot -- we've allocated enough
> + total room so that this is always possible.
> + */
> + brk = (char *) mem2chunk (((unsigned long) (m + alignment - 1)) &
> + - ((signed long) alignment));
> + if ((unsigned long) (brk - (char *) (p)) < MINSIZE)
> + brk += alignment;
> +
> + newp = (mchunkptr) brk;
> + leadsize = brk - (char *) (p);
> + newsize = chunksize (p) - leadsize;
> +
> + /* For mmapped chunks, just adjust offset */
> + if (chunk_is_mmapped (p))
> + {
> + newp->prev_size = p->prev_size + leadsize;
> + set_head (newp, newsize | IS_MMAPPED);
> + return chunk2mem (newp);
> + }
> +
> + /* Otherwise, give back leader, use the rest */
> + set_head (newp, newsize | PREV_INUSE |
> + (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_inuse_bit_at_offset (newp, newsize);
> + set_head_size (p, leadsize | (av != &main_arena ? NON_MAIN_ARENA : 0));
> + _int_free (av, p, 1);
> + p = newp;
> +
> + assert (newsize >= nb &&
> + (((unsigned long) (chunk2mem (p))) % alignment) == 0);
> }
>
> - /* Otherwise, give back leader, use the rest */
> - set_head(newp, newsize | PREV_INUSE |
> - (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_inuse_bit_at_offset(newp, newsize);
> - set_head_size(p, leadsize | (av != &main_arena ? NON_MAIN_ARENA : 0));
> - _int_free(av, p, 1);
> - p = newp;
> -
> - assert (newsize >= nb &&
> - (((unsigned long)(chunk2mem(p))) % alignment) == 0);
> - }
> -
> /* Also give back spare room at the end */
> - if (!chunk_is_mmapped(p)) {
> - size = chunksize(p);
> - if ((unsigned long)(size) > (unsigned long)(nb + MINSIZE)) {
> - remainder_size = size - nb;
> - remainder = chunk_at_offset(p, nb);
> - set_head(remainder, remainder_size | PREV_INUSE |
> - (av != &main_arena ? NON_MAIN_ARENA : 0));
> - set_head_size(p, nb);
> - _int_free(av, remainder, 1);
> + if (!chunk_is_mmapped (p))
> + {
> + size = chunksize (p);
> + if ((unsigned long) (size) > (unsigned long) (nb + MINSIZE))
> + {
> + remainder_size = size - nb;
> + remainder = chunk_at_offset (p, nb);
> + set_head (remainder, remainder_size | PREV_INUSE |
> + (av != &main_arena ? NON_MAIN_ARENA : 0));
> + set_head_size (p, nb);
> + _int_free (av, remainder, 1);
> + }
> }
> - }
>
> - check_inuse_chunk(av, p);
> - return chunk2mem(p);
> + check_inuse_chunk (av, p);
> + return chunk2mem (p);
> }
>
>
> /*
> - ------------------------------ malloc_trim ------------------------------
> -*/
> + ------------------------------ malloc_trim ------------------------------
> + */
>
> -static int mtrim(mstate av, size_t pad)
> +static int
> +mtrim (mstate av, size_t pad)
> {
> /* Ensure initialization/consolidation */
> malloc_consolidate (av);
>
> - const size_t ps = GLRO(dl_pagesize);
> + const size_t ps = GLRO (dl_pagesize);
> int psindex = bin_index (ps);
> const size_t psm1 = ps - 1;
>
> @@ -4348,42 +4501,43 @@ static int mtrim(mstate av, size_t pad)
> for (int i = 1; i < NBINS; ++i)
> if (i == 1 || i >= psindex)
> {
> - mbinptr bin = bin_at (av, i);
> + mbinptr bin = bin_at (av, i);
>
> - for (mchunkptr p = last (bin); p != bin; p = p->bk)
> - {
> - INTERNAL_SIZE_T size = chunksize (p);
> + for (mchunkptr p = last (bin); p != bin; p = p->bk)
> + {
> + INTERNAL_SIZE_T size = chunksize (p);
>
> - if (size > psm1 + sizeof (struct malloc_chunk))
> - {
> - /* See whether the chunk contains at least one unused page. */
> - char *paligned_mem = (char *) (((uintptr_t) p
> - + sizeof (struct malloc_chunk)
> - + psm1) & ~psm1);
> + if (size > psm1 + sizeof (struct malloc_chunk))
> + {
> + /* See whether the chunk contains at least one unused page. */
> + char *paligned_mem = (char *) (((uintptr_t) p
> + + sizeof (struct malloc_chunk)
> + + psm1) & ~psm1);
>
> - assert ((char *) chunk2mem (p) + 4 * SIZE_SZ <= paligned_mem);
> - assert ((char *) p + size > paligned_mem);
> + assert ((char *) chunk2mem (p) + 4 * SIZE_SZ <= paligned_mem);
> + assert ((char *) p + size > paligned_mem);
>
> - /* This is the size we could potentially free. */
> - size -= paligned_mem - (char *) p;
> + /* This is the size we could potentially free. */
> + size -= paligned_mem - (char *) p;
>
> - if (size > psm1)
> - {
> + if (size > psm1)
> + {
> #ifdef MALLOC_DEBUG
> - /* When debugging we simulate destroying the memory
> - content. */
> - memset (paligned_mem, 0x89, size & ~psm1);
> + /* When debugging we simulate destroying the memory
> + content. */
> + memset (paligned_mem, 0x89, size & ~psm1);
> #endif
> - __madvise (paligned_mem, size & ~psm1, MADV_DONTNEED);
> + __madvise (paligned_mem, size & ~psm1, MADV_DONTNEED);
>
> - result = 1;
> - }
> - }
> - }
> + result = 1;
> + }
> + }
> + }
> }
>
> #ifndef MORECORE_CANNOT_TRIM
> return result | (av == &main_arena ? systrim (pad, av) : 0);
> +
> #else
> return result;
> #endif
> @@ -4391,11 +4545,11 @@ static int mtrim(mstate av, size_t pad)
>
>
> int
> -__malloc_trim(size_t s)
> +__malloc_trim (size_t s)
> {
> int result = 0;
>
> - if(__malloc_initialized < 0)
> + if (__malloc_initialized < 0)
> ptmalloc_init ();
>
> mstate ar_ptr = &main_arena;
> @@ -4414,43 +4568,45 @@ __malloc_trim(size_t s)
>
>
> /*
> - ------------------------- malloc_usable_size -------------------------
> -*/
> + ------------------------- malloc_usable_size -------------------------
> + */
>
> static size_t
> -musable(void* mem)
> +musable (void *mem)
> {
> mchunkptr p;
> - if (mem != 0) {
> - p = mem2chunk(mem);
> -
> - if (__builtin_expect(using_malloc_checking == 1, 0))
> - return malloc_check_get_size(p);
> - if (chunk_is_mmapped(p))
> - return chunksize(p) - 2*SIZE_SZ;
> - else if (inuse(p))
> - return chunksize(p) - SIZE_SZ;
> - }
> + if (mem != 0)
> + {
> + p = mem2chunk (mem);
> +
> + if (__builtin_expect (using_malloc_checking == 1, 0))
> + return malloc_check_get_size (p);
> +
> + if (chunk_is_mmapped (p))
> + return chunksize (p) - 2 * SIZE_SZ;
> + else if (inuse (p))
> + return chunksize (p) - SIZE_SZ;
> + }
> return 0;
> }
>
>
> size_t
> -__malloc_usable_size(void* m)
> +__malloc_usable_size (void *m)
> {
> size_t result;
>
> - result = musable(m);
> + result = musable (m);
> return result;
> }
>
> /*
> - ------------------------------ mallinfo ------------------------------
> - Accumulate malloc statistics for arena AV into M.
> -*/
> + ------------------------------ mallinfo ------------------------------
> + Accumulate malloc statistics for arena AV into M.
> + */
>
> static void
> -int_mallinfo(mstate av, struct mallinfo *m)
> +int_mallinfo (mstate av, struct mallinfo *m)
> {
> size_t i;
> mbinptr b;
> @@ -4461,35 +4617,40 @@ int_mallinfo(mstate av, struct mallinfo *m)
> int nfastblocks;
>
> /* Ensure initialization */
> - if (av->top == 0) malloc_consolidate(av);
> + if (av->top == 0)
> + malloc_consolidate (av);
>
> - check_malloc_state(av);
> + check_malloc_state (av);
>
> /* Account for top */
> - avail = chunksize(av->top);
> + avail = chunksize (av->top);
> nblocks = 1; /* top always exists */
>
> /* traverse fastbins */
> nfastblocks = 0;
> fastavail = 0;
>
> - for (i = 0; i < NFASTBINS; ++i) {
> - for (p = fastbin (av, i); p != 0; p = p->fd) {
> - ++nfastblocks;
> - fastavail += chunksize(p);
> + for (i = 0; i < NFASTBINS; ++i)
> + {
> + for (p = fastbin (av, i); p != 0; p = p->fd)
> + {
> + ++nfastblocks;
> + fastavail += chunksize (p);
> + }
> }
> - }
>
> avail += fastavail;
>
> /* traverse regular bins */
> - for (i = 1; i < NBINS; ++i) {
> - b = bin_at(av, i);
> - for (p = last(b); p != b; p = p->bk) {
> - ++nblocks;
> - avail += chunksize(p);
> + for (i = 1; i < NBINS; ++i)
> + {
> + b = bin_at (av, i);
> + for (p = last (b); p != b; p = p->bk)
> + {
> + ++nblocks;
> + avail += chunksize (p);
> + }
> }
> - }
>
> m->smblks += nfastblocks;
> m->ordblks += nblocks;
> @@ -4502,35 +4663,38 @@ int_mallinfo(mstate av, struct mallinfo *m)
> m->hblks = mp_.n_mmaps;
> m->hblkhd = mp_.mmapped_mem;
> m->usmblks = mp_.max_total_mem;
> - m->keepcost = chunksize(av->top);
> + m->keepcost = chunksize (av->top);
> }
> }
>
>
> -struct mallinfo __libc_mallinfo()
> +struct mallinfo
> +__libc_mallinfo ()
> {
> struct mallinfo m;
> mstate ar_ptr;
>
> - if(__malloc_initialized < 0)
> + if (__malloc_initialized < 0)
> ptmalloc_init ();
>
> - memset(&m, 0, sizeof (m));
> + memset (&m, 0, sizeof (m));
> ar_ptr = &main_arena;
> - do {
> - (void)mutex_lock(&ar_ptr->mutex);
> - int_mallinfo(ar_ptr, &m);
> - (void)mutex_unlock(&ar_ptr->mutex);
> + do
> + {
> + (void) mutex_lock (&ar_ptr->mutex);
> + int_mallinfo (ar_ptr, &m);
> + (void) mutex_unlock (&ar_ptr->mutex);
>
> - ar_ptr = ar_ptr->next;
> - } while (ar_ptr != &main_arena);
> + ar_ptr = ar_ptr->next;
> + }
> + while (ar_ptr != &main_arena);
>
> return m;
> }
>
> /*
> - ------------------------------ malloc_stats ------------------------------
> -*/
> + ------------------------------ malloc_stats ------------------------------
> + */
>
> void
> __malloc_stats (void)
> @@ -4542,48 +4706,50 @@ __malloc_stats (void)
> long stat_lock_direct = 0, stat_lock_loop = 0, stat_lock_wait = 0;
> #endif
>
> - if(__malloc_initialized < 0)
> + if (__malloc_initialized < 0)
> ptmalloc_init ();
> _IO_flockfile (stderr);
> int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
> ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
> - for (i=0, ar_ptr = &main_arena;; i++) {
> - struct mallinfo mi;
> -
> - memset(&mi, 0, sizeof(mi));
> - (void)mutex_lock(&ar_ptr->mutex);
> - int_mallinfo(ar_ptr, &mi);
> - 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);
> + for (i = 0, ar_ptr = &main_arena;; i++)
> + {
> + struct mallinfo mi;
> +
> + memset (&mi, 0, sizeof (mi));
> + (void) mutex_lock (&ar_ptr->mutex);
> + int_mallinfo (ar_ptr, &mi);
> + 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);
> #if MALLOC_DEBUG > 1
> - if (i > 0)
> - dump_heap(heap_for_ptr(top(ar_ptr)));
> + if (i > 0)
> + dump_heap (heap_for_ptr (top (ar_ptr)));
> #endif
> - system_b += mi.arena;
> - in_use_b += mi.uordblks;
> + system_b += mi.arena;
> + in_use_b += mi.uordblks;
> #if THREAD_STATS
> - stat_lock_direct += ar_ptr->stat_lock_direct;
> - stat_lock_loop += ar_ptr->stat_lock_loop;
> - stat_lock_wait += ar_ptr->stat_lock_wait;
> + stat_lock_direct += ar_ptr->stat_lock_direct;
> + stat_lock_loop += ar_ptr->stat_lock_loop;
> + stat_lock_wait += ar_ptr->stat_lock_wait;
> #endif
> - (void)mutex_unlock(&ar_ptr->mutex);
> - ar_ptr = ar_ptr->next;
> - if(ar_ptr == &main_arena) break;
> - }
> - fprintf(stderr, "Total (incl. mmap):\n");
> - fprintf(stderr, "system bytes = %10u\n", system_b);
> - fprintf(stderr, "in use bytes = %10u\n", in_use_b);
> - fprintf(stderr, "max mmap regions = %10u\n", (unsigned int)mp_.max_n_mmaps);
> - fprintf(stderr, "max mmap bytes = %10lu\n",
> - (unsigned long)mp_.max_mmapped_mem);
> + (void) mutex_unlock (&ar_ptr->mutex);
> + ar_ptr = ar_ptr->next;
> + if (ar_ptr == &main_arena)
> + break;
> + }
> + fprintf (stderr, "Total (incl. mmap):\n");
> + fprintf (stderr, "system bytes = %10u\n", system_b);
> + fprintf (stderr, "in use bytes = %10u\n", in_use_b);
> + fprintf (stderr, "max mmap regions = %10u\n", (unsigned int) mp_.max_n_mmaps);
> + fprintf (stderr, "max mmap bytes = %10lu\n",
> + (unsigned long) mp_.max_mmapped_mem);
> #if THREAD_STATS
> - fprintf(stderr, "heaps created = %10d\n", stat_n_heaps);
> - fprintf(stderr, "locked directly = %10ld\n", stat_lock_direct);
> - fprintf(stderr, "locked in loop = %10ld\n", stat_lock_loop);
> - fprintf(stderr, "locked waiting = %10ld\n", stat_lock_wait);
> - fprintf(stderr, "locked total = %10ld\n",
> - stat_lock_direct + stat_lock_loop + stat_lock_wait);
> + fprintf (stderr, "heaps created = %10d\n", stat_n_heaps);
> + fprintf (stderr, "locked directly = %10ld\n", stat_lock_direct);
> + fprintf (stderr, "locked in loop = %10ld\n", stat_lock_loop);
> + fprintf (stderr, "locked waiting = %10ld\n", stat_lock_wait);
> + fprintf (stderr, "locked total = %10ld\n",
> + stat_lock_direct + stat_lock_loop + stat_lock_wait);
> #endif
> ((_IO_FILE *) stderr)->_flags2 |= old_flags2;
> _IO_funlockfile (stderr);
> @@ -4591,201 +4757,203 @@ __malloc_stats (void)
>
>
> /*
> - ------------------------------ mallopt ------------------------------
> -*/
> + ------------------------------ mallopt ------------------------------
> + */
>
> -int __libc_mallopt(int param_number, int value)
> +int
> +__libc_mallopt (int param_number, int value)
> {
> mstate av = &main_arena;
> int res = 1;
>
> - if(__malloc_initialized < 0)
> + if (__malloc_initialized < 0)
> ptmalloc_init ();
> - (void)mutex_lock(&av->mutex);
> + (void) mutex_lock (&av->mutex);
> /* Ensure initialization/consolidation */
> - malloc_consolidate(av);
> + malloc_consolidate (av);
>
> LIBC_PROBE (memory_mallopt, 2, param_number, value);
>
> - switch(param_number) {
> - case M_MXFAST:
> - if (value >= 0 && value <= MAX_FAST_SIZE)
> - {
> - LIBC_PROBE (memory_mallopt_mxfast, 2, value, get_max_fast ());
> - set_max_fast(value);
> - }
> - else
> - res = 0;
> - break;
> -
> - case M_TRIM_THRESHOLD:
> - LIBC_PROBE (memory_mallopt_trim_threshold, 3, value,
> - mp_.trim_threshold, mp_.no_dyn_threshold);
> - mp_.trim_threshold = value;
> - mp_.no_dyn_threshold = 1;
> - break;
> -
> - case M_TOP_PAD:
> - LIBC_PROBE (memory_mallopt_top_pad, 3, value,
> - mp_.top_pad, mp_.no_dyn_threshold);
> - mp_.top_pad = value;
> - mp_.no_dyn_threshold = 1;
> - break;
> -
> - case M_MMAP_THRESHOLD:
> - /* Forbid setting the threshold too high. */
> - if((unsigned long)value > HEAP_MAX_SIZE/2)
> - res = 0;
> - else
> - {
> - LIBC_PROBE (memory_mallopt_mmap_threshold, 3, value,
> - mp_.mmap_threshold, mp_.no_dyn_threshold);
> - mp_.mmap_threshold = value;
> - mp_.no_dyn_threshold = 1;
> - }
> - break;
> -
> - case M_MMAP_MAX:
> - LIBC_PROBE (memory_mallopt_mmap_max, 3, value,
> - mp_.n_mmaps_max, mp_.no_dyn_threshold);
> - mp_.n_mmaps_max = value;
> - mp_.no_dyn_threshold = 1;
> - break;
> -
> - case M_CHECK_ACTION:
> - LIBC_PROBE (memory_mallopt_check_action, 2, value, check_action);
> - check_action = value;
> - break;
> -
> - case M_PERTURB:
> - LIBC_PROBE (memory_mallopt_perturb, 2, value, perturb_byte);
> - perturb_byte = value;
> - break;
> -
> - case M_ARENA_TEST:
> - if (value > 0)
> - {
> - LIBC_PROBE (memory_mallopt_arena_test, 2, value, mp_.arena_test);
> - mp_.arena_test = value;
> - }
> - break;
> -
> - case M_ARENA_MAX:
> - if (value > 0)
> - {
> - LIBC_PROBE (memory_mallopt_arena_max, 2, value, mp_.arena_max);
> - mp_.arena_max = value;
> - }
> - break;
> - }
> - (void)mutex_unlock(&av->mutex);
> + switch (param_number)
> + {
> + case M_MXFAST:
> + if (value >= 0 && value <= MAX_FAST_SIZE)
> + {
> + LIBC_PROBE (memory_mallopt_mxfast, 2, value, get_max_fast ());
> + set_max_fast (value);
> + }
> + else
> + res = 0;
> + break;
> +
> + case M_TRIM_THRESHOLD:
> + LIBC_PROBE (memory_mallopt_trim_threshold, 3, value,
> + mp_.trim_threshold, mp_.no_dyn_threshold);
> + mp_.trim_threshold = value;
> + mp_.no_dyn_threshold = 1;
> + break;
> +
> + case M_TOP_PAD:
> + LIBC_PROBE (memory_mallopt_top_pad, 3, value,
> + mp_.top_pad, mp_.no_dyn_threshold);
> + mp_.top_pad = value;
> + mp_.no_dyn_threshold = 1;
> + break;
> +
> + case M_MMAP_THRESHOLD:
> + /* Forbid setting the threshold too high. */
> + if ((unsigned long) value > HEAP_MAX_SIZE / 2)
> + res = 0;
> + else
> + {
> + LIBC_PROBE (memory_mallopt_mmap_threshold, 3, value,
> + mp_.mmap_threshold, mp_.no_dyn_threshold);
> + mp_.mmap_threshold = value;
> + mp_.no_dyn_threshold = 1;
> + }
> + break;
> +
> + case M_MMAP_MAX:
> + LIBC_PROBE (memory_mallopt_mmap_max, 3, value,
> + mp_.n_mmaps_max, mp_.no_dyn_threshold);
> + mp_.n_mmaps_max = value;
> + mp_.no_dyn_threshold = 1;
> + break;
> +
> + case M_CHECK_ACTION:
> + LIBC_PROBE (memory_mallopt_check_action, 2, value, check_action);
> + check_action = value;
> + break;
> +
> + case M_PERTURB:
> + LIBC_PROBE (memory_mallopt_perturb, 2, value, perturb_byte);
> + perturb_byte = value;
> + break;
> +
> + case M_ARENA_TEST:
> + if (value > 0)
> + {
> + LIBC_PROBE (memory_mallopt_arena_test, 2, value, mp_.arena_test);
> + mp_.arena_test = value;
> + }
> + break;
> +
> + case M_ARENA_MAX:
> + if (value > 0)
> + {
> + LIBC_PROBE (memory_mallopt_arena_max, 2, value, mp_.arena_max);
> + mp_.arena_max = value;
> + }
> + break;
> + }
> + (void) mutex_unlock (&av->mutex);
> return res;
> }
> libc_hidden_def (__libc_mallopt)
>
>
> /*
> - -------------------- Alternative MORECORE functions --------------------
> -*/
> + -------------------- Alternative MORECORE functions --------------------
> + */
>
>
> /*
> - General Requirements for MORECORE.
> + General Requirements for MORECORE.
>
> - The MORECORE function must have the following properties:
> + The MORECORE function must have the following properties:
>
> - If MORECORE_CONTIGUOUS is false:
> + If MORECORE_CONTIGUOUS is false:
>
> - * MORECORE must allocate in multiples of pagesize. It will
> + * MORECORE must allocate in multiples of pagesize. It will
> only be called with arguments that are multiples of pagesize.
>
> - * MORECORE(0) must return an address that is at least
> + * MORECORE(0) must return an address that is at least
> MALLOC_ALIGNMENT aligned. (Page-aligning always suffices.)
>
> - else (i.e. If MORECORE_CONTIGUOUS is true):
> + else (i.e. If MORECORE_CONTIGUOUS is true):
>
> - * Consecutive calls to MORECORE with positive arguments
> + * Consecutive calls to MORECORE with positive arguments
> return increasing addresses, indicating that space has been
> contiguously extended.
>
> - * MORECORE need not allocate in multiples of pagesize.
> + * MORECORE need not allocate in multiples of pagesize.
> Calls to MORECORE need not have args of multiples of pagesize.
>
> - * MORECORE need not page-align.
> + * MORECORE need not page-align.
>
> - In either case:
> + In either case:
>
> - * MORECORE may allocate more memory than requested. (Or even less,
> + * MORECORE may allocate more memory than requested. (Or even less,
> but this will generally result in a malloc failure.)
>
> - * MORECORE must not allocate memory when given argument zero, but
> + * MORECORE must not allocate memory when given argument zero, but
> instead return one past the end address of memory from previous
> nonzero call. This malloc does NOT call MORECORE(0)
> until at least one call with positive arguments is made, so
> the initial value returned is not important.
>
> - * Even though consecutive calls to MORECORE need not return contiguous
> + * Even though consecutive calls to MORECORE need not return contiguous
> addresses, it must be OK for malloc'ed chunks to span multiple
> regions in those cases where they do happen to be contiguous.
>
> - * MORECORE need not handle negative arguments -- it may instead
> + * MORECORE need not handle negative arguments -- it may instead
> just return MORECORE_FAILURE when given negative arguments.
> Negative arguments are always multiples of pagesize. MORECORE
> must not misinterpret negative args as large positive unsigned
> args. You can suppress all such calls from even occurring by defining
> MORECORE_CANNOT_TRIM,
>
> - There is some variation across systems about the type of the
> - argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
> - actually be size_t, because sbrk supports negative args, so it is
> - normally the signed type of the same width as size_t (sometimes
> - declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much
> - matter though. Internally, we use "long" as arguments, which should
> - work across all reasonable possibilities.
> -
> - Additionally, if MORECORE ever returns failure for a positive
> - request, then mmap is used as a noncontiguous system allocator. This
> - is a useful backup strategy for systems with holes in address spaces
> - -- in this case sbrk cannot contiguously expand the heap, but mmap
> - may be able to map noncontiguous space.
> -
> - If you'd like mmap to ALWAYS be used, you can define MORECORE to be
> - a function that always returns MORECORE_FAILURE.
> -
> - If you are using this malloc with something other than sbrk (or its
> - emulation) to supply memory regions, you probably want to set
> - MORECORE_CONTIGUOUS as false. As an example, here is a custom
> - allocator kindly contributed for pre-OSX macOS. It uses virtually
> - but not necessarily physically contiguous non-paged memory (locked
> - in, present and won't get swapped out). You can use it by
> - uncommenting this section, adding some #includes, and setting up the
> - appropriate defines above:
> -
> - #define MORECORE osMoreCore
> - #define MORECORE_CONTIGUOUS 0
> -
> - There is also a shutdown routine that should somehow be called for
> - cleanup upon program exit.
> -
> - #define MAX_POOL_ENTRIES 100
> - #define MINIMUM_MORECORE_SIZE (64 * 1024)
> - static int next_os_pool;
> - void *our_os_pools[MAX_POOL_ENTRIES];
> -
> - void *osMoreCore(int size)
> - {
> + There is some variation across systems about the type of the
> + argument to sbrk/MORECORE. If size_t is unsigned, then it cannot
> + actually be size_t, because sbrk supports negative args, so it is
> + normally the signed type of the same width as size_t (sometimes
> + declared as "intptr_t", and sometimes "ptrdiff_t"). It doesn't much
> + matter though. Internally, we use "long" as arguments, which should
> + work across all reasonable possibilities.
> +
> + Additionally, if MORECORE ever returns failure for a positive
> + request, then mmap is used as a noncontiguous system allocator. This
> + is a useful backup strategy for systems with holes in address spaces
> + -- in this case sbrk cannot contiguously expand the heap, but mmap
> + may be able to map noncontiguous space.
> +
> + If you'd like mmap to ALWAYS be used, you can define MORECORE to be
> + a function that always returns MORECORE_FAILURE.
> +
> + If you are using this malloc with something other than sbrk (or its
> + emulation) to supply memory regions, you probably want to set
> + MORECORE_CONTIGUOUS as false. As an example, here is a custom
> + allocator kindly contributed for pre-OSX macOS. It uses virtually
> + but not necessarily physically contiguous non-paged memory (locked
> + in, present and won't get swapped out). You can use it by
> + uncommenting this section, adding some #includes, and setting up the
> + appropriate defines above:
> +
> + *#define MORECORE osMoreCore
> + *#define MORECORE_CONTIGUOUS 0
> +
> + There is also a shutdown routine that should somehow be called for
> + cleanup upon program exit.
> +
> + *#define MAX_POOL_ENTRIES 100
> + *#define MINIMUM_MORECORE_SIZE (64 * 1024)
> + static int next_os_pool;
> + void *our_os_pools[MAX_POOL_ENTRIES];
> +
> + void *osMoreCore(int size)
> + {
> void *ptr = 0;
> static void *sbrk_top = 0;
>
> if (size > 0)
> {
> if (size < MINIMUM_MORECORE_SIZE)
> - size = MINIMUM_MORECORE_SIZE;
> + size = MINIMUM_MORECORE_SIZE;
> if (CurrentExecutionLevel() == kTaskLevel)
> - ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
> + ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
> if (ptr == 0)
> {
> - return (void *) MORECORE_FAILURE;
> + return (void *) MORECORE_FAILURE;
> }
> // save ptrs so they can be freed during cleanup
> our_os_pools[next_os_pool] = ptr;
> @@ -4803,24 +4971,24 @@ libc_hidden_def (__libc_mallopt)
> {
> return sbrk_top;
> }
> - }
> + }
>
> - // cleanup any allocated memory pools
> - // called as last thing before shutting down driver
> + // cleanup any allocated memory pools
> + // called as last thing before shutting down driver
>
> - void osCleanupMem(void)
> - {
> + void osCleanupMem(void)
> + {
> void **ptr;
>
> for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
> if (*ptr)
> {
> - PoolDeallocate(*ptr);
> - *ptr = 0;
> + PoolDeallocate(*ptr);
> + * ptr = 0;
> }
> - }
> + }
>
> -*/
> + */
>
>
> /* Helper code. */
> @@ -4828,7 +4996,7 @@ libc_hidden_def (__libc_mallopt)
> extern char **__libc_argv attribute_hidden;
>
> static void
> -malloc_printerr(int action, const char *str, void *ptr)
> +malloc_printerr (int action, const char *str, void *ptr)
> {
> if ((action & 5) == 5)
> __libc_message (action & 2, "%s\n", str);
> @@ -4839,10 +5007,10 @@ malloc_printerr(int action, const char *str, void *ptr)
> buf[sizeof (buf) - 1] = '\0';
> char *cp = _itoa_word ((uintptr_t) ptr, &buf[sizeof (buf) - 1], 16, 0);
> while (cp > buf)
> - *--cp = '0';
> + *--cp = '0';
>
> __libc_message (action & 2, "*** Error in `%s': %s: 0x%s ***\n",
> - __libc_argv[0] ?: "<unknown>", str, cp);
> + __libc_argv[0] ? : "<unknown>", str, cp);
> }
> else if (action & 2)
> abort ();
> @@ -4865,10 +5033,11 @@ __posix_memalign (void **memptr, size_t alignment, size_t size)
> void *address = RETURN_ADDRESS (0);
> mem = _mid_memalign (alignment, size, address);
>
> - if (mem != NULL) {
> - *memptr = mem;
> - return 0;
> - }
> + if (mem != NULL)
> + {
> + *memptr = mem;
> + return 0;
> + }
>
> return ENOMEM;
> }
> @@ -4892,7 +5061,8 @@ malloc_info (int options, FILE *fp)
> size_t total_aspace = 0;
> size_t total_aspace_mprotect = 0;
>
> - void mi_arena (mstate ar_ptr)
> + void
> + mi_arena (mstate ar_ptr)
> {
> fprintf (fp, "<heap nr=\"%d\">\n<sizes>\n", n++);
>
> @@ -4913,28 +5083,28 @@ malloc_info (int options, FILE *fp)
>
> for (size_t i = 0; i < NFASTBINS; ++i)
> {
> - mchunkptr p = fastbin (ar_ptr, i);
> - if (p != NULL)
> - {
> - size_t nthissize = 0;
> - size_t thissize = chunksize (p);
> -
> - while (p != NULL)
> - {
> - ++nthissize;
> - p = p->fd;
> - }
> -
> - fastavail += nthissize * thissize;
> - nfastblocks += nthissize;
> - sizes[i].from = thissize - (MALLOC_ALIGNMENT - 1);
> - sizes[i].to = thissize;
> - sizes[i].count = nthissize;
> - }
> - else
> - sizes[i].from = sizes[i].to = sizes[i].count = 0;
> -
> - sizes[i].total = sizes[i].count * sizes[i].to;
> + mchunkptr p = fastbin (ar_ptr, i);
> + if (p != NULL)
> + {
> + size_t nthissize = 0;
> + size_t thissize = chunksize (p);
> +
> + while (p != NULL)
> + {
> + ++nthissize;
> + p = p->fd;
> + }
> +
> + fastavail += nthissize * thissize;
> + nfastblocks += nthissize;
> + sizes[i].from = thissize - (MALLOC_ALIGNMENT - 1);
> + sizes[i].to = thissize;
> + sizes[i].count = nthissize;
> + }
> + else
> + sizes[i].from = sizes[i].to = sizes[i].count = 0;
> +
> + sizes[i].total = sizes[i].count * sizes[i].to;
> }
>
>
> @@ -4943,29 +5113,29 @@ malloc_info (int options, FILE *fp)
>
> for (size_t i = 1; i < NBINS; ++i)
> {
> - bin = bin_at (ar_ptr, i);
> - r = bin->fd;
> - sizes[NFASTBINS - 1 + i].from = ~((size_t) 0);
> - sizes[NFASTBINS - 1 + i].to = sizes[NFASTBINS - 1 + i].total
> - = sizes[NFASTBINS - 1 + i].count = 0;
> -
> - if (r != NULL)
> - while (r != bin)
> - {
> - ++sizes[NFASTBINS - 1 + i].count;
> - sizes[NFASTBINS - 1 + i].total += r->size;
> - sizes[NFASTBINS - 1 + i].from
> - = MIN (sizes[NFASTBINS - 1 + i].from, r->size);
> - sizes[NFASTBINS - 1 + i].to = MAX (sizes[NFASTBINS - 1 + i].to,
> - r->size);
> -
> - r = r->fd;
> - }
> -
> - if (sizes[NFASTBINS - 1 + i].count == 0)
> - sizes[NFASTBINS - 1 + i].from = 0;
> - nblocks += sizes[NFASTBINS - 1 + i].count;
> - avail += sizes[NFASTBINS - 1 + i].total;
> + bin = bin_at (ar_ptr, i);
> + r = bin->fd;
> + sizes[NFASTBINS - 1 + i].from = ~((size_t) 0);
> + sizes[NFASTBINS - 1 + i].to = sizes[NFASTBINS - 1 + i].total
> + = sizes[NFASTBINS - 1 + i].count = 0;
> +
> + if (r != NULL)
> + while (r != bin)
> + {
> + ++sizes[NFASTBINS - 1 + i].count;
> + sizes[NFASTBINS - 1 + i].total += r->size;
> + sizes[NFASTBINS - 1 + i].from
> + = MIN (sizes[NFASTBINS - 1 + i].from, r->size);
> + sizes[NFASTBINS - 1 + i].to = MAX (sizes[NFASTBINS - 1 + i].to,
> + r->size);
> +
> + r = r->fd;
> + }
> +
> + if (sizes[NFASTBINS - 1 + i].count == 0)
> + sizes[NFASTBINS - 1 + i].from = 0;
> + nblocks += sizes[NFASTBINS - 1 + i].count;
> + avail += sizes[NFASTBINS - 1 + i].total;
> }
>
> mutex_unlock (&ar_ptr->mutex);
> @@ -4978,51 +5148,51 @@ malloc_info (int options, FILE *fp)
>
> for (size_t i = 0; i < nsizes; ++i)
> if (sizes[i].count != 0 && i != NFASTBINS)
> - fprintf (fp, "\
> + fprintf (fp, " \
> <size from=\"%zu\" to=\"%zu\" total=\"%zu\" count=\"%zu\"/>\n",
> - sizes[i].from, sizes[i].to, sizes[i].total, sizes[i].count);
> + sizes[i].from, sizes[i].to, sizes[i].total, sizes[i].count);
>
> if (sizes[NFASTBINS].count != 0)
> fprintf (fp, "\
> <unsorted from=\"%zu\" to=\"%zu\" total=\"%zu\" count=\"%zu\"/>\n",
> - sizes[NFASTBINS].from, sizes[NFASTBINS].to,
> - sizes[NFASTBINS].total, sizes[NFASTBINS].count);
> + sizes[NFASTBINS].from, sizes[NFASTBINS].to,
> + sizes[NFASTBINS].total, sizes[NFASTBINS].count);
>
> total_system += ar_ptr->system_mem;
> total_max_system += ar_ptr->max_system_mem;
>
> fprintf (fp,
> - "</sizes>\n<total type=\"fast\" count=\"%zu\" size=\"%zu\"/>\n"
> - "<total type=\"rest\" count=\"%zu\" size=\"%zu\"/>\n"
> - "<system type=\"current\" size=\"%zu\"/>\n"
> - "<system type=\"max\" size=\"%zu\"/>\n",
> - nfastblocks, fastavail, nblocks, avail,
> - ar_ptr->system_mem, ar_ptr->max_system_mem);
> + "</sizes>\n<total type=\"fast\" count=\"%zu\" size=\"%zu\"/>\n"
> + "<total type=\"rest\" count=\"%zu\" size=\"%zu\"/>\n"
> + "<system type=\"current\" size=\"%zu\"/>\n"
> + "<system type=\"max\" size=\"%zu\"/>\n",
> + nfastblocks, fastavail, nblocks, avail,
> + ar_ptr->system_mem, ar_ptr->max_system_mem);
>
> if (ar_ptr != &main_arena)
> {
> - heap_info *heap = heap_for_ptr(top(ar_ptr));
> - fprintf (fp,
> - "<aspace type=\"total\" size=\"%zu\"/>\n"
> - "<aspace type=\"mprotect\" size=\"%zu\"/>\n",
> - heap->size, heap->mprotect_size);
> - total_aspace += heap->size;
> - total_aspace_mprotect += heap->mprotect_size;
> + heap_info *heap = heap_for_ptr (top (ar_ptr));
> + fprintf (fp,
> + "<aspace type=\"total\" size=\"%zu\"/>\n"
> + "<aspace type=\"mprotect\" size=\"%zu\"/>\n",
> + heap->size, heap->mprotect_size);
> + total_aspace += heap->size;
> + total_aspace_mprotect += heap->mprotect_size;
> }
> else
> {
> - fprintf (fp,
> - "<aspace type=\"total\" size=\"%zu\"/>\n"
> - "<aspace type=\"mprotect\" size=\"%zu\"/>\n",
> - ar_ptr->system_mem, ar_ptr->system_mem);
> - total_aspace += ar_ptr->system_mem;
> - total_aspace_mprotect += ar_ptr->system_mem;
> + fprintf (fp,
> + "<aspace type=\"total\" size=\"%zu\"/>\n"
> + "<aspace type=\"mprotect\" size=\"%zu\"/>\n",
> + ar_ptr->system_mem, ar_ptr->system_mem);
> + total_aspace += ar_ptr->system_mem;
> + total_aspace_mprotect += ar_ptr->system_mem;
> }
>
> fputs ("</heap>\n", fp);
> }
>
> - if(__malloc_initialized < 0)
> + if (__malloc_initialized < 0)
> ptmalloc_init ();
>
> fputs ("<malloc version=\"1\">\n", fp);
> @@ -5037,16 +5207,16 @@ malloc_info (int options, FILE *fp)
> while (ar_ptr != &main_arena);
>
> fprintf (fp,
> - "<total type=\"fast\" count=\"%zu\" size=\"%zu\"/>\n"
> - "<total type=\"rest\" count=\"%zu\" size=\"%zu\"/>\n"
> - "<system type=\"current\" size=\"%zu\"/>\n"
> - "<system type=\"max\" size=\"%zu\"/>\n"
> - "<aspace type=\"total\" size=\"%zu\"/>\n"
> - "<aspace type=\"mprotect\" size=\"%zu\"/>\n"
> - "</malloc>\n",
> - total_nfastblocks, total_fastavail, total_nblocks, total_avail,
> - total_system, total_max_system,
> - total_aspace, total_aspace_mprotect);
> + "<total type=\"fast\" count=\"%zu\" size=\"%zu\"/>\n"
> + "<total type=\"rest\" count=\"%zu\" size=\"%zu\"/>\n"
> + "<system type=\"current\" size=\"%zu\"/>\n"
> + "<system type=\"max\" size=\"%zu\"/>\n"
> + "<aspace type=\"total\" size=\"%zu\"/>\n"
> + "<aspace type=\"mprotect\" size=\"%zu\"/>\n"
> + "</malloc>\n",
> + total_nfastblocks, total_fastavail, total_nblocks, total_avail,
> + total_system, total_max_system,
> + total_aspace, total_aspace_mprotect);
>
> return 0;
> }
> @@ -5073,11 +5243,11 @@ weak_alias (__malloc_set_state, malloc_set_state)
>
>
> /* ------------------------------------------------------------
> -History:
> + History:
>
> -[see ftp://g.oswego.edu/pub/misc/malloc.c for the history of dlmalloc]
> + [see ftp://g.oswego.edu/pub/misc/malloc.c for the history of dlmalloc]
>
> -*/
> + */
> /*
> * Local variables:
> * c-basic-offset: 2
> diff --git a/malloc/malloc.h b/malloc/malloc.h
> index b8b0ca3..22a9f3a 100644
> --- a/malloc/malloc.h
> +++ b/malloc/malloc.h
> @@ -39,7 +39,7 @@ extern void *malloc (size_t __size) __THROW __attribute_malloc__ __wur;
>
> /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */
> extern void *calloc (size_t __nmemb, size_t __size)
> - __THROW __attribute_malloc__ __wur;
> +__THROW __attribute_malloc__ __wur;
>
> /* Re-allocate the previously allocated block in __ptr, making the new
> block SIZE bytes long. */
> @@ -47,7 +47,7 @@ extern void *calloc (size_t __nmemb, size_t __size)
> the same pointer that was passed to it, aliasing needs to be allowed
> between objects pointed by the old and new pointers. */
> extern void *realloc (void *__ptr, size_t __size)
> - __THROW __attribute_warn_unused_result__;
> +__THROW __attribute_warn_unused_result__;
>
> /* Free a block allocated by `malloc', `realloc' or `calloc'. */
> extern void free (void *__ptr) __THROW;
> @@ -57,14 +57,14 @@ extern void cfree (void *__ptr) __THROW;
>
> /* Allocate SIZE bytes allocated to ALIGNMENT bytes. */
> extern void *memalign (size_t __alignment, size_t __size)
> - __THROW __attribute_malloc__ __wur;
> +__THROW __attribute_malloc__ __wur;
>
> /* Allocate SIZE bytes on a page boundary. */
> extern void *valloc (size_t __size) __THROW __attribute_malloc__ __wur;
>
> /* Equivalent to valloc(minimum-page-that-holds(n)), that is, round up
> __size to nearest pagesize. */
> -extern void * pvalloc (size_t __size) __THROW __attribute_malloc__ __wur;
> +extern void *pvalloc (size_t __size) __THROW __attribute_malloc__ __wur;
>
> /* Underlying allocation function; successive calls should return
> contiguous pieces of memory. */
> @@ -72,7 +72,7 @@ extern void *(*__morecore) (ptrdiff_t __size);
>
> /* Default value of `__morecore'. */
> extern void *__default_morecore (ptrdiff_t __size)
> - __THROW __attribute_malloc__;
> +__THROW __attribute_malloc__;
>
> /* SVID2/XPG mallinfo structure */
>
> @@ -95,16 +95,16 @@ extern struct mallinfo mallinfo (void) __THROW;
>
> /* SVID2/XPG mallopt options */
> #ifndef M_MXFAST
> -# define M_MXFAST 1 /* maximum request size for "fastbins" */
> +# define M_MXFAST 1 /* maximum request size for "fastbins" */
> #endif
> #ifndef M_NLBLKS
> -# define M_NLBLKS 2 /* UNUSED in this malloc */
> +# define M_NLBLKS 2 /* UNUSED in this malloc */
> #endif
> #ifndef M_GRAIN
> -# define M_GRAIN 3 /* UNUSED in this malloc */
> +# define M_GRAIN 3 /* UNUSED in this malloc */
> #endif
> #ifndef M_KEEP
> -# define M_KEEP 4 /* UNUSED in this malloc */
> +# define M_KEEP 4 /* UNUSED in this malloc */
> #endif
>
> /* mallopt options that actually do something */
> @@ -113,9 +113,9 @@ extern struct mallinfo mallinfo (void) __THROW;
> #define M_MMAP_THRESHOLD -3
> #define M_MMAP_MAX -4
> #define M_CHECK_ACTION -5
> -#define M_PERTURB -6
> -#define M_ARENA_TEST -7
> -#define M_ARENA_MAX -8
> +#define M_PERTURB -6
> +#define M_ARENA_TEST -7
> +#define M_ARENA_MAX -8
>
> /* General SVID/XPG interface to tunable parameters. */
> extern int mallopt (int __param, int __val) __THROW;
> @@ -145,22 +145,22 @@ extern int malloc_set_state (void *__ptr) __THROW;
> the application provides the preferred way to set up the hook
> pointers. */
> extern void (*__MALLOC_HOOK_VOLATILE __malloc_initialize_hook) (void)
> - __MALLOC_DEPRECATED;
> +__MALLOC_DEPRECATED;
> /* Hooks for debugging and user-defined versions. */
> extern void (*__MALLOC_HOOK_VOLATILE __free_hook) (void *__ptr,
> - const void *)
> - __MALLOC_DEPRECATED;
> -extern void *(*__MALLOC_HOOK_VOLATILE __malloc_hook) (size_t __size,
> - const void *)
> - __MALLOC_DEPRECATED;
> -extern void *(*__MALLOC_HOOK_VOLATILE __realloc_hook) (void *__ptr,
> - size_t __size,
> - const void *)
> - __MALLOC_DEPRECATED;
> -extern void *(*__MALLOC_HOOK_VOLATILE __memalign_hook) (size_t __alignment,
> - size_t __size,
> - const void *)
> - __MALLOC_DEPRECATED;
> + const void *)
> +__MALLOC_DEPRECATED;
> +extern void *(*__MALLOC_HOOK_VOLATILE __malloc_hook)(size_t __size,
> + const void *)
> +__MALLOC_DEPRECATED;
> +extern void *(*__MALLOC_HOOK_VOLATILE __realloc_hook)(void *__ptr,
> + size_t __size,
> + const void *)
> +__MALLOC_DEPRECATED;
> +extern void *(*__MALLOC_HOOK_VOLATILE __memalign_hook)(size_t __alignment,
> + size_t __size,
> + const void *)
> +__MALLOC_DEPRECATED;
> extern void (*__MALLOC_HOOK_VOLATILE __after_morecore_hook) (void);
>
> /* Activate a standard set of debugging hooks. */
> @@ -168,5 +168,4 @@ extern void __malloc_check_init (void) __THROW __MALLOC_DEPRECATED;
>
>
> __END_DECLS
> -
> #endif /* malloc.h */
> diff --git a/malloc/mallocbug.c b/malloc/mallocbug.c
> index fc607ae..7d19b6f 100644
> --- a/malloc/mallocbug.c
> +++ b/malloc/mallocbug.c
> @@ -22,14 +22,14 @@ main (int argc, char *argv[])
> size_t i;
>
> /* Here's what memory is supposed to look like (hex):
> - size contents
> - 3000 original_info_table, later fill_info_table1
> + size contents
> + 3000 original_info_table, later fill_info_table1
> 3fa000 dummy0
> 3fa000 dummy1
> - 6000 info_table_2
> - 3000 over_top
> + 6000 info_table_2
> + 3000 over_top
>
> - */
> + */
> /* mem: original_info_table */
> dummy0 = malloc (0x3fa000);
> /* mem: original_info_table, dummy0 */
> @@ -54,15 +54,15 @@ main (int argc, char *argv[])
> for (i = 0; i < over_top_size; ++i)
> if (over_top[i] != 0)
> {
> - printf ("FAIL: malloc expands info table\n");
> - return 0;
> + printf ("FAIL: malloc expands info table\n");
> + return 0;
> }
>
> for (i = 0; i < over_top_dup_size; ++i)
> if (over_top_dup[i] != 1)
> {
> - printf ("FAIL: malloc expands info table\n");
> - return 0;
> + printf ("FAIL: malloc expands info table\n");
> + return 0;
> }
>
> printf ("PASS: malloc expands info table\n");
> diff --git a/malloc/mcheck.c b/malloc/mcheck.c
> index 2e5eadd..8be0145 100644
> --- a/malloc/mcheck.c
> +++ b/malloc/mcheck.c
> @@ -17,7 +17,7 @@
> License along with the GNU C Library; if not, see
> <http://www.gnu.org/licenses/>. */
>
> -#ifndef _MALLOC_INTERNAL
> +#ifndef _MALLOC_INTERNAL
> # define _MALLOC_INTERNAL
> # include <malloc.h>
> # include <mcheck.h>
> @@ -28,32 +28,32 @@
> #endif
>
> /* Old hook values. */
> -static void (*old_free_hook) (__ptr_t ptr, const __ptr_t);
> +static void (*old_free_hook)(__ptr_t ptr, const __ptr_t);
> static __ptr_t (*old_malloc_hook) (size_t size, const __ptr_t);
> static __ptr_t (*old_memalign_hook) (size_t alignment, size_t size,
> - const __ptr_t);
> + const __ptr_t);
> static __ptr_t (*old_realloc_hook) (__ptr_t ptr, size_t size,
> - const __ptr_t);
> + const __ptr_t);
>
> /* Function to call when something awful happens. */
> static void (*abortfunc) (enum mcheck_status);
>
> /* Arbitrary magical numbers. */
> -#define MAGICWORD 0xfedabeeb
> -#define MAGICFREE 0xd8675309
> -#define MAGICBYTE ((char) 0xd7)
> -#define MALLOCFLOOD ((char) 0x93)
> -#define FREEFLOOD ((char) 0x95)
> +#define MAGICWORD 0xfedabeeb
> +#define MAGICFREE 0xd8675309
> +#define MAGICBYTE ((char) 0xd7)
> +#define MALLOCFLOOD ((char) 0x93)
> +#define FREEFLOOD ((char) 0x95)
>
> struct hdr
> - {
> - size_t size; /* Exact size requested by user. */
> - unsigned long int magic; /* Magic number to check header integrity. */
> - struct hdr *prev;
> - struct hdr *next;
> - __ptr_t block; /* Real block allocated, for memalign. */
> - unsigned long int magic2; /* Extra, keeps us doubleword aligned. */
> - };
> +{
> + size_t size; /* Exact size requested by user. */
> + unsigned long int magic; /* Magic number to check header integrity. */
> + struct hdr *prev;
> + struct hdr *next;
> + __ptr_t block; /* Real block allocated, for memalign. */
> + unsigned long int magic2; /* Extra, keeps us doubleword aligned. */
> +};
>
> /* This is the beginning of the list of all memory blocks allocated.
> It is only constructed if the pedantic testing is requested. */
> @@ -69,11 +69,10 @@ static int pedantic;
> # define flood memset
> #else
> static void flood (__ptr_t, int, size_t);
> -static void
> -flood (ptr, val, size)
> - __ptr_t ptr;
> - int val;
> - size_t size;
> +static void flood (ptr, val, size)
> +__ptr_t ptr;
> +int val;
> +size_t size;
> {
> char *cp = ptr;
> while (size--)
> @@ -101,11 +100,11 @@ checkhdr (const struct hdr *hdr)
> break;
> case MAGICWORD:
> if (((char *) &hdr[1])[hdr->size] != MAGICBYTE)
> - status = MCHECK_TAIL;
> + status = MCHECK_TAIL;
> else if ((hdr->magic2 ^ (uintptr_t) hdr->block) != MAGICWORD)
> - status = MCHECK_HEAD;
> + status = MCHECK_HEAD;
> else
> - status = MCHECK_OK;
> + status = MCHECK_OK;
> break;
> }
> if (status != MCHECK_OK)
> @@ -148,13 +147,13 @@ unlink_blk (struct hdr *ptr)
> {
> ptr->next->prev = ptr->prev;
> ptr->next->magic = MAGICWORD ^ ((uintptr_t) ptr->next->prev
> - + (uintptr_t) ptr->next->next);
> + + (uintptr_t) ptr->next->next);
> }
> if (ptr->prev != NULL)
> {
> ptr->prev->next = ptr->next;
> ptr->prev->magic = MAGICWORD ^ ((uintptr_t) ptr->prev->prev
> - + (uintptr_t) ptr->prev->next);
> + + (uintptr_t) ptr->prev->next);
> }
> else
> root = ptr->next;
> @@ -173,7 +172,7 @@ link_blk (struct hdr *hdr)
> {
> hdr->next->prev = hdr;
> hdr->next->magic = MAGICWORD ^ ((uintptr_t) hdr
> - + (uintptr_t) hdr->next->next);
> + + (uintptr_t) hdr->next->next);
> }
> }
> static void
> @@ -194,7 +193,7 @@ freehook (__ptr_t ptr, const __ptr_t caller)
> }
> __free_hook = old_free_hook;
> if (old_free_hook != NULL)
> - (*old_free_hook) (ptr, caller);
> + (*old_free_hook)(ptr, caller);
> else
> free (ptr);
> __free_hook = freehook;
> @@ -216,8 +215,8 @@ mallochook (size_t size, const __ptr_t caller)
>
> __malloc_hook = old_malloc_hook;
> if (old_malloc_hook != NULL)
> - hdr = (struct hdr *) (*old_malloc_hook) (sizeof (struct hdr) + size + 1,
> - caller);
> + hdr = (struct hdr *) (*old_malloc_hook)(sizeof (struct hdr) + size + 1,
> + caller);
> else
> hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1);
> __malloc_hook = mallochook;
> @@ -235,7 +234,7 @@ mallochook (size_t size, const __ptr_t caller)
>
> static __ptr_t
> memalignhook (size_t alignment, size_t size,
> - const __ptr_t caller)
> + const __ptr_t caller)
> {
> struct hdr *hdr;
> size_t slop;
> @@ -244,7 +243,7 @@ memalignhook (size_t alignment, size_t size,
> if (pedantic)
> mcheck_check_all ();
>
> - slop = (sizeof *hdr + alignment - 1) & -alignment;
> + slop = (sizeof *hdr + alignment - 1) & - alignment;
>
> if (size > ~((size_t) 0) - (slop + 1))
> {
> @@ -254,7 +253,7 @@ memalignhook (size_t alignment, size_t size,
>
> __memalign_hook = old_memalign_hook;
> if (old_memalign_hook != NULL)
> - block = (*old_memalign_hook) (alignment, slop + size + 1, caller);
> + block = (*old_memalign_hook)(alignment, slop + size + 1, caller);
> else
> block = memalign (alignment, slop + size + 1);
> __memalign_hook = memalignhook;
> @@ -301,7 +300,7 @@ reallochook (__ptr_t ptr, size_t size, const __ptr_t caller)
> checkhdr (hdr);
> unlink_blk (hdr);
> if (size < osize)
> - flood ((char *) ptr + size, FREEFLOOD, osize - size);
> + flood ((char *) ptr + size, FREEFLOOD, osize - size);
> }
> else
> {
> @@ -313,12 +312,12 @@ reallochook (__ptr_t ptr, size_t size, const __ptr_t caller)
> __memalign_hook = old_memalign_hook;
> __realloc_hook = old_realloc_hook;
> if (old_realloc_hook != NULL)
> - hdr = (struct hdr *) (*old_realloc_hook) ((__ptr_t) hdr,
> - sizeof (struct hdr) + size + 1,
> - caller);
> + hdr = (struct hdr *) (*old_realloc_hook)((__ptr_t) hdr,
> + sizeof (struct hdr) + size + 1,
> + caller);
> else
> hdr = (struct hdr *) realloc ((__ptr_t) hdr,
> - sizeof (struct hdr) + size + 1);
> + sizeof (struct hdr) + size + 1);
> __free_hook = freehook;
> __malloc_hook = mallochook;
> __memalign_hook = memalignhook;
> @@ -344,19 +343,19 @@ mabort (enum mcheck_status status)
> switch (status)
> {
> case MCHECK_OK:
> - msg = _("memory is consistent, library is buggy\n");
> + msg = _ ("memory is consistent, library is buggy\n");
> break;
> case MCHECK_HEAD:
> - msg = _("memory clobbered before allocated block\n");
> + msg = _ ("memory clobbered before allocated block\n");
> break;
> case MCHECK_TAIL:
> - msg = _("memory clobbered past end of allocated block\n");
> + msg = _ ("memory clobbered past end of allocated block\n");
> break;
> case MCHECK_FREE:
> - msg = _("block freed twice\n");
> + msg = _ ("block freed twice\n");
> break;
> default:
> - msg = _("bogus mcheck_status, library is buggy\n");
> + msg = _ ("bogus mcheck_status, library is buggy\n");
> break;
> }
> #ifdef _LIBC
> @@ -370,11 +369,10 @@ mabort (enum mcheck_status status)
>
> /* Memory barrier so that GCC does not optimize out the argument. */
> #define malloc_opt_barrier(x) \
> -({ __typeof (x) __x = x; __asm ("" : "+m" (__x)); __x; })
> + ({ __typeof (x) __x = x; __asm ("" : "+m" (__x)); __x; })
>
> -int
> -mcheck (func)
> - void (*func) (enum mcheck_status);
> +int mcheck (func)
> +void (*func)(enum mcheck_status);
> {
> abortfunc = (func != NULL) ? func : &mabort;
>
> @@ -404,9 +402,8 @@ mcheck (func)
> libc_hidden_def (mcheck)
> #endif
>
> -int
> -mcheck_pedantic (func)
> - void (*func) (enum mcheck_status);
> +int mcheck_pedantic (func)
> +void (*func)(enum mcheck_status);
> {
> int res = mcheck (func);
> if (res == 0)
> diff --git a/malloc/mcheck.h b/malloc/mcheck.h
> index 204ca33..53b9405 100644
> --- a/malloc/mcheck.h
> +++ b/malloc/mcheck.h
> @@ -16,7 +16,7 @@
> <http://www.gnu.org/licenses/>. */
>
> #ifndef _MCHECK_H
> -#define _MCHECK_H 1
> +#define _MCHECK_H 1
>
> #include <features.h>
>
> @@ -25,24 +25,24 @@ __BEGIN_DECLS
> /* Return values for `mprobe': these are the kinds of inconsistencies that
> `mcheck' enables detection of. */
> enum mcheck_status
> - {
> - MCHECK_DISABLED = -1, /* Consistency checking is not turned on. */
> - MCHECK_OK, /* Block is fine. */
> - MCHECK_FREE, /* Block freed twice. */
> - MCHECK_HEAD, /* Memory before the block was clobbered. */
> - MCHECK_TAIL /* Memory after the block was clobbered. */
> - };
> +{
> + MCHECK_DISABLED = -1, /* Consistency checking is not turned on. */
> + MCHECK_OK, /* Block is fine. */
> + MCHECK_FREE, /* Block freed twice. */
> + MCHECK_HEAD, /* Memory before the block was clobbered. */
> + MCHECK_TAIL /* Memory after the block was clobbered. */
> +};
>
>
> /* Activate a standard collection of debugging hooks. This must be called
> before `malloc' is ever called. ABORTFUNC is called with an error code
> (see enum above) when an inconsistency is detected. If ABORTFUNC is
> null, the standard function prints on stderr and then calls `abort'. */
> -extern int mcheck (void (*__abortfunc) (enum mcheck_status)) __THROW;
> +extern int mcheck (void (*__abortfunc)(enum mcheck_status)) __THROW;
>
> /* Similar to `mcheck' but performs checks for all block whenever one of
> the memory handling functions is called. This can be very slow. */
> -extern int mcheck_pedantic (void (*__abortfunc) (enum mcheck_status)) __THROW;
> +extern int mcheck_pedantic (void (*__abortfunc)(enum mcheck_status)) __THROW;
>
> /* Force check of all blocks now. */
> extern void mcheck_check_all (void);
> @@ -57,5 +57,4 @@ extern void mtrace (void) __THROW;
> extern void muntrace (void) __THROW;
>
> __END_DECLS
> -
> #endif /* mcheck.h */
> diff --git a/malloc/memusage.c b/malloc/memusage.c
> index e32f6ba..2aaa150 100644
> --- a/malloc/memusage.c
> +++ b/malloc/memusage.c
> @@ -38,7 +38,7 @@
>
> /* Pointer to the real functions. These are determined used `dlsym'
> when really needed. */
> -static void *(*mallocp) (size_t);
> +static void *(*mallocp)(size_t);
> static void *(*reallocp) (void *, size_t);
> static void *(*callocp) (size_t, size_t);
> static void (*freep) (void *);
> @@ -89,11 +89,11 @@ static memusage_size_t peak_use[3];
> static __thread uintptr_t start_sp;
>
> /* A few macros to make the source more readable. */
> -#define peak_heap peak_use[0]
> -#define peak_stack peak_use[1]
> -#define peak_total peak_use[2]
> +#define peak_heap peak_use[0]
> +#define peak_stack peak_use[1]
> +#define peak_total peak_use[2]
>
> -#define DEFAULT_BUFFER_SIZE 32768
> +#define DEFAULT_BUFFER_SIZE 32768
> static size_t buffer_size;
>
> static int fd = -1;
> @@ -164,16 +164,16 @@ update_data (struct header *result, size_t len, size_t old_len)
> {
> uatomic32_t idx = catomic_exchange_and_add (&buffer_cnt, 1);
> if (idx + 1 >= 2 * buffer_size)
> - {
> - /* We try to reset the counter to the correct range. If
> - this fails because of another thread increasing the
> - counter it does not matter since that thread will take
> - care of the correction. */
> - uatomic32_t reset = (idx + 1) % (2 * buffer_size);
> - catomic_compare_and_exchange_val_acq (&buffer_cnt, reset, idx + 1);
> - if (idx >= 2 * buffer_size)
> - idx = reset - 1;
> - }
> + {
> + /* We try to reset the counter to the correct range. If
> + this fails because of another thread increasing the
> + counter it does not matter since that thread will take
> + care of the correction. */
> + uatomic32_t reset = (idx + 1) % (2 * buffer_size);
> + catomic_compare_and_exchange_val_acq (&buffer_cnt, reset, idx + 1);
> + if (idx >= 2 * buffer_size)
> + idx = reset - 1;
> + }
> assert (idx < 2 * DEFAULT_BUFFER_SIZE);
>
> buffer[idx].heap = current_heap;
> @@ -182,9 +182,9 @@ update_data (struct header *result, size_t len, size_t old_len)
>
> /* Write out buffer if it is full. */
> if (idx + 1 == buffer_size)
> - write (fd, buffer, buffer_size * sizeof (struct entry));
> + write (fd, buffer, buffer_size * sizeof (struct entry));
> else if (idx + 1 == 2 * buffer_size)
> - write (fd, &buffer[buffer_size], buffer_size * sizeof (struct entry));
> + write (fd, &buffer[buffer_size], buffer_size * sizeof (struct entry));
> }
> }
>
> @@ -221,19 +221,19 @@ me (void)
> size_t prog_len = strlen (__progname);
>
> initialized = -1;
> - mallocp = (void *(*) (size_t)) dlsym (RTLD_NEXT, "malloc");
> - reallocp = (void *(*) (void *, size_t)) dlsym (RTLD_NEXT, "realloc");
> - callocp = (void *(*) (size_t, size_t)) dlsym (RTLD_NEXT, "calloc");
> - freep = (void (*) (void *)) dlsym (RTLD_NEXT, "free");
> + mallocp = (void *(*)(size_t))dlsym (RTLD_NEXT, "malloc");
> + reallocp = (void *(*)(void *, size_t))dlsym (RTLD_NEXT, "realloc");
> + callocp = (void *(*)(size_t, size_t))dlsym (RTLD_NEXT, "calloc");
> + freep = (void (*)(void *))dlsym (RTLD_NEXT, "free");
>
> - mmapp = (void *(*) (void *, size_t, int, int, int, off_t)) dlsym (RTLD_NEXT,
> - "mmap");
> + mmapp = (void *(*)(void *, size_t, int, int, int, off_t))dlsym (RTLD_NEXT,
> + "mmap");
> mmap64p =
> - (void *(*) (void *, size_t, int, int, int, off64_t)) dlsym (RTLD_NEXT,
> - "mmap64");
> - mremapp = (void *(*) (void *, size_t, size_t, int, void *)) dlsym (RTLD_NEXT,
> - "mremap");
> - munmapp = (int (*) (void *, size_t)) dlsym (RTLD_NEXT, "munmap");
> + (void *(*)(void *, size_t, int, int, int, off64_t))dlsym (RTLD_NEXT,
> + "mmap64");
> + mremapp = (void *(*)(void *, size_t, size_t, int, void *))dlsym (RTLD_NEXT,
> + "mremap");
> + munmapp = (int (*)(void *, size_t))dlsym (RTLD_NEXT, "munmap");
> initialized = 1;
>
> if (env != NULL)
> @@ -241,8 +241,8 @@ me (void)
> /* Check for program name. */
> size_t len = strlen (env);
> if (len > prog_len || strcmp (env, &__progname[prog_len - len]) != 0
> - || (prog_len != len && __progname[prog_len - len - 1] != '/'))
> - not_me = true;
> + || (prog_len != len && __progname[prog_len - len - 1] != '/'))
> + not_me = true;
> }
>
> /* Only open the file if it's really us. */
> @@ -251,62 +251,62 @@ me (void)
> const char *outname;
>
> if (!start_sp)
> - start_sp = GETSP ();
> + start_sp = GETSP ();
>
> outname = getenv ("MEMUSAGE_OUTPUT");
> if (outname != NULL && outname[0] != '\0'
> - && (access (outname, R_OK | W_OK) == 0 || errno == ENOENT))
> - {
> - fd = creat64 (outname, 0666);
> -
> - if (fd == -1)
> - /* Don't do anything in future calls if we cannot write to
> - the output file. */
> - not_me = true;
> - else
> - {
> - /* Write the first entry. */
> - first.heap = 0;
> - first.stack = 0;
> - GETTIME (first.time_low, first.time_high);
> - /* Write it two times since we need the starting and end time. */
> - write (fd, &first, sizeof (first));
> - write (fd, &first, sizeof (first));
> -
> - /* Determine the buffer size. We use the default if the
> - environment variable is not present. */
> - buffer_size = DEFAULT_BUFFER_SIZE;
> - if (getenv ("MEMUSAGE_BUFFER_SIZE") != NULL)
> - {
> - buffer_size = atoi (getenv ("MEMUSAGE_BUFFER_SIZE"));
> - if (buffer_size == 0 || buffer_size > DEFAULT_BUFFER_SIZE)
> - buffer_size = DEFAULT_BUFFER_SIZE;
> - }
> -
> - /* Possibly enable timer-based stack pointer retrieval. */
> - if (getenv ("MEMUSAGE_NO_TIMER") == NULL)
> - {
> - struct sigaction act;
> -
> - act.sa_handler = (sighandler_t) &int_handler;
> - act.sa_flags = SA_RESTART;
> - sigfillset (&act.sa_mask);
> -
> - if (sigaction (SIGPROF, &act, NULL) >= 0)
> - {
> - struct itimerval timer;
> -
> - timer.it_value.tv_sec = 0;
> - timer.it_value.tv_usec = 1;
> - timer.it_interval = timer.it_value;
> - setitimer (ITIMER_PROF, &timer, NULL);
> - }
> - }
> - }
> - }
> + && (access (outname, R_OK | W_OK) == 0 || errno == ENOENT))
> + {
> + fd = creat64 (outname, 0666);
> +
> + if (fd == -1)
> + /* Don't do anything in future calls if we cannot write to
> + the output file. */
> + not_me = true;
> + else
> + {
> + /* Write the first entry. */
> + first.heap = 0;
> + first.stack = 0;
> + GETTIME (first.time_low, first.time_high);
> + /* Write it two times since we need the starting and end time. */
> + write (fd, &first, sizeof (first));
> + write (fd, &first, sizeof (first));
> +
> + /* Determine the buffer size. We use the default if the
> + environment variable is not present. */
> + buffer_size = DEFAULT_BUFFER_SIZE;
> + if (getenv ("MEMUSAGE_BUFFER_SIZE") != NULL)
> + {
> + buffer_size = atoi (getenv ("MEMUSAGE_BUFFER_SIZE"));
> + if (buffer_size == 0 || buffer_size > DEFAULT_BUFFER_SIZE)
> + buffer_size = DEFAULT_BUFFER_SIZE;
> + }
> +
> + /* Possibly enable timer-based stack pointer retrieval. */
> + if (getenv ("MEMUSAGE_NO_TIMER") == NULL)
> + {
> + struct sigaction act;
> +
> + act.sa_handler = (sighandler_t) &int_handler;
> + act.sa_flags = SA_RESTART;
> + sigfillset (&act.sa_mask);
> +
> + if (sigaction (SIGPROF, &act, NULL) >= 0)
> + {
> + struct itimerval timer;
> +
> + timer.it_value.tv_sec = 0;
> + timer.it_value.tv_usec = 1;
> + timer.it_interval = timer.it_value;
> + setitimer (ITIMER_PROF, &timer, NULL);
> + }
> + }
> + }
> + }
>
> if (!not_me && getenv ("MEMUSAGE_TRACE_MMAP") != NULL)
> - trace_mmap = true;
> + trace_mmap = true;
> }
> }
>
> @@ -317,7 +317,7 @@ __attribute__ ((constructor))
> init (void)
> {
> start_sp = GETSP ();
> - if (! initialized)
> + if (!initialized)
> me ();
> }
>
> @@ -333,13 +333,14 @@ malloc (size_t len)
> if (__builtin_expect (initialized <= 0, 0))
> {
> if (initialized == -1)
> - return NULL;
> + return NULL;
> +
> me ();
> }
>
> /* If this is not the correct program just use the normal function. */
> if (not_me)
> - return (*mallocp) (len);
> + return (*mallocp)(len);
>
> /* Keep track of number of calls. */
> catomic_increment (&calls[idx_malloc]);
> @@ -356,7 +357,7 @@ malloc (size_t len)
> catomic_increment (&calls_total);
>
> /* Do the real work. */
> - result = (struct header *) (*mallocp) (len + sizeof (struct header));
> + result = (struct header *) (*mallocp)(len + sizeof (struct header));
> if (result == NULL)
> {
> catomic_increment (&failed[idx_malloc]);
> @@ -384,13 +385,14 @@ realloc (void *old, size_t len)
> if (__builtin_expect (initialized <= 0, 0))
> {
> if (initialized == -1)
> - return NULL;
> + return NULL;
> +
> me ();
> }
>
> /* If this is not the correct program just use the normal function. */
> if (not_me)
> - return (*reallocp) (old, len);
> + return (*reallocp)(old, len);
>
> if (old == NULL)
> {
> @@ -402,8 +404,9 @@ realloc (void *old, size_t len)
> {
> real = ((struct header *) old) - 1;
> if (real->magic != MAGIC)
> - /* This is no memory allocated here. */
> - return (*reallocp) (old, len);
> + /* This is no memory allocated here. */
> + return (*reallocp)(old, len);
> +
> old_len = real->length;
> }
>
> @@ -442,7 +445,7 @@ realloc (void *old, size_t len)
> catomic_increment (&calls_total);
>
> /* Do the real work. */
> - result = (struct header *) (*reallocp) (real, len + sizeof (struct header));
> + result = (struct header *) (*reallocp)(real, len + sizeof (struct header));
> if (result == NULL)
> {
> catomic_increment (&failed[idx_realloc]);
> @@ -476,13 +479,14 @@ calloc (size_t n, size_t len)
> if (__builtin_expect (initialized <= 0, 0))
> {
> if (initialized == -1)
> - return NULL;
> + return NULL;
> +
> me ();
> }
>
> /* If this is not the correct program just use the normal function. */
> if (not_me)
> - return (*callocp) (n, len);
> + return (*callocp)(n, len);
>
> /* Keep track of number of calls. */
> catomic_increment (&calls[idx_calloc]);
> @@ -499,7 +503,7 @@ calloc (size_t n, size_t len)
> ++calls_total;
>
> /* Do the real work. */
> - result = (struct header *) (*mallocp) (size + sizeof (struct header));
> + result = (struct header *) (*mallocp)(size + sizeof (struct header));
> if (result == NULL)
> {
> catomic_increment (&failed[idx_calloc]);
> @@ -525,7 +529,8 @@ free (void *ptr)
> if (__builtin_expect (initialized <= 0, 0))
> {
> if (initialized == -1)
> - return;
> + return;
> +
> me ();
> }
>
> @@ -576,17 +581,18 @@ mmap (void *start, size_t len, int prot, int flags, int fd, off_t offset)
> if (__builtin_expect (initialized <= 0, 0))
> {
> if (initialized == -1)
> - return NULL;
> + return NULL;
> +
> me ();
> }
>
> /* Always get a block. We don't need extra memory. */
> - result = (*mmapp) (start, len, prot, flags, fd, offset);
> + result = (*mmapp)(start, len, prot, flags, fd, offset);
>
> if (!not_me && trace_mmap)
> {
> int idx = (flags & MAP_ANON
> - ? idx_mmap_a : prot & PROT_WRITE ? idx_mmap_w : idx_mmap_r);
> + ? idx_mmap_a : prot & PROT_WRITE ? idx_mmap_w : idx_mmap_r);
>
> /* Keep track of number of calls. */
> catomic_increment (&calls[idx]);
> @@ -596,20 +602,20 @@ mmap (void *start, size_t len, int prot, int flags, int fd, off_t offset)
> catomic_add (&grand_total, len);
> /* Remember the size of the request. */
> if (len < 65536)
> - catomic_increment (&histogram[len / 16]);
> + catomic_increment (&histogram[len / 16]);
> else
> - catomic_increment (&large);
> + catomic_increment (&large);
> /* Total number of calls of any of the functions. */
> catomic_increment (&calls_total);
>
> /* Check for failures. */
> if (result == NULL)
> - catomic_increment (&failed[idx]);
> + catomic_increment (&failed[idx]);
> else if (idx == idx_mmap_w)
> - /* Update the allocation data and write out the records if
> - necessary. Note the first parameter is NULL which means
> - the size is not tracked. */
> - update_data (NULL, len, 0);
> + /* Update the allocation data and write out the records if
> + necessary. Note the first parameter is NULL which means
> + the size is not tracked. */
> + update_data (NULL, len, 0);
> }
>
> /* Return the pointer to the user buffer. */
> @@ -628,17 +634,18 @@ mmap64 (void *start, size_t len, int prot, int flags, int fd, off64_t offset)
> if (__builtin_expect (initialized <= 0, 0))
> {
> if (initialized == -1)
> - return NULL;
> + return NULL;
> +
> me ();
> }
>
> /* Always get a block. We don't need extra memory. */
> - result = (*mmap64p) (start, len, prot, flags, fd, offset);
> + result = (*mmap64p)(start, len, prot, flags, fd, offset);
>
> if (!not_me && trace_mmap)
> {
> int idx = (flags & MAP_ANON
> - ? idx_mmap_a : prot & PROT_WRITE ? idx_mmap_w : idx_mmap_r);
> + ? idx_mmap_a : prot & PROT_WRITE ? idx_mmap_w : idx_mmap_r);
>
> /* Keep track of number of calls. */
> catomic_increment (&calls[idx]);
> @@ -648,20 +655,20 @@ mmap64 (void *start, size_t len, int prot, int flags, int fd, off64_t offset)
> catomic_add (&grand_total, len);
> /* Remember the size of the request. */
> if (len < 65536)
> - catomic_increment (&histogram[len / 16]);
> + catomic_increment (&histogram[len / 16]);
> else
> - catomic_increment (&large);
> + catomic_increment (&large);
> /* Total number of calls of any of the functions. */
> catomic_increment (&calls_total);
>
> /* Check for failures. */
> if (result == NULL)
> - catomic_increment (&failed[idx]);
> + catomic_increment (&failed[idx]);
> else if (idx == idx_mmap_w)
> - /* Update the allocation data and write out the records if
> - necessary. Note the first parameter is NULL which means
> - the size is not tracked. */
> - update_data (NULL, len, 0);
> + /* Update the allocation data and write out the records if
> + necessary. Note the first parameter is NULL which means
> + the size is not tracked. */
> + update_data (NULL, len, 0);
> }
>
> /* Return the pointer to the user buffer. */
> @@ -672,7 +679,7 @@ mmap64 (void *start, size_t len, int prot, int flags, int fd, off64_t offset)
> /* `mremap' replacement. We do not have to keep track of the size since
> `munmap' will get it as a parameter. */
> void *
> -mremap (void *start, size_t old_len, size_t len, int flags, ...)
> +mremap (void *start, size_t old_len, size_t len, int flags, ...)
> {
> void *result = NULL;
> va_list ap;
> @@ -685,49 +692,50 @@ mremap (void *start, size_t old_len, size_t len, int flags, ...)
> if (__builtin_expect (initialized <= 0, 0))
> {
> if (initialized == -1)
> - return NULL;
> + return NULL;
> +
> me ();
> }
>
> /* Always get a block. We don't need extra memory. */
> - result = (*mremapp) (start, old_len, len, flags, newaddr);
> + result = (*mremapp)(start, old_len, len, flags, newaddr);
>
> if (!not_me && trace_mmap)
> {
> /* Keep track of number of calls. */
> catomic_increment (&calls[idx_mremap]);
> if (len > old_len)
> - {
> - /* Keep track of total memory consumption for `malloc'. */
> - catomic_add (&total[idx_mremap], len - old_len);
> - /* Keep track of total memory requirement. */
> - catomic_add (&grand_total, len - old_len);
> - }
> + {
> + /* Keep track of total memory consumption for `malloc'. */
> + catomic_add (&total[idx_mremap], len - old_len);
> + /* Keep track of total memory requirement. */
> + catomic_add (&grand_total, len - old_len);
> + }
> /* Remember the size of the request. */
> if (len < 65536)
> - catomic_increment (&histogram[len / 16]);
> + catomic_increment (&histogram[len / 16]);
> else
> - catomic_increment (&large);
> + catomic_increment (&large);
> /* Total number of calls of any of the functions. */
> catomic_increment (&calls_total);
>
> /* Check for failures. */
> if (result == NULL)
> - catomic_increment (&failed[idx_mremap]);
> + catomic_increment (&failed[idx_mremap]);
> else
> - {
> - /* Record whether the reduction/increase happened in place. */
> - if (start == result)
> - catomic_increment (&inplace_mremap);
> - /* Was the buffer increased? */
> - if (old_len > len)
> - catomic_increment (&decreasing_mremap);
> -
> - /* Update the allocation data and write out the records if
> - necessary. Note the first parameter is NULL which means
> - the size is not tracked. */
> - update_data (NULL, len, old_len);
> - }
> + {
> + /* Record whether the reduction/increase happened in place. */
> + if (start == result)
> + catomic_increment (&inplace_mremap);
> + /* Was the buffer increased? */
> + if (old_len > len)
> + catomic_increment (&decreasing_mremap);
> +
> + /* Update the allocation data and write out the records if
> + necessary. Note the first parameter is NULL which means
> + the size is not tracked. */
> + update_data (NULL, len, old_len);
> + }
> }
>
> /* Return the pointer to the user buffer. */
> @@ -745,12 +753,13 @@ munmap (void *start, size_t len)
> if (__builtin_expect (initialized <= 0, 0))
> {
> if (initialized == -1)
> - return -1;
> + return -1;
> +
> me ();
> }
>
> /* Do the real work. */
> - result = (*munmapp) (start, len);
> + result = (*munmapp)(start, len);
>
> if (!not_me && trace_mmap)
> {
> @@ -758,16 +767,16 @@ munmap (void *start, size_t len)
> catomic_increment (&calls[idx_munmap]);
>
> if (__builtin_expect (result == 0, 1))
> - {
> - /* Keep track of total memory freed using `free'. */
> - catomic_add (&total[idx_munmap], len);
> -
> - /* Update the allocation data and write out the records if
> - necessary. */
> - update_data (NULL, 0, len);
> - }
> + {
> + /* Keep track of total memory freed using `free'. */
> + catomic_add (&total[idx_munmap], len);
> +
> + /* Update the allocation data and write out the records if
> + necessary. */
> + update_data (NULL, 0, len);
> + }
> else
> - catomic_increment (&failed[idx_munmap]);
> + catomic_increment (&failed[idx_munmap]);
> }
>
> return result;
> @@ -785,6 +794,7 @@ dest (void)
> /* If we haven't done anything here just return. */
> if (not_me)
> return;
> +
> /* If we should call any of the memory functions don't do any profiling. */
> not_me = true;
>
> @@ -793,13 +803,13 @@ dest (void)
> {
> /* Write the partially filled buffer. */
> if (buffer_cnt > buffer_size)
> - write (fd, buffer + buffer_size,
> - (buffer_cnt - buffer_size) * sizeof (struct entry));
> + write (fd, buffer + buffer_size,
> + (buffer_cnt - buffer_size) * sizeof (struct entry));
> else
> - write (fd, buffer, buffer_cnt * sizeof (struct entry));
> + write (fd, buffer, buffer_cnt * sizeof (struct entry));
>
> /* Go back to the beginning of the file. We allocated two records
> - here when we opened the file. */
> + here when we opened the file. */
> lseek (fd, 0, SEEK_SET);
> /* Write out a record containing the total size. */
> first.stack = peak_total;
> @@ -824,25 +834,25 @@ dest (void)
> \e[00;34mrealloc|\e[0m %10lu %12llu %s%12lu\e[00;00m (nomove:%ld, dec:%ld, free:%ld)\n\
> \e[00;34m calloc|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\
> \e[00;34m free|\e[0m %10lu %12llu\n",
> - (unsigned long long int) grand_total, (unsigned long int) peak_heap,
> - (unsigned long int) peak_stack,
> - (unsigned long int) calls[idx_malloc],
> - (unsigned long long int) total[idx_malloc],
> - failed[idx_malloc] ? "\e[01;41m" : "",
> - (unsigned long int) failed[idx_malloc],
> - (unsigned long int) calls[idx_realloc],
> - (unsigned long long int) total[idx_realloc],
> - failed[idx_realloc] ? "\e[01;41m" : "",
> - (unsigned long int) failed[idx_realloc],
> - (unsigned long int) inplace,
> - (unsigned long int) decreasing,
> - (unsigned long int) realloc_free,
> - (unsigned long int) calls[idx_calloc],
> - (unsigned long long int) total[idx_calloc],
> - failed[idx_calloc] ? "\e[01;41m" : "",
> - (unsigned long int) failed[idx_calloc],
> - (unsigned long int) calls[idx_free],
> - (unsigned long long int) total[idx_free]);
> + (unsigned long long int) grand_total, (unsigned long int) peak_heap,
> + (unsigned long int) peak_stack,
> + (unsigned long int) calls[idx_malloc],
> + (unsigned long long int) total[idx_malloc],
> + failed[idx_malloc] ? "\e[01;41m" : "",
> + (unsigned long int) failed[idx_malloc],
> + (unsigned long int) calls[idx_realloc],
> + (unsigned long long int) total[idx_realloc],
> + failed[idx_realloc] ? "\e[01;41m" : "",
> + (unsigned long int) failed[idx_realloc],
> + (unsigned long int) inplace,
> + (unsigned long int) decreasing,
> + (unsigned long int) realloc_free,
> + (unsigned long int) calls[idx_calloc],
> + (unsigned long long int) total[idx_calloc],
> + failed[idx_calloc] ? "\e[01;41m" : "",
> + (unsigned long int) failed[idx_calloc],
> + (unsigned long int) calls[idx_free],
> + (unsigned long long int) total[idx_free]);
>
> if (trace_mmap)
> fprintf (stderr, "\
> @@ -851,28 +861,28 @@ dest (void)
> \e[00;34mmmap(a)|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\
> \e[00;34m mremap|\e[0m %10lu %12llu %s%12lu\e[00;00m (nomove: %ld, dec:%ld)\n\
> \e[00;34m munmap|\e[0m %10lu %12llu %s%12lu\e[00;00m\n",
> - (unsigned long int) calls[idx_mmap_r],
> - (unsigned long long int) total[idx_mmap_r],
> - failed[idx_mmap_r] ? "\e[01;41m" : "",
> - (unsigned long int) failed[idx_mmap_r],
> - (unsigned long int) calls[idx_mmap_w],
> - (unsigned long long int) total[idx_mmap_w],
> - failed[idx_mmap_w] ? "\e[01;41m" : "",
> - (unsigned long int) failed[idx_mmap_w],
> - (unsigned long int) calls[idx_mmap_a],
> - (unsigned long long int) total[idx_mmap_a],
> - failed[idx_mmap_a] ? "\e[01;41m" : "",
> - (unsigned long int) failed[idx_mmap_a],
> - (unsigned long int) calls[idx_mremap],
> - (unsigned long long int) total[idx_mremap],
> - failed[idx_mremap] ? "\e[01;41m" : "",
> - (unsigned long int) failed[idx_mremap],
> - (unsigned long int) inplace_mremap,
> - (unsigned long int) decreasing_mremap,
> - (unsigned long int) calls[idx_munmap],
> - (unsigned long long int) total[idx_munmap],
> - failed[idx_munmap] ? "\e[01;41m" : "",
> - (unsigned long int) failed[idx_munmap]);
> + (unsigned long int) calls[idx_mmap_r],
> + (unsigned long long int) total[idx_mmap_r],
> + failed[idx_mmap_r] ? "\e[01;41m" : "",
> + (unsigned long int) failed[idx_mmap_r],
> + (unsigned long int) calls[idx_mmap_w],
> + (unsigned long long int) total[idx_mmap_w],
> + failed[idx_mmap_w] ? "\e[01;41m" : "",
> + (unsigned long int) failed[idx_mmap_w],
> + (unsigned long int) calls[idx_mmap_a],
> + (unsigned long long int) total[idx_mmap_a],
> + failed[idx_mmap_a] ? "\e[01;41m" : "",
> + (unsigned long int) failed[idx_mmap_a],
> + (unsigned long int) calls[idx_mremap],
> + (unsigned long long int) total[idx_mremap],
> + failed[idx_mremap] ? "\e[01;41m" : "",
> + (unsigned long int) failed[idx_mremap],
> + (unsigned long int) inplace_mremap,
> + (unsigned long int) decreasing_mremap,
> + (unsigned long int) calls[idx_munmap],
> + (unsigned long long int) total[idx_munmap],
> + failed[idx_munmap] ? "\e[01;41m" : "",
> + (unsigned long int) failed[idx_munmap]);
>
> /* Write out a histoogram of the sizes of the allocations. */
> fprintf (stderr, "\e[01;32mHistogram for block sizes:\e[0;0m\n");
> @@ -887,20 +897,20 @@ dest (void)
> /* Only write out the nonzero entries. */
> if (histogram[cnt / 16] != 0)
> {
> - percent = (histogram[cnt / 16] * 100) / calls_total;
> - fprintf (stderr, "%5d-%-5d%12lu ", cnt, cnt + 15,
> - (unsigned long int) histogram[cnt / 16]);
> - if (percent == 0)
> - fputs (" <1% \e[41;37m", stderr);
> - else
> - fprintf (stderr, "%3d%% \e[41;37m", percent);
> -
> - /* Draw a bar with a length corresponding to the current
> + percent = (histogram[cnt / 16] * 100) / calls_total;
> + fprintf (stderr, "%5d-%-5d%12lu ", cnt, cnt + 15,
> + (unsigned long int) histogram[cnt / 16]);
> + if (percent == 0)
> + fputs (" <1% \e[41;37m", stderr);
> + else
> + fprintf (stderr, "%3d%% \e[41;37m", percent);
> +
> + /* Draw a bar with a length corresponding to the current
> percentage. */
> - percent = (histogram[cnt / 16] * 50) / maxcalls;
> - while (percent-- > 0)
> - fputc ('=', stderr);
> - fputs ("\e[0;0m\n", stderr);
> + percent = (histogram[cnt / 16] * 50) / maxcalls;
> + while (percent-- > 0)
> + fputc ('=', stderr);
> + fputs ("\e[0;0m\n", stderr);
> }
>
> if (large != 0)
> @@ -908,9 +918,9 @@ dest (void)
> percent = (large * 100) / calls_total;
> fprintf (stderr, " large %12lu ", (unsigned long int) large);
> if (percent == 0)
> - fputs (" <1% \e[41;37m", stderr);
> + fputs (" <1% \e[41;37m", stderr);
> else
> - fprintf (stderr, "%3d%% \e[41;37m", percent);
> + fprintf (stderr, "%3d%% \e[41;37m", percent);
> percent = (large * 50) / maxcalls;
> while (percent-- > 0)
> fputc ('=', stderr);
> diff --git a/malloc/memusagestat.c b/malloc/memusagestat.c
> index b244ef6..8c43b5d 100644
> --- a/malloc/memusagestat.c
> +++ b/malloc/memusagestat.c
> @@ -53,24 +53,24 @@
> /* Definitions of arguments for argp functions. */
> static const struct argp_option options[] =
> {
> - { "output", 'o', N_("FILE"), 0, N_("Name output file") },
> - { "string", 's', N_("STRING"), 0, N_("Title string used in output graphic") },
> - { "time", 't', NULL, 0, N_("\
> + { "output", 'o', N_ ("FILE"), 0, N_ ("Name output file") },
> + { "string", 's', N_ ("STRING"), 0, N_ ("Title string used in output graphic") },
> + { "time", 't', NULL, 0, N_ (" \
> Generate output linear to time (default is linear to number of function calls)\
> ") },
> { "total", 'T', NULL, 0,
> - N_("Also draw graph for total memory consumption") },
> - { "x-size", 'x', N_("VALUE"), 0,
> - N_("Make output graphic VALUE pixels wide") },
> - { "y-size", 'y', "VALUE", 0, N_("Make output graphic VALUE pixels high") },
> + N_ ("Also draw graph for total memory consumption") },
> + { "x-size", 'x', N_ ("VALUE"), 0,
> + N_ ("Make output graphic VALUE pixels wide") },
> + { "y-size", 'y', "VALUE", 0, N_ ("Make output graphic VALUE pixels high") },
> { NULL, 0, NULL, 0, NULL }
> };
>
> /* Short description of program. */
> -static const char doc[] = N_("Generate graphic from memory profiling data");
> +static const char doc[] = N_ ("Generate graphic from memory profiling data");
>
> /* Strings for arguments in help texts. */
> -static const char args_doc[] = N_("DATAFILE [OUTFILE]");
> +static const char args_doc[] = N_ ("DATAFILE [OUTFILE]");
>
> /* Prototype for option handler. */
> static error_t parse_opt (int key, char *arg, struct argp_state *state);
> @@ -152,7 +152,7 @@ main (int argc, char *argv[])
> if (remaining >= argc || remaining + 2 < argc)
> {
> argp_help (&argp, stdout, ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR,
> - program_invocation_short_name);
> + program_invocation_short_name);
> exit (1);
> }
>
> @@ -197,21 +197,21 @@ main (int argc, char *argv[])
> if (maxsize_heap == 0 && maxsize_stack == 0)
> {
> /* The program aborted before memusage was able to write the
> - information about the maximum heap and stack use. Repair
> - the file now. */
> + information about the maximum heap and stack use. Repair
> + the file now. */
> struct entry next;
>
> while (1)
> - {
> - if (read (fd, &next, sizeof (next)) == 0)
> - break;
> - if (next.heap > maxsize_heap)
> - maxsize_heap = next.heap;
> - if (next.stack > maxsize_stack)
> - maxsize_stack = next.stack;
> - if (maxsize_heap + maxsize_stack > maxsize_total)
> - maxsize_total = maxsize_heap + maxsize_stack;
> - }
> + {
> + if (read (fd, &next, sizeof (next)) == 0)
> + break;
> + if (next.heap > maxsize_heap)
> + maxsize_heap = next.heap;
> + if (next.stack > maxsize_stack)
> + maxsize_stack = next.stack;
> + if (maxsize_heap + maxsize_stack > maxsize_total)
> + maxsize_total = maxsize_heap + maxsize_stack;
> + }
>
> headent[0].stack = maxsize_total;
> headent[1].heap = maxsize_heap;
> @@ -227,7 +227,7 @@ main (int argc, char *argv[])
> if (also_total)
> {
> /* We use one scale and since we also draw the total amount of
> - memory used we have to adapt the maximum. */
> + memory used we have to adapt the maximum. */
> maxsize_heap = maxsize_total;
> maxsize_stack = maxsize_total;
> }
> @@ -292,145 +292,145 @@ main (int argc, char *argv[])
> }
>
> gdImageString (im_out, gdFontSmall, 38, ysize - 14, (unsigned char *) "0",
> - blue);
> + blue);
> snprintf (buf, sizeof (buf), heap_format, 0);
> gdImageString (im_out, gdFontSmall, maxsize_heap < 1024 ? 32 : 26,
> - ysize - 26, (unsigned char *) buf, red);
> + ysize - 26, (unsigned char *) buf, red);
> snprintf (buf, sizeof (buf), stack_format, 0);
> gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26,
> - (unsigned char *) buf, green);
> + (unsigned char *) buf, green);
>
> if (string != NULL)
> gdImageString (im_out, gdFontLarge, (xsize - strlen (string) * 8) / 2,
> - 2, (unsigned char *) string, green);
> + 2, (unsigned char *) string, green);
>
> gdImageStringUp (im_out, gdFontSmall, 1, ysize / 2 - 10,
> - (unsigned char *) "allocated", red);
> + (unsigned char *) "allocated", red);
> gdImageStringUp (im_out, gdFontSmall, 11, ysize / 2 - 10,
> - (unsigned char *) "memory", red);
> + (unsigned char *) "memory", red);
>
> gdImageStringUp (im_out, gdFontSmall, xsize - 39, ysize / 2 - 10,
> - (unsigned char *) "used", green);
> + (unsigned char *) "used", green);
> gdImageStringUp (im_out, gdFontSmall, xsize - 27, ysize / 2 - 10,
> - (unsigned char *) "stack", green);
> + (unsigned char *) "stack", green);
>
> snprintf (buf, sizeof (buf), heap_format, maxsize_heap / heap_scale);
> gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6, 14,
> - (unsigned char *) buf, red);
> + (unsigned char *) buf, red);
> snprintf (buf, sizeof (buf), stack_format, maxsize_stack / stack_scale);
> gdImageString (im_out, gdFontSmall, xsize - 37, 14,
> - (unsigned char *) buf, green);
> + (unsigned char *) buf, green);
>
> for (line = 1; line <= 3; ++line)
> {
> if (maxsize_heap > 0)
> - {
> - cnt = (((ysize - 40) * (maxsize_heap / 4 * line / heap_scale))
> - / (maxsize_heap / heap_scale));
> - gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
> - ysize - 20 - cnt, red);
> - snprintf (buf, sizeof (buf), heap_format,
> - maxsize_heap / 4 * line / heap_scale);
> - gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
> - ysize - 26 - cnt, (unsigned char *) buf, red);
> - }
> + {
> + cnt = (((ysize - 40) * (maxsize_heap / 4 * line / heap_scale))
> + / (maxsize_heap / heap_scale));
> + gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
> + ysize - 20 - cnt, red);
> + snprintf (buf, sizeof (buf), heap_format,
> + maxsize_heap / 4 * line / heap_scale);
> + gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
> + ysize - 26 - cnt, (unsigned char *) buf, red);
> + }
> else
> - cnt = 0;
> + cnt = 0;
>
> if (maxsize_stack > 0)
> - cnt2 = (((ysize - 40) * (maxsize_stack / 4 * line / stack_scale))
> - / (maxsize_stack / stack_scale));
> + cnt2 = (((ysize - 40) * (maxsize_stack / 4 * line / stack_scale))
> + / (maxsize_stack / stack_scale));
> else
> - cnt2 = 0;
> + cnt2 = 0;
>
> if (cnt != cnt2)
> - gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
> - ysize - 20 - cnt2, green);
> + gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
> + ysize - 20 - cnt2, green);
> snprintf (buf, sizeof (buf), stack_format, maxsize_stack / 4 * line /
> - stack_scale);
> + stack_scale);
> gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,
> - (unsigned char *) buf, green);
> + (unsigned char *) buf, green);
> }
>
> snprintf (buf, sizeof (buf), "%llu", (unsigned long long) total);
> gdImageString (im_out, gdFontSmall, xsize - 50, ysize - 14,
> - (unsigned char *) buf, blue);
> + (unsigned char *) buf, blue);
>
> if (!time_based)
> {
> uint64_t previously = start_time;
>
> gdImageString (im_out, gdFontSmall, 40 + (xsize - 32 * 6 - 80) / 2,
> - ysize - 12,
> - (unsigned char *) "# memory handling function calls",
> - blue);
> + ysize - 12,
> + (unsigned char *) "# memory handling function calls",
> + blue);
>
>
> last_stack = last_heap = last_total = ysize - 20;
> for (cnt = 1; cnt <= total; ++cnt)
> - {
> - struct entry entry;
> - size_t new[2];
> - uint64_t now;
> -
> - read (fd, &entry, sizeof (entry));
> -
> - now = ((uint64_t) entry.time_high) << 32 | entry.time_low;
> -
> - if ((((previously - start_time) * 100) / total_time) % 10 < 5)
> - gdImageFilledRectangle (im_out,
> - 40 + ((cnt - 1) * (xsize - 80)) / total,
> - ysize - 19,
> - 39 + (cnt * (xsize - 80)) / total,
> - ysize - 14, yellow);
> - previously = now;
> -
> - if (also_total && maxsize_heap > 0)
> - {
> - size_t new3;
> -
> - new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
> - * (entry.heap + entry.stack))
> - / maxsize_heap);
> - gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
> - last_total,
> - 40 + ((xsize - 80) * cnt) / total, new3,
> - black);
> - last_total = new3;
> - }
> -
> - if (maxsize_heap > 0)
> - {
> - new[0] = ((ysize - 20)
> - - ((((unsigned long long int) (ysize - 40))
> - * entry.heap) / maxsize_heap));
> - gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
> - last_heap, 40 + ((xsize - 80) * cnt) / total,
> - new[0], red);
> - last_heap = new[0];
> - }
> -
> - if (maxsize_stack > 0)
> - {
> - new[1] = ((ysize - 20)
> - - ((((unsigned long long int) (ysize - 40))
> - * entry.stack) / maxsize_stack));
> - gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
> - last_stack, 40 + ((xsize - 80) * cnt) / total,
> - new[1], green);
> - last_stack = new[1];
> - }
> - }
> + {
> + struct entry entry;
> + size_t new[2];
> + uint64_t now;
> +
> + read (fd, &entry, sizeof (entry));
> +
> + now = ((uint64_t) entry.time_high) << 32 | entry.time_low;
> +
> + if ((((previously - start_time) * 100) / total_time) % 10 < 5)
> + gdImageFilledRectangle (im_out,
> + 40 + ((cnt - 1) * (xsize - 80)) / total,
> + ysize - 19,
> + 39 + (cnt * (xsize - 80)) / total,
> + ysize - 14, yellow);
> + previously = now;
> +
> + if (also_total && maxsize_heap > 0)
> + {
> + size_t new3;
> +
> + new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
> + * (entry.heap + entry.stack))
> + / maxsize_heap);
> + gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
> + last_total,
> + 40 + ((xsize - 80) * cnt) / total, new3,
> + black);
> + last_total = new3;
> + }
> +
> + if (maxsize_heap > 0)
> + {
> + new[0] = ((ysize - 20)
> + - ((((unsigned long long int) (ysize - 40))
> + * entry.heap) / maxsize_heap));
> + gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
> + last_heap, 40 + ((xsize - 80) * cnt) / total,
> + new[0], red);
> + last_heap = new[0];
> + }
> +
> + if (maxsize_stack > 0)
> + {
> + new[1] = ((ysize - 20)
> + - ((((unsigned long long int) (ysize - 40))
> + * entry.stack) / maxsize_stack));
> + gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
> + last_stack, 40 + ((xsize - 80) * cnt) / total,
> + new[1], green);
> + last_stack = new[1];
> + }
> + }
>
> cnt = 0;
> while (cnt < total)
> - {
> - gdImageLine (im_out, 40 + ((xsize - 80) * cnt) / total, ysize - 20,
> - 40 + ((xsize - 80) * cnt) / total, ysize - 15, blue);
> - cnt += MAX (1, total / 20);
> - }
> + {
> + gdImageLine (im_out, 40 + ((xsize - 80) * cnt) / total, ysize - 20,
> + 40 + ((xsize - 80) * cnt) / total, ysize - 15, blue);
> + cnt += MAX (1, total / 20);
> + }
> gdImageLine (im_out, xsize - 40, ysize - 20, xsize - 40, ysize - 15,
> - blue);
> + blue);
> }
> else
> {
> @@ -438,67 +438,67 @@ main (int argc, char *argv[])
> size_t last_xpos = 40;
>
> gdImageString (im_out, gdFontSmall, 40 + (xsize - 39 * 6 - 80) / 2,
> - ysize - 12,
> - (unsigned char *) "\
> + ysize - 12,
> + (unsigned char *) " \
> # memory handling function calls / time", blue);
>
> for (cnt = 0; cnt < 20; cnt += 2)
> - gdImageFilledRectangle (im_out,
> - 40 + (cnt * (xsize - 80)) / 20, ysize - 19,
> - 39 + ((cnt + 1) * (xsize - 80)) / 20,
> - ysize - 14, yellow);
> + gdImageFilledRectangle (im_out,
> + 40 + (cnt * (xsize - 80)) / 20, ysize - 19,
> + 39 + ((cnt + 1) * (xsize - 80)) / 20,
> + ysize - 14, yellow);
>
> last_stack = last_heap = last_total = ysize - 20;
> for (cnt = 1; cnt <= total; ++cnt)
> - {
> - struct entry entry;
> - size_t new[2];
> - size_t xpos;
> - uint64_t now;
> -
> - read (fd, &entry, sizeof (entry));
> -
> - now = ((uint64_t) entry.time_high) << 32 | entry.time_low;
> - xpos = 40 + ((xsize - 80) * (now - start_time)) / total_time;
> -
> - if (cnt == next_tick)
> - {
> - gdImageLine (im_out, xpos, ysize - 20, xpos, ysize - 15, blue);
> - next_tick += MAX (1, total / 20);
> - }
> -
> - if (also_total && maxsize_heap > 0)
> - {
> - size_t new3;
> -
> - new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
> - * (entry.heap + entry.stack))
> - / maxsize_heap);
> - gdImageLine (im_out, last_xpos, last_total, xpos, new3, black);
> - last_total = new3;
> - }
> -
> - if (maxsize_heap > 0)
> - {
> - new[0] = ((ysize - 20)
> - - ((((unsigned long long int) (ysize - 40))
> - * entry.heap) / maxsize_heap));
> - gdImageLine (im_out, last_xpos, last_heap, xpos, new[0], red);
> - last_heap = new[0];
> - }
> -
> - if (maxsize_stack > 0)
> - {
> - new[1] = ((ysize - 20)
> - - ((((unsigned long long int) (ysize - 40))
> - * entry.stack) / maxsize_stack));
> - gdImageLine (im_out, last_xpos, last_stack, xpos, new[1],
> - green);
> - last_stack = new[1];
> - }
> -
> - last_xpos = xpos;
> - }
> + {
> + struct entry entry;
> + size_t new[2];
> + size_t xpos;
> + uint64_t now;
> +
> + read (fd, &entry, sizeof (entry));
> +
> + now = ((uint64_t) entry.time_high) << 32 | entry.time_low;
> + xpos = 40 + ((xsize - 80) * (now - start_time)) / total_time;
> +
> + if (cnt == next_tick)
> + {
> + gdImageLine (im_out, xpos, ysize - 20, xpos, ysize - 15, blue);
> + next_tick += MAX (1, total / 20);
> + }
> +
> + if (also_total && maxsize_heap > 0)
> + {
> + size_t new3;
> +
> + new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
> + * (entry.heap + entry.stack))
> + / maxsize_heap);
> + gdImageLine (im_out, last_xpos, last_total, xpos, new3, black);
> + last_total = new3;
> + }
> +
> + if (maxsize_heap > 0)
> + {
> + new[0] = ((ysize - 20)
> + - ((((unsigned long long int) (ysize - 40))
> + * entry.heap) / maxsize_heap));
> + gdImageLine (im_out, last_xpos, last_heap, xpos, new[0], red);
> + last_heap = new[0];
> + }
> +
> + if (maxsize_stack > 0)
> + {
> + new[1] = ((ysize - 20)
> + - ((((unsigned long long int) (ysize - 40))
> + * entry.stack) / maxsize_stack));
> + gdImageLine (im_out, last_xpos, last_stack, xpos, new[1],
> + green);
> + last_stack = new[1];
> + }
> +
> + last_xpos = xpos;
> + }
> }
>
> /* Write out the result. */
> @@ -537,12 +537,12 @@ parse_opt (int key, char *arg, struct argp_state *state)
> case 'x':
> xsize = atoi (arg);
> if (xsize == 0)
> - xsize = XSIZE;
> + xsize = XSIZE;
> break;
> case 'y':
> ysize = atoi (arg);
> if (ysize == 0)
> - ysize = XSIZE;
> + ysize = XSIZE;
> break;
> default:
> return ARGP_ERR_UNKNOWN;
> @@ -563,8 +563,10 @@ more_help (int key, const char *text, void *input)
> if (asprintf (&tp, gettext ("\
> For bug reporting instructions, please see:\n\
> %s.\n"), REPORT_BUGS_TO) < 0)
> - return NULL;
> + return NULL;
> +
> return tp;
> +
> default:
> break;
> }
> diff --git a/malloc/morecore.c b/malloc/morecore.c
> index 0a644c3..bd6e750 100644
> --- a/malloc/morecore.c
> +++ b/malloc/morecore.c
> @@ -15,27 +15,27 @@
> License along with the GNU C Library; if not, see
> <http://www.gnu.org/licenses/>. */
>
> -#ifndef _MALLOC_INTERNAL
> -#define _MALLOC_INTERNAL
> -#include <malloc.h>
> +#ifndef _MALLOC_INTERNAL
> +# define _MALLOC_INTERNAL
> +# include <malloc.h>
> #endif
>
> -#ifndef __GNU_LIBRARY__
> -#define __sbrk sbrk
> +#ifndef __GNU_LIBRARY__
> +# define __sbrk sbrk
> #endif
>
> #ifdef __GNU_LIBRARY__
> /* It is best not to declare this and cast its result on foreign operating
> systems with potentially hostile include files. */
>
> -#include <stddef.h>
> -#include <stdlib.h>
> +# include <stddef.h>
> +# include <stdlib.h>
> extern void *__sbrk (ptrdiff_t increment) __THROW;
> libc_hidden_proto (__sbrk)
> #endif
>
> #ifndef NULL
> -#define NULL 0
> +# define NULL 0
> #endif
>
> /* Allocate INCREMENT more bytes of data space,
> @@ -47,6 +47,7 @@ __default_morecore (ptrdiff_t increment)
> void *result = (void *) __sbrk (increment);
> if (result == (void *) -1)
> return NULL;
> +
> return result;
> }
> libc_hidden_def (__default_morecore)
> diff --git a/malloc/mtrace.c b/malloc/mtrace.c
> index ee94133..93229ed 100644
> --- a/malloc/mtrace.c
> +++ b/malloc/mtrace.c
> @@ -1,8 +1,8 @@
> /* More debugging hooks for `malloc'.
> Copyright (C) 1991-2013 Free Software Foundation, Inc.
> This file is part of the GNU C Library.
> - Written April 2, 1991 by John Gilmore of Cygnus Support.
> - Based on mcheck.c by Mike Haertel.
> + Written April 2, 1991 by John Gilmore of Cygnus Support.
> + Based on mcheck.c by Mike Haertel.
>
> The GNU C Library is free software; you can redistribute it and/or
> modify it under the terms of the GNU Lesser General Public
> @@ -18,11 +18,11 @@
> License along with the GNU C Library; if not, see
> <http://www.gnu.org/licenses/>. */
>
> -#ifndef _MALLOC_INTERNAL
> -#define _MALLOC_INTERNAL
> -#include <malloc.h>
> -#include <mcheck.h>
> -#include <bits/libc-lock.h>
> +#ifndef _MALLOC_INTERNAL
> +# define _MALLOC_INTERNAL
> +# include <malloc.h>
> +# include <mcheck.h>
> +# include <bits/libc-lock.h>
> #endif
>
> #include <dlfcn.h>
> @@ -48,7 +48,7 @@
> #define TRACE_BUFFER_SIZE 512
>
> static FILE *mallstream;
> -static const char mallenv[]= "MALLOC_TRACE";
> +static const char mallenv[] = "MALLOC_TRACE";
> static char *malloc_trace_buffer;
>
> __libc_lock_define_initialized (static, lock);
> @@ -60,9 +60,9 @@ __ptr_t mallwatch;
> static void (*tr_old_free_hook) (__ptr_t ptr, const __ptr_t);
> static __ptr_t (*tr_old_malloc_hook) (size_t size, const __ptr_t);
> static __ptr_t (*tr_old_realloc_hook) (__ptr_t ptr, size_t size,
> - const __ptr_t);
> + const __ptr_t);
> static __ptr_t (*tr_old_memalign_hook) (size_t __alignment, size_t __size,
> - const __ptr_t);
> + const __ptr_t);
>
> /* This function is called when the block being alloc'd, realloc'd, or
> freed has an address matching the variable "mallwatch". In a debugger,
> @@ -79,39 +79,38 @@ libc_hidden_def (tr_break)
>
> static void tr_where (const __ptr_t, Dl_info *) __THROW internal_function;
> static void
> -internal_function
> -tr_where (caller, info)
> - const __ptr_t caller;
> - Dl_info *info;
> +internal_function tr_where (caller, info)
> +const __ptr_t caller;
> +Dl_info *info;
> {
> if (caller != NULL)
> {
> if (info != NULL)
> - {
> - char *buf = (char *) "";
> - if (info->dli_sname != NULL)
> - {
> - size_t len = strlen (info->dli_sname);
> - buf = alloca (len + 6 + 2 * sizeof (void *));
> -
> - buf[0] = '(';
> - __stpcpy (_fitoa (caller >= (const __ptr_t) info->dli_saddr
> - ? caller - (const __ptr_t) info->dli_saddr
> - : (const __ptr_t) info->dli_saddr - caller,
> - __stpcpy (__mempcpy (buf + 1, info->dli_sname,
> - len),
> - caller >= (__ptr_t) info->dli_saddr
> - ? "+0x" : "-0x"),
> - 16, 0),
> - ")");
> - }
> -
> - fprintf (mallstream, "@ %s%s%s[%p] ",
> - info->dli_fname ?: "", info->dli_fname ? ":" : "",
> - buf, caller);
> - }
> + {
> + char *buf = (char *) "";
> + if (info->dli_sname != NULL)
> + {
> + size_t len = strlen (info->dli_sname);
> + buf = alloca (len + 6 + 2 * sizeof (void *));
> +
> + buf[0] = '(';
> + __stpcpy (_fitoa (caller >= (const __ptr_t) info->dli_saddr
> + ? caller - (const __ptr_t) info->dli_saddr
> + : (const __ptr_t) info->dli_saddr - caller,
> + __stpcpy (__mempcpy (buf + 1, info->dli_sname,
> + len),
> + caller >= (__ptr_t) info->dli_saddr
> + ? "+0x" : "-0x"),
> + 16, 0),
> + ")");
> + }
> +
> + fprintf (mallstream, "@ %s%s%s[%p] ",
> + info->dli_fname ? : "", info->dli_fname ? ":" : "",
> + buf, caller);
> + }
> else
> - fprintf (mallstream, "@ [%p] ", caller);
> + fprintf (mallstream, "@ [%p] ", caller);
> }
> }
>
> @@ -131,10 +130,9 @@ lock_and_info (const __ptr_t caller, Dl_info *mem)
>
>
> static void tr_freehook (__ptr_t, const __ptr_t) __THROW;
> -static void
> -tr_freehook (ptr, caller)
> - __ptr_t ptr;
> - const __ptr_t caller;
> +static void tr_freehook (ptr, caller)
> +__ptr_t ptr;
> +const __ptr_t caller;
> {
> if (ptr == NULL)
> return;
> @@ -152,7 +150,7 @@ tr_freehook (ptr, caller)
> }
> __free_hook = tr_old_free_hook;
> if (tr_old_free_hook != NULL)
> - (*tr_old_free_hook) (ptr, caller);
> + (*tr_old_free_hook)(ptr, caller);
> else
> free (ptr);
> __free_hook = tr_freehook;
> @@ -160,10 +158,9 @@ tr_freehook (ptr, caller)
> }
>
> static __ptr_t tr_mallochook (size_t, const __ptr_t) __THROW;
> -static __ptr_t
> -tr_mallochook (size, caller)
> - size_t size;
> - const __ptr_t caller;
> +static __ptr_t tr_mallochook (size, caller)
> +size_t size;
> +const __ptr_t caller;
> {
> __ptr_t hdr;
>
> @@ -172,7 +169,7 @@ tr_mallochook (size, caller)
>
> __malloc_hook = tr_old_malloc_hook;
> if (tr_old_malloc_hook != NULL)
> - hdr = (__ptr_t) (*tr_old_malloc_hook) (size, caller);
> + hdr = (__ptr_t) (*tr_old_malloc_hook)(size, caller);
> else
> hdr = (__ptr_t) malloc (size);
> __malloc_hook = tr_mallochook;
> @@ -190,12 +187,11 @@ tr_mallochook (size, caller)
> }
>
> static __ptr_t tr_reallochook (__ptr_t, size_t, const __ptr_t)
> - __THROW;
> -static __ptr_t
> -tr_reallochook (ptr, size, caller)
> - __ptr_t ptr;
> - size_t size;
> - const __ptr_t caller;
> +__THROW;
> +static __ptr_t tr_reallochook (ptr, size, caller)
> +__ptr_t ptr;
> +size_t size;
> +const __ptr_t caller;
> {
> __ptr_t hdr;
>
> @@ -209,7 +205,7 @@ tr_reallochook (ptr, size, caller)
> __malloc_hook = tr_old_malloc_hook;
> __realloc_hook = tr_old_realloc_hook;
> if (tr_old_realloc_hook != NULL)
> - hdr = (__ptr_t) (*tr_old_realloc_hook) (ptr, size, caller);
> + hdr = (__ptr_t) (*tr_old_realloc_hook)(ptr, size, caller);
> else
> hdr = (__ptr_t) realloc (ptr, size);
> __free_hook = tr_freehook;
> @@ -220,10 +216,10 @@ tr_reallochook (ptr, size, caller)
> if (hdr == NULL)
> {
> if (size != 0)
> - /* Failed realloc. */
> - fprintf (mallstream, "! %p %#lx\n", ptr, (unsigned long int) size);
> + /* Failed realloc. */
> + fprintf (mallstream, "! %p %#lx\n", ptr, (unsigned long int) size);
> else
> - fprintf (mallstream, "- %p\n", ptr);
> + fprintf (mallstream, "- %p\n", ptr);
> }
> else if (ptr == NULL)
> fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
> @@ -243,11 +239,10 @@ tr_reallochook (ptr, size, caller)
> }
>
> static __ptr_t tr_memalignhook (size_t, size_t,
> - const __ptr_t) __THROW;
> -static __ptr_t
> -tr_memalignhook (alignment, size, caller)
> - size_t alignment, size;
> - const __ptr_t caller;
> + const __ptr_t) __THROW;
> +static __ptr_t tr_memalignhook (alignment, size, caller)
> +size_t alignment, size;
> +const __ptr_t caller;
> {
> __ptr_t hdr;
>
> @@ -257,7 +252,7 @@ tr_memalignhook (alignment, size, caller)
> __memalign_hook = tr_old_memalign_hook;
> __malloc_hook = tr_old_malloc_hook;
> if (tr_old_memalign_hook != NULL)
> - hdr = (__ptr_t) (*tr_old_memalign_hook) (alignment, size, caller);
> + hdr = (__ptr_t) (*tr_old_memalign_hook)(alignment, size, caller);
> else
> hdr = (__ptr_t) memalign (alignment, size);
> __memalign_hook = tr_memalignhook;
> @@ -321,44 +316,44 @@ mtrace (void)
> {
> char *mtb = malloc (TRACE_BUFFER_SIZE);
> if (mtb == NULL)
> - return;
> + return;
>
> mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "wce");
> if (mallstream != NULL)
> - {
> + {
> #ifndef __ASSUME_O_CLOEXEC
> - /* Make sure we close the file descriptor on exec. */
> - int flags = __fcntl (fileno (mallstream), F_GETFD, 0);
> - if (flags >= 0)
> - {
> - flags |= FD_CLOEXEC;
> - __fcntl (fileno (mallstream), F_SETFD, flags);
> - }
> + /* Make sure we close the file descriptor on exec. */
> + int flags = __fcntl (fileno (mallstream), F_GETFD, 0);
> + if (flags >= 0)
> + {
> + flags |= FD_CLOEXEC;
> + __fcntl (fileno (mallstream), F_SETFD, flags);
> + }
> #endif
> - /* Be sure it doesn't malloc its buffer! */
> - malloc_trace_buffer = mtb;
> - setvbuf (mallstream, malloc_trace_buffer, _IOFBF, TRACE_BUFFER_SIZE);
> - fprintf (mallstream, "= Start\n");
> - tr_old_free_hook = __free_hook;
> - __free_hook = tr_freehook;
> - tr_old_malloc_hook = __malloc_hook;
> - __malloc_hook = tr_mallochook;
> - tr_old_realloc_hook = __realloc_hook;
> - __realloc_hook = tr_reallochook;
> - tr_old_memalign_hook = __memalign_hook;
> - __memalign_hook = tr_memalignhook;
> + /* Be sure it doesn't malloc its buffer! */
> + malloc_trace_buffer = mtb;
> + setvbuf (mallstream, malloc_trace_buffer, _IOFBF, TRACE_BUFFER_SIZE);
> + fprintf (mallstream, "= Start\n");
> + tr_old_free_hook = __free_hook;
> + __free_hook = tr_freehook;
> + tr_old_malloc_hook = __malloc_hook;
> + __malloc_hook = tr_mallochook;
> + tr_old_realloc_hook = __realloc_hook;
> + __realloc_hook = tr_reallochook;
> + tr_old_memalign_hook = __memalign_hook;
> + __memalign_hook = tr_memalignhook;
> #ifdef _LIBC
> - if (!added_atexit_handler)
> - {
> - extern void *__dso_handle __attribute__ ((__weak__));
> - added_atexit_handler = 1;
> - __cxa_atexit ((void (*) (void *)) release_libc_mem, NULL,
> - &__dso_handle ? __dso_handle : NULL);
> - }
> + if (!added_atexit_handler)
> + {
> + extern void *__dso_handle __attribute__ ((__weak__));
> + added_atexit_handler = 1;
> + __cxa_atexit ((void (*)(void *))release_libc_mem, NULL,
> + &__dso_handle ? __dso_handle : NULL);
> + }
> #endif
> - }
> + }
> else
> - free (mtb);
> + free (mtb);
> }
> }
>
> diff --git a/malloc/obstack.c b/malloc/obstack.c
> index 69320ca..37d98a4 100644
> --- a/malloc/obstack.c
> +++ b/malloc/obstack.c
> @@ -42,7 +42,7 @@
> program understand `configure --with-gnu-libc' and omit the object
> files, it is simpler to just do this in the source for each such file. */
>
> -#include <stdio.h> /* Random thing to get __GNU_LIBRARY__. */
> +#include <stdio.h> /* Random thing to get __GNU_LIBRARY__. */
> #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1
> # include <gnu-versions.h>
> # if _GNU_OBSTACK_INTERFACE_VERSION == OBSTACK_INTERFACE_VERSION
> @@ -78,10 +78,10 @@ struct fooalign
> But in fact it might be less smart and round addresses to as much as
> DEFAULT_ROUNDING. So we prepare for it to do that. */
> enum
> - {
> - DEFAULT_ALIGNMENT = offsetof (struct fooalign, u),
> - DEFAULT_ROUNDING = sizeof (union fooround)
> - };
> +{
> + DEFAULT_ALIGNMENT = offsetof (struct fooalign, u),
> + DEFAULT_ROUNDING = sizeof (union fooround)
> +};
>
> /* When we copy a long block of data, this is the unit to do it with.
> On some machines, copying successive ints does not work;
> @@ -127,19 +127,19 @@ compat_symbol (libc, _obstack_compat, _obstack, GLIBC_2_0);
> do not allow (expr) ? void : void. */
>
> # define CALL_CHUNKFUN(h, size) \
> - (((h) -> use_extra_arg) \
> - ? (*(h)->chunkfun) ((h)->extra_arg, (size)) \
> - : (*(struct _obstack_chunk *(*) (long)) (h)->chunkfun) ((size)))
> + (((h)->use_extra_arg) \
> + ? (*(h)->chunkfun)((h)->extra_arg, (size)) \
> + : (*(struct _obstack_chunk *(*)(long))(h)->chunkfun)((size)))
>
> # define CALL_FREEFUN(h, old_chunk) \
> do { \
> - if ((h) -> use_extra_arg) \
> - (*(h)->freefun) ((h)->extra_arg, (old_chunk)); \
> - else \
> - (*(void (*) (void *)) (h)->freefun) ((old_chunk)); \
> - } while (0)
> + if ((h)->use_extra_arg) \
> + (*(h)->freefun)((h)->extra_arg, (old_chunk)); \
> + else \
> + (*(void (*)(void *))(h)->freefun)((old_chunk)); \
> + } while (0)
> +
>
> -
> /* Initialize an obstack H for use. Specify chunk size SIZE (0 means default).
> Objects start on multiples of ALIGNMENT (0 means use default).
> CHUNKFUN is the function to use to allocate chunks,
> @@ -150,44 +150,44 @@ compat_symbol (libc, _obstack_compat, _obstack, GLIBC_2_0);
>
> int
> _obstack_begin (struct obstack *h,
> - int size, int alignment,
> - void *(*chunkfun) (long),
> - void (*freefun) (void *))
> + int size, int alignment,
> + void *(*chunkfun)(long),
> + void (*freefun)(void *))
> {
> struct _obstack_chunk *chunk; /* points to new chunk */
>
> if (alignment == 0)
> alignment = DEFAULT_ALIGNMENT;
> if (size == 0)
> - /* Default size is what GNU malloc can fit in a 4096-byte block. */
> + /* Default size is what GNU malloc can fit in a 4096-byte block. */
> {
> /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc.
> - Use the values for range checking, because if range checking is off,
> - the extra bytes won't be missed terribly, but if range checking is on
> - and we used a larger request, a whole extra 4096 bytes would be
> - allocated.
> + Use the values for range checking, because if range checking is off,
> + the extra bytes won't be missed terribly, but if range checking is on
> + and we used a larger request, a whole extra 4096 bytes would be
> + allocated.
>
> - These number are irrelevant to the new GNU malloc. I suspect it is
> - less sensitive to the size of the request. */
> + These number are irrelevant to the new GNU malloc. I suspect it is
> + less sensitive to the size of the request. */
> int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1))
> - + 4 + DEFAULT_ROUNDING - 1)
> - & ~(DEFAULT_ROUNDING - 1));
> + + 4 + DEFAULT_ROUNDING - 1)
> + & ~(DEFAULT_ROUNDING - 1));
> size = 4096 - extra;
> }
>
> - h->chunkfun = (struct _obstack_chunk * (*)(void *, long)) chunkfun;
> - h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun;
> + h->chunkfun = (struct _obstack_chunk * (*)(void *, long))chunkfun;
> + h->freefun = (void (*)(void *, struct _obstack_chunk *))freefun;
> h->chunk_size = size;
> h->alignment_mask = alignment - 1;
> h->use_extra_arg = 0;
>
> - chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size);
> + chunk = h->chunk = CALL_CHUNKFUN (h, h->chunk_size);
> if (!chunk)
> - (*obstack_alloc_failed_handler) ();
> + (*obstack_alloc_failed_handler)();
> h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents,
> - alignment - 1);
> + alignment - 1);
> h->chunk_limit = chunk->limit
> - = (char *) chunk + h->chunk_size;
> + = (char *) chunk + h->chunk_size;
> chunk->prev = 0;
> /* The initial chunk now contains no empty object. */
> h->maybe_empty_object = 0;
> @@ -197,45 +197,45 @@ _obstack_begin (struct obstack *h,
>
> int
> _obstack_begin_1 (struct obstack *h, int size, int alignment,
> - void *(*chunkfun) (void *, long),
> - void (*freefun) (void *, void *),
> - void *arg)
> + void *(*chunkfun)(void *, long),
> + void (*freefun)(void *, void *),
> + void *arg)
> {
> struct _obstack_chunk *chunk; /* points to new chunk */
>
> if (alignment == 0)
> alignment = DEFAULT_ALIGNMENT;
> if (size == 0)
> - /* Default size is what GNU malloc can fit in a 4096-byte block. */
> + /* Default size is what GNU malloc can fit in a 4096-byte block. */
> {
> /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc.
> - Use the values for range checking, because if range checking is off,
> - the extra bytes won't be missed terribly, but if range checking is on
> - and we used a larger request, a whole extra 4096 bytes would be
> - allocated.
> + Use the values for range checking, because if range checking is off,
> + the extra bytes won't be missed terribly, but if range checking is on
> + and we used a larger request, a whole extra 4096 bytes would be
> + allocated.
>
> - These number are irrelevant to the new GNU malloc. I suspect it is
> - less sensitive to the size of the request. */
> + These number are irrelevant to the new GNU malloc. I suspect it is
> + less sensitive to the size of the request. */
> int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1))
> - + 4 + DEFAULT_ROUNDING - 1)
> - & ~(DEFAULT_ROUNDING - 1));
> + + 4 + DEFAULT_ROUNDING - 1)
> + & ~(DEFAULT_ROUNDING - 1));
> size = 4096 - extra;
> }
>
> - h->chunkfun = (struct _obstack_chunk * (*)(void *,long)) chunkfun;
> - h->freefun = (void (*) (void *, struct _obstack_chunk *)) freefun;
> + h->chunkfun = (struct _obstack_chunk * (*)(void *, long))chunkfun;
> + h->freefun = (void (*)(void *, struct _obstack_chunk *))freefun;
> h->chunk_size = size;
> h->alignment_mask = alignment - 1;
> h->extra_arg = arg;
> h->use_extra_arg = 1;
>
> - chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size);
> + chunk = h->chunk = CALL_CHUNKFUN (h, h->chunk_size);
> if (!chunk)
> - (*obstack_alloc_failed_handler) ();
> + (*obstack_alloc_failed_handler)();
> h->next_free = h->object_base = __PTR_ALIGN ((char *) chunk, chunk->contents,
> - alignment - 1);
> + alignment - 1);
> h->chunk_limit = chunk->limit
> - = (char *) chunk + h->chunk_size;
> + = (char *) chunk + h->chunk_size;
> chunk->prev = 0;
> /* The initial chunk now contains no empty object. */
> h->maybe_empty_object = 0;
> @@ -254,7 +254,7 @@ _obstack_newchunk (struct obstack *h, int length)
> {
> struct _obstack_chunk *old_chunk = h->chunk;
> struct _obstack_chunk *new_chunk;
> - long new_size;
> + long new_size;
> long obj_size = h->next_free - h->object_base;
> long i;
> long already;
> @@ -268,7 +268,7 @@ _obstack_newchunk (struct obstack *h, int length)
> /* Allocate and initialize the new chunk. */
> new_chunk = CALL_CHUNKFUN (h, new_size);
> if (!new_chunk)
> - (*obstack_alloc_failed_handler) ();
> + (*obstack_alloc_failed_handler)();
> h->chunk = new_chunk;
> new_chunk->prev = old_chunk;
> new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;
> @@ -283,12 +283,12 @@ _obstack_newchunk (struct obstack *h, int length)
> if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT)
> {
> for (i = obj_size / sizeof (COPYING_UNIT) - 1;
> - i >= 0; i--)
> - ((COPYING_UNIT *)object_base)[i]
> - = ((COPYING_UNIT *)h->object_base)[i];
> + i >= 0; i--)
> + ((COPYING_UNIT *) object_base)[i]
> + = ((COPYING_UNIT *) h->object_base)[i];
> /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT,
> - but that can cross a page boundary on a machine
> - which does not do strict alignment for COPYING_UNITS. */
> + but that can cross a page boundary on a machine
> + which does not do strict alignment for COPYING_UNITS. */
> already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT);
> }
> else
> @@ -300,10 +300,10 @@ _obstack_newchunk (struct obstack *h, int length)
> /* If the object just copied was the only data in OLD_CHUNK,
> free that chunk and remove it from the chain.
> But not if that chunk might contain an empty object. */
> - if (! h->maybe_empty_object
> + if (!h->maybe_empty_object
> && (h->object_base
> - == __PTR_ALIGN ((char *) old_chunk, old_chunk->contents,
> - h->alignment_mask)))
> + == __PTR_ALIGN ((char *) old_chunk, old_chunk->contents,
> + h->alignment_mask)))
> {
> new_chunk->prev = old_chunk->prev;
> CALL_FREEFUN (h, old_chunk);
> @@ -329,8 +329,8 @@ int _obstack_allocated_p (struct obstack *h, void *obj);
> int
> _obstack_allocated_p (struct obstack *h, void *obj)
> {
> - struct _obstack_chunk *lp; /* below addr of any objects in this chunk */
> - struct _obstack_chunk *plp; /* point to previous chunk if any */
> + struct _obstack_chunk *lp; /* below addr of any objects in this chunk */
> + struct _obstack_chunk *plp; /* point to previous chunk if any */
>
> lp = (h)->chunk;
> /* We use >= rather than > since the object cannot be exactly at
> @@ -343,7 +343,7 @@ _obstack_allocated_p (struct obstack *h, void *obj)
> }
> return lp != 0;
> }
> -
> +
> /* Free objects in obstack H, including OBJ and everything allocate
> more recently than OBJ. If OBJ is zero, free everything in H. */
>
> @@ -352,8 +352,8 @@ _obstack_allocated_p (struct obstack *h, void *obj)
> void
> obstack_free (struct obstack *h, void *obj)
> {
> - struct _obstack_chunk *lp; /* below addr of any objects in this chunk */
> - struct _obstack_chunk *plp; /* point to previous chunk if any */
> + struct _obstack_chunk *lp; /* below addr of any objects in this chunk */
> + struct _obstack_chunk *plp; /* point to previous chunk if any */
>
> lp = h->chunk;
> /* We use >= because there cannot be an object at the beginning of a chunk.
> @@ -365,7 +365,7 @@ obstack_free (struct obstack *h, void *obj)
> CALL_FREEFUN (h, lp);
> lp = plp;
> /* If we switch chunks, we can't tell whether the new current
> - chunk contains an empty object, so assume that it may. */
> + chunk contains an empty object, so assume that it may. */
> h->maybe_empty_object = 1;
> }
> if (lp)
> @@ -384,11 +384,11 @@ obstack_free (struct obstack *h, void *obj)
> called by non-GCC compilers. */
> strong_alias (obstack_free, _obstack_free)
> # endif
> -
> +
> int
> _obstack_memory_used (struct obstack *h)
> {
> - struct _obstack_chunk* lp;
> + struct _obstack_chunk *lp;
> int nbytes = 0;
>
> for (lp = h->chunk; lp != 0; lp = lp->prev)
> @@ -397,7 +397,7 @@ _obstack_memory_used (struct obstack *h)
> }
> return nbytes;
> }
> -
> +
> /* Define the error handler. */
> # ifdef _LIBC
> # include <libintl.h>
> @@ -429,11 +429,10 @@ print_and_abort (void)
> like this and the translation should be reused instead of creating
> a very similar string which requires a separate translation. */
> # ifdef _LIBC
> - (void) __fxprintf (NULL, "%s\n", _("memory exhausted"));
> + (void) __fxprintf (NULL, "%s\n", _ ("memory exhausted"));
> # else
> - fprintf (stderr, "%s\n", _("memory exhausted"));
> + fprintf (stderr, "%s\n", _ ("memory exhausted"));
> # endif
> exit (obstack_exit_failure);
> }
> -
> -#endif /* !ELIDE_CODE */
> +#endif /* !ELIDE_CODE */
> diff --git a/malloc/obstack.h b/malloc/obstack.h
> index e786d1f..6efd47d 100644
> --- a/malloc/obstack.h
> +++ b/malloc/obstack.h
> @@ -18,85 +18,85 @@
>
> /* Summary:
>
> -All the apparent functions defined here are macros. The idea
> -is that you would use these pre-tested macros to solve a
> -very specific set of problems, and they would run fast.
> -Caution: no side-effects in arguments please!! They may be
> -evaluated MANY times!!
> -
> -These macros operate a stack of objects. Each object starts life
> -small, and may grow to maturity. (Consider building a word syllable
> -by syllable.) An object can move while it is growing. Once it has
> -been "finished" it never changes address again. So the "top of the
> -stack" is typically an immature growing object, while the rest of the
> -stack is of mature, fixed size and fixed address objects.
> -
> -These routines grab large chunks of memory, using a function you
> -supply, called `obstack_chunk_alloc'. On occasion, they free chunks,
> -by calling `obstack_chunk_free'. You must define them and declare
> -them before using any obstack macros.
> -
> -Each independent stack is represented by a `struct obstack'.
> -Each of the obstack macros expects a pointer to such a structure
> -as the first argument.
> -
> -One motivation for this package is the problem of growing char strings
> -in symbol tables. Unless you are "fascist pig with a read-only mind"
> ---Gosper's immortal quote from HAKMEM item 154, out of context--you
> -would not like to put any arbitrary upper limit on the length of your
> -symbols.
> -
> -In practice this often means you will build many short symbols and a
> -few long symbols. At the time you are reading a symbol you don't know
> -how long it is. One traditional method is to read a symbol into a
> -buffer, realloc()ating the buffer every time you try to read a symbol
> -that is longer than the buffer. This is beaut, but you still will
> -want to copy the symbol from the buffer to a more permanent
> -symbol-table entry say about half the time.
> -
> -With obstacks, you can work differently. Use one obstack for all symbol
> -names. As you read a symbol, grow the name in the obstack gradually.
> -When the name is complete, finalize it. Then, if the symbol exists already,
> -free the newly read name.
> -
> -The way we do this is to take a large chunk, allocating memory from
> -low addresses. When you want to build a symbol in the chunk you just
> -add chars above the current "high water mark" in the chunk. When you
> -have finished adding chars, because you got to the end of the symbol,
> -you know how long the chars are, and you can create a new object.
> -Mostly the chars will not burst over the highest address of the chunk,
> -because you would typically expect a chunk to be (say) 100 times as
> -long as an average object.
> -
> -In case that isn't clear, when we have enough chars to make up
> -the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
> -so we just point to it where it lies. No moving of chars is
> -needed and this is the second win: potentially long strings need
> -never be explicitly shuffled. Once an object is formed, it does not
> -change its address during its lifetime.
> -
> -When the chars burst over a chunk boundary, we allocate a larger
> -chunk, and then copy the partly formed object from the end of the old
> -chunk to the beginning of the new larger chunk. We then carry on
> -accreting characters to the end of the object as we normally would.
> -
> -A special macro is provided to add a single char at a time to a
> -growing object. This allows the use of register variables, which
> -break the ordinary 'growth' macro.
> -
> -Summary:
> - We allocate large chunks.
> - We carve out one object at a time from the current chunk.
> - Once carved, an object never moves.
> - We are free to append data of any size to the currently
> - growing object.
> - Exactly one object is growing in an obstack at any one time.
> - You can run one obstack per control block.
> - You may have as many control blocks as you dare.
> - Because of the way we do it, you can `unwind' an obstack
> - back to a previous state. (You may remove objects much
> - as you would with a stack.)
> -*/
> + All the apparent functions defined here are macros. The idea
> + is that you would use these pre-tested macros to solve a
> + very specific set of problems, and they would run fast.
> + Caution: no side-effects in arguments please!! They may be
> + evaluated MANY times!!
> +
> + These macros operate a stack of objects. Each object starts life
> + small, and may grow to maturity. (Consider building a word syllable
> + by syllable.) An object can move while it is growing. Once it has
> + been "finished" it never changes address again. So the "top of the
> + stack" is typically an immature growing object, while the rest of the
> + stack is of mature, fixed size and fixed address objects.
> +
> + These routines grab large chunks of memory, using a function you
> + supply, called `obstack_chunk_alloc'. On occasion, they free chunks,
> + by calling `obstack_chunk_free'. You must define them and declare
> + them before using any obstack macros.
> +
> + Each independent stack is represented by a `struct obstack'.
> + Each of the obstack macros expects a pointer to such a structure
> + as the first argument.
> +
> + One motivation for this package is the problem of growing char strings
> + in symbol tables. Unless you are "fascist pig with a read-only mind"
> + --Gosper's immortal quote from HAKMEM item 154, out of context--you
> + would not like to put any arbitrary upper limit on the length of your
> + symbols.
> +
> + In practice this often means you will build many short symbols and a
> + few long symbols. At the time you are reading a symbol you don't know
> + how long it is. One traditional method is to read a symbol into a
> + buffer, realloc()ating the buffer every time you try to read a symbol
> + that is longer than the buffer. This is beaut, but you still will
> + want to copy the symbol from the buffer to a more permanent
> + symbol-table entry say about half the time.
> +
> + With obstacks, you can work differently. Use one obstack for all symbol
> + names. As you read a symbol, grow the name in the obstack gradually.
> + When the name is complete, finalize it. Then, if the symbol exists already,
> + free the newly read name.
> +
> + The way we do this is to take a large chunk, allocating memory from
> + low addresses. When you want to build a symbol in the chunk you just
> + add chars above the current "high water mark" in the chunk. When you
> + have finished adding chars, because you got to the end of the symbol,
> + you know how long the chars are, and you can create a new object.
> + Mostly the chars will not burst over the highest address of the chunk,
> + because you would typically expect a chunk to be (say) 100 times as
> + long as an average object.
> +
> + In case that isn't clear, when we have enough chars to make up
> + the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed)
> + so we just point to it where it lies. No moving of chars is
> + needed and this is the second win: potentially long strings need
> + never be explicitly shuffled. Once an object is formed, it does not
> + change its address during its lifetime.
> +
> + When the chars burst over a chunk boundary, we allocate a larger
> + chunk, and then copy the partly formed object from the end of the old
> + chunk to the beginning of the new larger chunk. We then carry on
> + accreting characters to the end of the object as we normally would.
> +
> + A special macro is provided to add a single char at a time to a
> + growing object. This allows the use of register variables, which
> + break the ordinary 'growth' macro.
> +
> + Summary:
> + We allocate large chunks.
> + We carve out one object at a time from the current chunk.
> + Once carved, an object never moves.
> + We are free to append data of any size to the currently
> + growing object.
> + Exactly one object is growing in an obstack at any one time.
> + You can run one obstack per control block.
> + You may have as many control blocks as you dare.
> + Because of the way we do it, you can `unwind' an obstack
> + back to a previous state. (You may remove objects much
> + as you would with a stack.)
> + */
>
>
> /* Don't do the contents of this file more than once. */
> @@ -107,7 +107,7 @@ Summary:
> #ifdef __cplusplus
> extern "C" {
> #endif
> -
> +
> /* We need the type of a pointer subtraction. If __PTRDIFF_TYPE__ is
> defined, as with GNU C, use that; that way we don't pollute the
> namespace with <stddef.h>'s symbols. Otherwise, include <stddef.h>
> @@ -124,7 +124,7 @@ extern "C" {
> aligning P to the next multiple of A + 1. B and P must be of type
> char *. A + 1 must be a power of 2. */
>
> -#define __BPTR_ALIGN(B, P, A) ((B) + (((P) - (B) + (A)) & ~(A)))
> +#define __BPTR_ALIGN(B, P, A) ((B) + (((P) -(B) + (A)) & ~(A)))
>
> /* Similiar to _BPTR_ALIGN (B, P, A), except optimize the common case
> where pointers can be converted to integers, aligned as integers,
> @@ -133,61 +133,61 @@ extern "C" {
> relative to B. Otherwise, use the faster strategy of computing the
> alignment relative to 0. */
>
> -#define __PTR_ALIGN(B, P, A) \
> +#define __PTR_ALIGN(B, P, A) \
> __BPTR_ALIGN (sizeof (PTR_INT_TYPE) < sizeof (void *) ? (B) : (char *) 0, \
> - P, A)
> + P, A)
>
> #include <string.h>
>
> -struct _obstack_chunk /* Lives at front of each chunk. */
> +struct _obstack_chunk /* Lives at front of each chunk. */
> {
> - char *limit; /* 1 past end of this chunk */
> - struct _obstack_chunk *prev; /* address of prior chunk or NULL */
> - char contents[4]; /* objects begin here */
> + char *limit; /* 1 past end of this chunk */
> + struct _obstack_chunk *prev; /* address of prior chunk or NULL */
> + char contents[4]; /* objects begin here */
> };
>
> -struct obstack /* control current object in current chunk */
> +struct obstack /* control current object in current chunk */
> {
> - long chunk_size; /* preferred size to allocate chunks in */
> - struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */
> - char *object_base; /* address of object we are building */
> - char *next_free; /* where to add next char to current object */
> - char *chunk_limit; /* address of char after current chunk */
> + long chunk_size; /* preferred size to allocate chunks in */
> + struct _obstack_chunk *chunk; /* address of current struct obstack_chunk */
> + char *object_base; /* address of object we are building */
> + char *next_free; /* where to add next char to current object */
> + char *chunk_limit; /* address of char after current chunk */
> union
> {
> PTR_INT_TYPE tempint;
> void *tempptr;
> - } temp; /* Temporary for some macros. */
> - int alignment_mask; /* Mask of alignment for each object. */
> + } temp; /* Temporary for some macros. */
> + int alignment_mask; /* Mask of alignment for each object. */
> /* These prototypes vary based on `use_extra_arg', and we use
> casts to the prototypeless function type in all assignments,
> but having prototypes here quiets -Wstrict-prototypes. */
> struct _obstack_chunk *(*chunkfun) (void *, long);
> void (*freefun) (void *, struct _obstack_chunk *);
> - void *extra_arg; /* first arg for chunk alloc/dealloc funcs */
> - unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */
> - unsigned maybe_empty_object:1;/* There is a possibility that the current
> - chunk contains a zero-length object. This
> - prevents freeing the chunk if we allocate
> - a bigger chunk to replace it. */
> - unsigned alloc_failed:1; /* No longer used, as we now call the failed
> - handler on error, but retained for binary
> - compatibility. */
> + void *extra_arg; /* first arg for chunk alloc/dealloc funcs */
> + unsigned use_extra_arg : 1; /* chunk alloc/dealloc funcs take extra arg */
> + unsigned maybe_empty_object : 1; /* There is a possibility that the current
> + chunk contains a zero-length object. This
> + prevents freeing the chunk if we allocate
> + a bigger chunk to replace it. */
> + unsigned alloc_failed : 1; /* No longer used, as we now call the failed
> + handler on error, but retained for binary
> + compatibility. */
> };
>
> /* Declare the external functions we use; they are in obstack.c. */
>
> extern void _obstack_newchunk (struct obstack *, int);
> extern int _obstack_begin (struct obstack *, int, int,
> - void *(*) (long), void (*) (void *));
> + void *(*)(long), void (*)(void *));
> extern int _obstack_begin_1 (struct obstack *, int, int,
> - void *(*) (void *, long),
> - void (*) (void *, void *), void *);
> + void *(*)(void *, long),
> + void (*)(void *, void *), void *);
> extern int _obstack_memory_used (struct obstack *);
>
> void obstack_free (struct obstack *__obstack, void *__glibc_block);
>
> -
> +
> /* Error handler called when `obstack_chunk_alloc' failed to allocate
> more memory. This can be set to a user defined function which
> should either abort gracefully or use longjump - but shouldn't
> @@ -196,7 +196,7 @@ extern void (*obstack_alloc_failed_handler) (void);
>
> /* Exit value used when `print_and_abort' is used. */
> extern int obstack_exit_failure;
> -
> +
> /* Pointer to beginning of object being allocated or to be allocated next.
> Note that this might not be the final address of the object
> because a new chunk might be needed to hold the final size. */
> @@ -209,45 +209,45 @@ extern int obstack_exit_failure;
>
> /* Pointer to next byte not yet allocated in current chunk. */
>
> -#define obstack_next_free(h) ((h)->next_free)
> +#define obstack_next_free(h) ((h)->next_free)
>
> /* Mask specifying low bits that should be clear in address of an object. */
>
> #define obstack_alignment_mask(h) ((h)->alignment_mask)
>
> /* To prevent prototype warnings provide complete argument list. */
> -#define obstack_init(h) \
> - _obstack_begin ((h), 0, 0, \
> - (void *(*) (long)) obstack_chunk_alloc, \
> - (void (*) (void *)) obstack_chunk_free)
> +#define obstack_init(h) \
> + _obstack_begin ((h), 0, 0, \
> + (void *(*)(long))obstack_chunk_alloc, \
> + (void (*)(void *))obstack_chunk_free)
>
> -#define obstack_begin(h, size) \
> - _obstack_begin ((h), (size), 0, \
> - (void *(*) (long)) obstack_chunk_alloc, \
> - (void (*) (void *)) obstack_chunk_free)
> +#define obstack_begin(h, size) \
> + _obstack_begin ((h), (size), 0, \
> + (void *(*)(long))obstack_chunk_alloc, \
> + (void (*)(void *))obstack_chunk_free)
>
> #define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \
> - _obstack_begin ((h), (size), (alignment), \
> - (void *(*) (long)) (chunkfun), \
> - (void (*) (void *)) (freefun))
> + _obstack_begin ((h), (size), (alignment), \
> + (void *(*)(long))(chunkfun), \
> + (void (*)(void *))(freefun))
>
> #define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \
> - _obstack_begin_1 ((h), (size), (alignment), \
> - (void *(*) (void *, long)) (chunkfun), \
> - (void (*) (void *, void *)) (freefun), (arg))
> + _obstack_begin_1 ((h), (size), (alignment), \
> + (void *(*)(void *, long))(chunkfun), \
> + (void (*)(void *, void *))(freefun), (arg))
>
> #define obstack_chunkfun(h, newchunkfun) \
> - ((h) -> chunkfun = (struct _obstack_chunk *(*)(void *, long)) (newchunkfun))
> + ((h)->chunkfun = (struct _obstack_chunk *(*)(void *, long))(newchunkfun))
>
> #define obstack_freefun(h, newfreefun) \
> - ((h) -> freefun = (void (*)(void *, struct _obstack_chunk *)) (newfreefun))
> + ((h)->freefun = (void (*)(void *, struct _obstack_chunk *))(newfreefun))
>
> -#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = (achar))
> +#define obstack_1grow_fast(h, achar) (*((h)->next_free)++ = (achar))
>
> -#define obstack_blank_fast(h,n) ((h)->next_free += (n))
> +#define obstack_blank_fast(h, n) ((h)->next_free += (n))
>
> #define obstack_memory_used(h) _obstack_memory_used (h)
> -
> +
> #if defined __GNUC__
> /* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
> does not implement __extension__. But that compiler doesn't define
> @@ -261,158 +261,158 @@ extern int obstack_exit_failure;
> without using a global variable.
> Also, we can avoid using the `temp' slot, to make faster code. */
>
> -# define obstack_object_size(OBSTACK) \
> - __extension__ \
> - ({ struct obstack const *__o = (OBSTACK); \
> - (unsigned) (__o->next_free - __o->object_base); })
> -
> -# define obstack_room(OBSTACK) \
> - __extension__ \
> - ({ struct obstack const *__o = (OBSTACK); \
> - (unsigned) (__o->chunk_limit - __o->next_free); })
> -
> -# define obstack_make_room(OBSTACK,length) \
> -__extension__ \
> -({ struct obstack *__o = (OBSTACK); \
> - int __len = (length); \
> - if (__o->chunk_limit - __o->next_free < __len) \
> - _obstack_newchunk (__o, __len); \
> - (void) 0; })
> -
> -# define obstack_empty_p(OBSTACK) \
> - __extension__ \
> - ({ struct obstack const *__o = (OBSTACK); \
> - (__o->chunk->prev == 0 \
> - && __o->next_free == __PTR_ALIGN ((char *) __o->chunk, \
> - __o->chunk->contents, \
> - __o->alignment_mask)); })
> -
> -# define obstack_grow(OBSTACK,where,length) \
> -__extension__ \
> -({ struct obstack *__o = (OBSTACK); \
> - int __len = (length); \
> - if (__o->next_free + __len > __o->chunk_limit) \
> - _obstack_newchunk (__o, __len); \
> - memcpy (__o->next_free, where, __len); \
> - __o->next_free += __len; \
> - (void) 0; })
> -
> -# define obstack_grow0(OBSTACK,where,length) \
> -__extension__ \
> -({ struct obstack *__o = (OBSTACK); \
> - int __len = (length); \
> - if (__o->next_free + __len + 1 > __o->chunk_limit) \
> - _obstack_newchunk (__o, __len + 1); \
> - memcpy (__o->next_free, where, __len); \
> - __o->next_free += __len; \
> - *(__o->next_free)++ = 0; \
> - (void) 0; })
> -
> -# define obstack_1grow(OBSTACK,datum) \
> -__extension__ \
> -({ struct obstack *__o = (OBSTACK); \
> - if (__o->next_free + 1 > __o->chunk_limit) \
> - _obstack_newchunk (__o, 1); \
> - obstack_1grow_fast (__o, datum); \
> - (void) 0; })
> +# define obstack_object_size(OBSTACK) \
> + __extension__ \
> + ({ struct obstack const *__o = (OBSTACK); \
> + (unsigned) (__o->next_free - __o->object_base); })
> +
> +# define obstack_room(OBSTACK) \
> + __extension__ \
> + ({ struct obstack const *__o = (OBSTACK); \
> + (unsigned) (__o->chunk_limit - __o->next_free); })
> +
> +# define obstack_make_room(OBSTACK, length) \
> + __extension__ \
> + ({ struct obstack *__o = (OBSTACK); \
> + int __len = (length); \
> + if (__o->chunk_limit - __o->next_free < __len) \
> + _obstack_newchunk (__o, __len); \
> + (void) 0; })
> +
> +# define obstack_empty_p(OBSTACK) \
> + __extension__ \
> + ({ struct obstack const *__o = (OBSTACK); \
> + (__o->chunk->prev == 0 \
> + && __o->next_free == __PTR_ALIGN ((char *) __o->chunk, \
> + __o->chunk->contents, \
> + __o->alignment_mask)); })
> +
> +# define obstack_grow(OBSTACK, where, length) \
> + __extension__ \
> + ({ struct obstack *__o = (OBSTACK); \
> + int __len = (length); \
> + if (__o->next_free + __len > __o->chunk_limit) \
> + _obstack_newchunk (__o, __len); \
> + memcpy (__o->next_free, where, __len); \
> + __o->next_free += __len; \
> + (void) 0; })
> +
> +# define obstack_grow0(OBSTACK, where, length) \
> + __extension__ \
> + ({ struct obstack *__o = (OBSTACK); \
> + int __len = (length); \
> + if (__o->next_free + __len + 1 > __o->chunk_limit) \
> + _obstack_newchunk (__o, __len + 1); \
> + memcpy (__o->next_free, where, __len); \
> + __o->next_free += __len; \
> + *(__o->next_free)++ = 0; \
> + (void) 0; })
> +
> +# define obstack_1grow(OBSTACK, datum) \
> + __extension__ \
> + ({ struct obstack *__o = (OBSTACK); \
> + if (__o->next_free + 1 > __o->chunk_limit) \
> + _obstack_newchunk (__o, 1); \
> + obstack_1grow_fast (__o, datum); \
> + (void) 0; })
>
> /* These assume that the obstack alignment is good enough for pointers
> or ints, and that the data added so far to the current object
> shares that much alignment. */
>
> -# define obstack_ptr_grow(OBSTACK,datum) \
> -__extension__ \
> -({ struct obstack *__o = (OBSTACK); \
> - if (__o->next_free + sizeof (void *) > __o->chunk_limit) \
> - _obstack_newchunk (__o, sizeof (void *)); \
> - obstack_ptr_grow_fast (__o, datum); }) \
> -
> -# define obstack_int_grow(OBSTACK,datum) \
> -__extension__ \
> -({ struct obstack *__o = (OBSTACK); \
> - if (__o->next_free + sizeof (int) > __o->chunk_limit) \
> - _obstack_newchunk (__o, sizeof (int)); \
> - obstack_int_grow_fast (__o, datum); })
> -
> -# define obstack_ptr_grow_fast(OBSTACK,aptr) \
> -__extension__ \
> -({ struct obstack *__o1 = (OBSTACK); \
> - *(const void **) __o1->next_free = (aptr); \
> - __o1->next_free += sizeof (const void *); \
> - (void) 0; })
> -
> -# define obstack_int_grow_fast(OBSTACK,aint) \
> -__extension__ \
> -({ struct obstack *__o1 = (OBSTACK); \
> - *(int *) __o1->next_free = (aint); \
> - __o1->next_free += sizeof (int); \
> - (void) 0; })
> -
> -# define obstack_blank(OBSTACK,length) \
> -__extension__ \
> -({ struct obstack *__o = (OBSTACK); \
> - int __len = (length); \
> - if (__o->chunk_limit - __o->next_free < __len) \
> - _obstack_newchunk (__o, __len); \
> - obstack_blank_fast (__o, __len); \
> - (void) 0; })
> -
> -# define obstack_alloc(OBSTACK,length) \
> -__extension__ \
> -({ struct obstack *__h = (OBSTACK); \
> - obstack_blank (__h, (length)); \
> - obstack_finish (__h); })
> -
> -# define obstack_copy(OBSTACK,where,length) \
> -__extension__ \
> -({ struct obstack *__h = (OBSTACK); \
> - obstack_grow (__h, (where), (length)); \
> - obstack_finish (__h); })
> -
> -# define obstack_copy0(OBSTACK,where,length) \
> -__extension__ \
> -({ struct obstack *__h = (OBSTACK); \
> - obstack_grow0 (__h, (where), (length)); \
> - obstack_finish (__h); })
> +# define obstack_ptr_grow(OBSTACK, datum) \
> + __extension__ \
> + ({ struct obstack *__o = (OBSTACK); \
> + if (__o->next_free + sizeof (void *) > __o->chunk_limit) \
> + _obstack_newchunk (__o, sizeof (void *)); \
> + obstack_ptr_grow_fast (__o, datum); }) \
> +
> +# define obstack_int_grow(OBSTACK, datum) \
> + __extension__ \
> + ({ struct obstack *__o = (OBSTACK); \
> + if (__o->next_free + sizeof (int) > __o->chunk_limit) \
> + _obstack_newchunk (__o, sizeof (int)); \
> + obstack_int_grow_fast (__o, datum); })
> +
> +# define obstack_ptr_grow_fast(OBSTACK, aptr) \
> + __extension__ \
> + ({ struct obstack *__o1 = (OBSTACK); \
> + *(const void **) __o1->next_free = (aptr); \
> + __o1->next_free += sizeof (const void *); \
> + (void) 0; })
> +
> +# define obstack_int_grow_fast(OBSTACK, aint) \
> + __extension__ \
> + ({ struct obstack *__o1 = (OBSTACK); \
> + *(int *) __o1->next_free = (aint); \
> + __o1->next_free += sizeof (int); \
> + (void) 0; })
> +
> +# define obstack_blank(OBSTACK, length) \
> + __extension__ \
> + ({ struct obstack *__o = (OBSTACK); \
> + int __len = (length); \
> + if (__o->chunk_limit - __o->next_free < __len) \
> + _obstack_newchunk (__o, __len); \
> + obstack_blank_fast (__o, __len); \
> + (void) 0; })
> +
> +# define obstack_alloc(OBSTACK, length) \
> + __extension__ \
> + ({ struct obstack *__h = (OBSTACK); \
> + obstack_blank (__h, (length)); \
> + obstack_finish (__h); })
> +
> +# define obstack_copy(OBSTACK, where, length) \
> + __extension__ \
> + ({ struct obstack *__h = (OBSTACK); \
> + obstack_grow (__h, (where), (length)); \
> + obstack_finish (__h); })
> +
> +# define obstack_copy0(OBSTACK, where, length) \
> + __extension__ \
> + ({ struct obstack *__h = (OBSTACK); \
> + obstack_grow0 (__h, (where), (length)); \
> + obstack_finish (__h); })
>
> /* The local variable is named __o1 to avoid a name conflict
> when obstack_blank is called. */
> -# define obstack_finish(OBSTACK) \
> -__extension__ \
> -({ struct obstack *__o1 = (OBSTACK); \
> - void *__value = (void *) __o1->object_base; \
> - if (__o1->next_free == __value) \
> - __o1->maybe_empty_object = 1; \
> - __o1->next_free \
> - = __PTR_ALIGN (__o1->object_base, __o1->next_free, \
> - __o1->alignment_mask); \
> - if (__o1->next_free - (char *)__o1->chunk \
> - > __o1->chunk_limit - (char *)__o1->chunk) \
> - __o1->next_free = __o1->chunk_limit; \
> - __o1->object_base = __o1->next_free; \
> - __value; })
> -
> -# define obstack_free(OBSTACK, OBJ) \
> -__extension__ \
> -({ struct obstack *__o = (OBSTACK); \
> - void *__obj = (OBJ); \
> - if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \
> - __o->next_free = __o->object_base = (char *)__obj; \
> - else (obstack_free) (__o, __obj); })
> -
> +# define obstack_finish(OBSTACK) \
> + __extension__ \
> + ({ struct obstack *__o1 = (OBSTACK); \
> + void *__value = (void *) __o1->object_base; \
> + if (__o1->next_free == __value) \
> + __o1->maybe_empty_object = 1; \
> + __o1->next_free \
> + = __PTR_ALIGN (__o1->object_base, __o1->next_free, \
> + __o1->alignment_mask); \
> + if (__o1->next_free - (char *) __o1->chunk \
> + > __o1->chunk_limit - (char *) __o1->chunk) \
> + __o1->next_free = __o1->chunk_limit; \
> + __o1->object_base = __o1->next_free; \
> + __value; })
> +
> +# define obstack_free(OBSTACK, OBJ) \
> + __extension__ \
> + ({ struct obstack *__o = (OBSTACK); \
> + void *__obj = (OBJ); \
> + if (__obj > (void *) __o->chunk && __obj < (void *) __o->chunk_limit) \
> + __o->next_free = __o->object_base = (char *) __obj; \
> + else (obstack_free) (__o, __obj); })
> +
> #else /* not __GNUC__ */
>
> # define obstack_object_size(h) \
> - (unsigned) ((h)->next_free - (h)->object_base)
> + (unsigned) ((h)->next_free - (h)->object_base)
>
> -# define obstack_room(h) \
> - (unsigned) ((h)->chunk_limit - (h)->next_free)
> +# define obstack_room(h) \
> + (unsigned) ((h)->chunk_limit - (h)->next_free)
>
> # define obstack_empty_p(h) \
> - ((h)->chunk->prev == 0 \
> - && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk, \
> - (h)->chunk->contents, \
> - (h)->alignment_mask))
> + ((h)->chunk->prev == 0 \
> + && (h)->next_free == __PTR_ALIGN ((char *) (h)->chunk, \
> + (h)->chunk->contents, \
> + (h)->alignment_mask))
>
> /* Note that the call to _obstack_newchunk is enclosed in (..., 0)
> so that we can avoid having void expressions
> @@ -420,88 +420,86 @@ __extension__ \
> Casting the third operand to void was tried before,
> but some compilers won't accept it. */
>
> -# define obstack_make_room(h,length) \
> -( (h)->temp.tempint = (length), \
> - (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \
> +# define obstack_make_room(h, length) \
> + ((h)->temp.tempint = (length), \
> + (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \
> ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0))
>
> -# define obstack_grow(h,where,length) \
> -( (h)->temp.tempint = (length), \
> - (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \
> - ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \
> - memcpy ((h)->next_free, where, (h)->temp.tempint), \
> - (h)->next_free += (h)->temp.tempint)
> -
> -# define obstack_grow0(h,where,length) \
> -( (h)->temp.tempint = (length), \
> - (((h)->next_free + (h)->temp.tempint + 1 > (h)->chunk_limit) \
> - ? (_obstack_newchunk ((h), (h)->temp.tempint + 1), 0) : 0), \
> - memcpy ((h)->next_free, where, (h)->temp.tempint), \
> - (h)->next_free += (h)->temp.tempint, \
> - *((h)->next_free)++ = 0)
> -
> -# define obstack_1grow(h,datum) \
> -( (((h)->next_free + 1 > (h)->chunk_limit) \
> - ? (_obstack_newchunk ((h), 1), 0) : 0), \
> - obstack_1grow_fast (h, datum))
> -
> -# define obstack_ptr_grow(h,datum) \
> -( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \
> - ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \
> - obstack_ptr_grow_fast (h, datum))
> -
> -# define obstack_int_grow(h,datum) \
> -( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \
> - ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \
> - obstack_int_grow_fast (h, datum))
> -
> -# define obstack_ptr_grow_fast(h,aptr) \
> +# define obstack_grow(h, where, length) \
> + ((h)->temp.tempint = (length), \
> + (((h)->next_free + (h)->temp.tempint > (h)->chunk_limit) \
> + ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \
> + memcpy ((h)->next_free, where, (h)->temp.tempint), \
> + (h)->next_free += (h)->temp.tempint)
> +
> +# define obstack_grow0(h, where, length) \
> + ((h)->temp.tempint = (length), \
> + (((h)->next_free + (h)->temp.tempint + 1 > (h)->chunk_limit) \
> + ? (_obstack_newchunk ((h), (h)->temp.tempint + 1), 0) : 0), \
> + memcpy ((h)->next_free, where, (h)->temp.tempint), \
> + (h)->next_free += (h)->temp.tempint, \
> + *((h)->next_free)++ = 0)
> +
> +# define obstack_1grow(h, datum) \
> + ((((h)->next_free + 1 > (h)->chunk_limit) \
> + ? (_obstack_newchunk ((h), 1), 0) : 0), \
> + obstack_1grow_fast (h, datum))
> +
> +# define obstack_ptr_grow(h, datum) \
> + ((((h)->next_free + sizeof (char *) > (h)->chunk_limit) \
> + ? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \
> + obstack_ptr_grow_fast (h, datum))
> +
> +# define obstack_int_grow(h, datum) \
> + ((((h)->next_free + sizeof (int) > (h)->chunk_limit) \
> + ? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \
> + obstack_int_grow_fast (h, datum))
> +
> +# define obstack_ptr_grow_fast(h, aptr) \
> (((const void **) ((h)->next_free += sizeof (void *)))[-1] = (aptr))
>
> -# define obstack_int_grow_fast(h,aint) \
> +# define obstack_int_grow_fast(h, aint) \
> (((int *) ((h)->next_free += sizeof (int)))[-1] = (aint))
>
> -# define obstack_blank(h,length) \
> -( (h)->temp.tempint = (length), \
> - (((h)->chunk_limit - (h)->next_free < (h)->temp.tempint) \
> - ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \
> - obstack_blank_fast (h, (h)->temp.tempint))
> -
> -# define obstack_alloc(h,length) \
> - (obstack_blank ((h), (length)), obstack_finish ((h)))
> -
> -# define obstack_copy(h,where,length) \
> - (obstack_grow ((h), (where), (length)), obstack_finish ((h)))
> -
> -# define obstack_copy0(h,where,length) \
> - (obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))
> -
> -# define obstack_finish(h) \
> -( ((h)->next_free == (h)->object_base \
> - ? (((h)->maybe_empty_object = 1), 0) \
> - : 0), \
> - (h)->temp.tempptr = (h)->object_base, \
> - (h)->next_free \
> - = __PTR_ALIGN ((h)->object_base, (h)->next_free, \
> - (h)->alignment_mask), \
> - (((h)->next_free - (char *) (h)->chunk \
> - > (h)->chunk_limit - (char *) (h)->chunk) \
> - ? ((h)->next_free = (h)->chunk_limit) : 0), \
> - (h)->object_base = (h)->next_free, \
> - (h)->temp.tempptr)
> -
> -# define obstack_free(h,obj) \
> -( (h)->temp.tempint = (char *) (obj) - (char *) (h)->chunk, \
> - ((((h)->temp.tempint > 0 \
> - && (h)->temp.tempint < (h)->chunk_limit - (char *) (h)->chunk)) \
> - ? (((h)->next_free = (h)->object_base \
> - = (h)->temp.tempint + (char *) (h)->chunk), 0) \
> +# define obstack_blank(h, length) \
> + ((h)->temp.tempint = (length), \
> + (((h)->chunk_limit - (h)->next_free < (h)->temp.tempint) \
> + ? (_obstack_newchunk ((h), (h)->temp.tempint), 0) : 0), \
> + obstack_blank_fast (h, (h)->temp.tempint))
> +
> +# define obstack_alloc(h, length) \
> + (obstack_blank ((h), (length)), obstack_finish ((h)))
> +
> +# define obstack_copy(h, where, length) \
> + (obstack_grow ((h), (where), (length)), obstack_finish ((h)))
> +
> +# define obstack_copy0(h, where, length) \
> + (obstack_grow0 ((h), (where), (length)), obstack_finish ((h)))
> +
> +# define obstack_finish(h) \
> + (((h)->next_free == (h)->object_base \
> + ? (((h)->maybe_empty_object = 1), 0) \
> + : 0), \
> + (h)->temp.tempptr = (h)->object_base, \
> + (h)->next_free \
> + = __PTR_ALIGN ((h)->object_base, (h)->next_free, \
> + (h)->alignment_mask), \
> + (((h)->next_free - (char *) (h)->chunk \
> + > (h)->chunk_limit - (char *) (h)->chunk) \
> + ? ((h)->next_free = (h)->chunk_limit) : 0), \
> + (h)->object_base = (h)->next_free, \
> + (h)->temp.tempptr)
> +
> +# define obstack_free(h, obj) \
> + ((h)->temp.tempint = (char *) (obj) - (char *) (h)->chunk, \
> + ((((h)->temp.tempint > 0 \
> + && (h)->temp.tempint < (h)->chunk_limit - (char *) (h)->chunk)) \
> + ? (((h)->next_free = (h)->object_base \
> + = (h)->temp.tempint + (char *) (h)->chunk), 0) \
> : ((obstack_free) ((h), (h)->temp.tempint + (char *) (h)->chunk), 0)))
> -
> #endif /* not __GNUC__ */
>
> #ifdef __cplusplus
> -} /* C++ */
> +} /* C++ */
> #endif
> -
> #endif /* obstack.h */
> diff --git a/malloc/set-freeres.c b/malloc/set-freeres.c
> index e7ffbe0..f18cb83 100644
> --- a/malloc/set-freeres.c
> +++ b/malloc/set-freeres.c
> @@ -33,17 +33,17 @@ __libc_freeres (void)
> protect for multiple executions since these are fatal. */
> static long int already_called;
>
> - if (! atomic_compare_and_exchange_bool_acq (&already_called, 1, 0))
> + if (!atomic_compare_and_exchange_bool_acq (&already_called, 1, 0))
> {
> - void * const *p;
> + void *const *p;
>
> _IO_cleanup ();
>
> RUN_HOOK (__libc_subfreeres, ());
>
> for (p = symbol_set_first_element (__libc_freeres_ptrs);
> - ! symbol_set_end_p (__libc_freeres_ptrs, p); ++p)
> - free (*p);
> + !symbol_set_end_p (__libc_freeres_ptrs, p); ++p)
> + free (*p);
> }
> }
> libc_hidden_def (__libc_freeres)
> diff --git a/malloc/tst-mallocstate.c b/malloc/tst-mallocstate.c
> index 8548dad..19e595b 100644
> --- a/malloc/tst-mallocstate.c
> +++ b/malloc/tst-mallocstate.c
> @@ -48,19 +48,19 @@ main (void)
>
> free (malloc (10));
>
> - for (i=0; i<100; ++i)
> + for (i = 0; i < 100; ++i)
> {
> save_state = malloc_get_state ();
> if (save_state == NULL)
> - {
> - merror ("malloc_get_state () failed.");
> - break;
> - }
> + {
> + merror ("malloc_get_state () failed.");
> + break;
> + }
> /*free (malloc (10)); This could change the top chunk! */
> malloc_set_state (save_state);
> - p1 = realloc (p1, i*4 + 4);
> + p1 = realloc (p1, i * 4 + 4);
> if (p1 == NULL)
> - merror ("realloc (i*4) failed.");
> + merror ("realloc (i*4) failed.");
> free (save_state);
> }
>
> diff --git a/malloc/tst-mtrace.c b/malloc/tst-mtrace.c
> index 93d560d..606e7f6 100644
> --- a/malloc/tst-mtrace.c
> +++ b/malloc/tst-mtrace.c
> @@ -55,20 +55,20 @@ main (void)
> ssize_t n = getline (&line, &linelen, fp);
>
> if (n < 0)
> - break;
> + break;
>
> if (n == 0)
> - continue;
> + continue;
>
> copy = strdup (line);
> if (copy == NULL)
> - abort ();
> + abort ();
>
> p = (char **) tsearch (copy, &root,
> - (int (*) (const void *, const void *)) strcmp);
> + (int (*)(const void *, const void *))strcmp);
> if (*p != copy)
> - /* This line wasn't added. */
> - free (copy);
> + /* This line wasn't added. */
> + free (copy);
> }
>
> fclose (fp);
> diff --git a/malloc/tst-realloc.c b/malloc/tst-realloc.c
> index 9d290d2..1df3057 100644
> --- a/malloc/tst-realloc.c
> +++ b/malloc/tst-realloc.c
> @@ -79,11 +79,11 @@ do_test (void)
> for (i = 0; i < 20; i++)
> {
> if (c[i] != 0)
> - ok = 0;
> + ok = 0;
> }
>
> if (ok == 0)
> - merror ("first 20 bytes were not cleared");
> + merror ("first 20 bytes were not cleared");
>
> free (p);
>
> @@ -104,11 +104,11 @@ do_test (void)
> for (i = 0; i < 16; i++)
> {
> if (c[i] != 0xff)
> - ok = 0;
> + ok = 0;
> }
>
> if (ok == 0)
> - merror ("first 16 bytes were not correct");
> + merror ("first 16 bytes were not correct");
>
> /* Check failed realloc leaves original untouched (C89). */
> c = realloc (p, -1);
> @@ -121,11 +121,11 @@ do_test (void)
> for (i = 0; i < 16; i++)
> {
> if (c[i] != 0xff)
> - ok = 0;
> + ok = 0;
> }
>
> if (ok == 0)
> - merror ("first 16 bytes were not correct after failed realloc");
> + merror ("first 16 bytes were not correct after failed realloc");
>
> /* realloc (p, 0) frees p (C89) and returns NULL (glibc). */
> p = realloc (p, 0);
--
CPU needs recalibration