diff options
Diffstat (limited to 'dotfiles/system/.zsh/modules/Src/mem.c')
| -rw-r--r-- | dotfiles/system/.zsh/modules/Src/mem.c | 1899 |
1 files changed, 0 insertions, 1899 deletions
diff --git a/dotfiles/system/.zsh/modules/Src/mem.c b/dotfiles/system/.zsh/modules/Src/mem.c deleted file mode 100644 index 77e4375..0000000 --- a/dotfiles/system/.zsh/modules/Src/mem.c +++ /dev/null @@ -1,1899 +0,0 @@ -/* - * mem.c - memory management - * - * This file is part of zsh, the Z shell. - * - * Copyright (c) 1992-1997 Paul Falstad - * All rights reserved. - * - * Permission is hereby granted, without written agreement and without - * license or royalty fees, to use, copy, modify, and distribute this - * software and to distribute modified versions of this software for any - * purpose, provided that the above copyright notice and the following - * two paragraphs appear in all copies of this software. - * - * In no event shall Paul Falstad or the Zsh Development Group be liable - * to any party for direct, indirect, special, incidental, or consequential - * damages arising out of the use of this software and its documentation, - * even if Paul Falstad and the Zsh Development Group have been advised of - * the possibility of such damage. - * - * Paul Falstad and the Zsh Development Group specifically disclaim any - * warranties, including, but not limited to, the implied warranties of - * merchantability and fitness for a particular purpose. The software - * provided hereunder is on an "as is" basis, and Paul Falstad and the - * Zsh Development Group have no obligation to provide maintenance, - * support, updates, enhancements, or modifications. - * - */ - -#include "zsh.mdh" -#include "mem.pro" - -/* - There are two ways to allocate memory in zsh. The first way is - to call zalloc/zshcalloc, which call malloc/calloc directly. It - is legal to call realloc() or free() on memory allocated this way. - The second way is to call zhalloc/hcalloc, which allocates memory - from one of the memory pools on the heap stack. Such memory pools - will automatically created when the heap allocation routines are - called. To be sure that they are freed at appropriate times - one should call pushheap() before one starts using heaps and - popheap() after that (when the memory allocated on the heaps since - the last pushheap() isn't needed anymore). - pushheap() saves the states of all currently allocated heaps and - popheap() resets them to the last state saved and destroys the - information about that state. If you called pushheap() and - allocated some memory on the heaps and then come to a place where - you don't need the allocated memory anymore but you still want - to allocate memory on the heap, you should call freeheap(). This - works like popheap(), only that it doesn't free the information - about the heap states (i.e. the heaps are like after the call to - pushheap() and you have to call popheap some time later). - - Memory allocated in this way does not have to be freed explicitly; - it will all be freed when the pool is destroyed. In fact, - attempting to free this memory may result in a core dump. - - If possible, the heaps are allocated using mmap() so that the - (*real*) heap isn't filled up with empty zsh heaps. If mmap() - is not available and zsh's own allocator is used, we use a simple trick - to avoid that: we allocate a large block of memory before allocating - a heap pool, this memory is freed again immediately after the pool - is allocated. If there are only small blocks on the free list this - guarantees that the memory for the pool is at the end of the memory - which means that we can give it back to the system when the pool is - freed. - - hrealloc(char *p, size_t old, size_t new) is an optimisation - with a similar interface to realloc(). Typically the new size - will be larger than the old one, since there is no gain in - shrinking the allocation (indeed, that will confused hrealloc() - since it will forget that the unused space once belonged to this - pointer). However, new == 0 is a special case; then if we - had to allocate a special heap for this memory it is freed at - that point. -*/ - -#if defined(HAVE_SYS_MMAN_H) && defined(HAVE_MMAP) && defined(HAVE_MUNMAP) - -#include <sys/mman.h> - -/* - * This definition is designed to enable use of memory mapping on MacOS. - * However, performance tests indicate that MacOS mapped regions are - * somewhat slower to allocate than memory from malloc(), so whether - * using this improves performance depends on details of zhalloc(). - */ -#if defined(MAP_ANON) && !defined(MAP_ANONYMOUS) -#define MAP_ANONYMOUS MAP_ANON -#endif - -#if defined(MAP_ANONYMOUS) && defined(MAP_PRIVATE) - -#define USE_MMAP 1 -#define MMAP_FLAGS (MAP_ANONYMOUS | MAP_PRIVATE) - -#endif -#endif - -#ifdef ZSH_MEM_WARNING -# ifndef DEBUG -# define DEBUG 1 -# endif -#endif - -#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG) - -static int h_m[1025], h_push, h_pop, h_free; - -#endif - -/* Make sure we align to the longest fundamental type. */ -union mem_align { - zlong l; - double d; -}; - -#define H_ISIZE sizeof(union mem_align) -#define HEAPSIZE (16384 - H_ISIZE) -/* Memory available for user data in default arena size */ -#define HEAP_ARENA_SIZE (HEAPSIZE - sizeof(struct heap)) -#define HEAPFREE (16384 - H_ISIZE) - -/* Memory available for user data in heap h */ -#define ARENA_SIZEOF(h) ((h)->size - sizeof(struct heap)) - -/* list of zsh heaps */ - -static Heap heaps; - -/* a heap with free space, not always correct (it will be the last heap - * if that was newly allocated but it may also be another one) */ - -static Heap fheap; - -/**/ -#ifdef ZSH_HEAP_DEBUG -/* - * The heap ID we'll allocate next. - * - * We'll avoid using 0 as that means zero-initialised memory - * containing a heap ID is (correctly) marked as invalid. - */ -static Heapid next_heap_id = (Heapid)1; - -/* - * The ID of the heap from which we last allocated heap memory. - * In theory, since we carefully avoid allocating heap memory during - * interrupts, after any call to zhalloc() or wrappers this should - * be the ID of the heap containing the memory just returned. - */ -/**/ -mod_export Heapid last_heap_id; - -/* - * Stack of heaps saved by new_heaps(). - * Assumes old_heaps() will come along and restore it later - * (outputs an error if old_heaps() is called out of sequence). - */ -static LinkList heaps_saved; - -/* - * Debugging verbosity. This must be set from a debugger. - * An 'or' of bits from the enum heap_debug_verbosity. - */ -static volatile int heap_debug_verbosity; - -/* - * Generate a heap identifier that's unique up to unsigned integer wrap. - * - * For the purposes of debugging we won't bother trying to make a - * heap_id globally unique, which would require checking all existing - * heaps every time we create an ID and still wouldn't do what we - * ideally want, which is to make sure the IDs of valid heaps are - * different from the IDs of no-longer-valid heaps. Given that, - * we'll just assume that if we haven't tracked the problem when the - * ID wraps we're out of luck. We could change the type to a long long - * if we wanted more room - */ - -static Heapid -new_heap_id(void) -{ - return next_heap_id++; -} - -/**/ -#endif - -/* Use new heaps from now on. This returns the old heap-list. */ - -/**/ -mod_export Heap -new_heaps(void) -{ - Heap h; - - queue_signals(); - h = heaps; - - fheap = heaps = NULL; - unqueue_signals(); - -#ifdef ZSH_HEAP_DEBUG - if (heap_debug_verbosity & HDV_NEW) { - fprintf(stderr, "HEAP DEBUG: heap " HEAPID_FMT - " saved, new heaps created.\n", h->heap_id); - } - if (!heaps_saved) - heaps_saved = znewlinklist(); - zpushnode(heaps_saved, h); -#endif - return h; -} - -/* Re-install the old heaps again, freeing the new ones. */ - -/**/ -mod_export void -old_heaps(Heap old) -{ - Heap h, n; - - queue_signals(); - for (h = heaps; h; h = n) { - n = h->next; - DPUTS(h->sp, "BUG: old_heaps() with pushed heaps"); -#ifdef ZSH_HEAP_DEBUG - if (heap_debug_verbosity & HDV_FREE) { - fprintf(stderr, "HEAP DEBUG: heap " HEAPID_FMT - "freed in old_heaps().\n", h->heap_id); - } -#endif -#ifdef USE_MMAP - munmap((void *) h, h->size); -#else - zfree(h, HEAPSIZE); -#endif -#ifdef ZSH_VALGRIND - VALGRIND_DESTROY_MEMPOOL((char *)h); -#endif - } - heaps = old; -#ifdef ZSH_HEAP_DEBUG - if (heap_debug_verbosity & HDV_OLD) { - fprintf(stderr, "HEAP DEBUG: heap " HEAPID_FMT - "restored.\n", heaps->heap_id); - } - { - Heap myold = heaps_saved ? getlinknode(heaps_saved) : NULL; - if (old != myold) - { - fprintf(stderr, "HEAP DEBUG: invalid old heap " HEAPID_FMT - ", expecting " HEAPID_FMT ".\n", old->heap_id, - myold->heap_id); - } - } -#endif - fheap = NULL; - unqueue_signals(); -} - -/* Temporarily switch to other heaps (or back again). */ - -/**/ -mod_export Heap -switch_heaps(Heap new) -{ - Heap h; - - queue_signals(); - h = heaps; - -#ifdef ZSH_HEAP_DEBUG - if (heap_debug_verbosity & HDV_SWITCH) { - fprintf(stderr, "HEAP DEBUG: heap temporarily switched from " - HEAPID_FMT " to " HEAPID_FMT ".\n", h->heap_id, new->heap_id); - } -#endif - heaps = new; - fheap = NULL; - unqueue_signals(); - - return h; -} - -/* save states of zsh heaps */ - -/**/ -mod_export void -pushheap(void) -{ - Heap h; - Heapstack hs; - - queue_signals(); - -#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG) - h_push++; -#endif - - for (h = heaps; h; h = h->next) { - DPUTS(!h->used && h->next, "BUG: empty heap"); - hs = (Heapstack) zalloc(sizeof(*hs)); - hs->next = h->sp; - h->sp = hs; - hs->used = h->used; -#ifdef ZSH_HEAP_DEBUG - hs->heap_id = h->heap_id; - h->heap_id = new_heap_id(); - if (heap_debug_verbosity & HDV_PUSH) { - fprintf(stderr, "HEAP DEBUG: heap " HEAPID_FMT " pushed, new id is " - HEAPID_FMT ".\n", - hs->heap_id, h->heap_id); - } -#endif - } - unqueue_signals(); -} - -/* reset heaps to previous state */ - -/**/ -mod_export void -freeheap(void) -{ - Heap h, hn, hl = NULL; - - queue_signals(); - -#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG) - h_free++; -#endif - - /* - * When pushheap() is called, it sweeps over the entire heaps list of - * arenas and marks every one of them with the amount of free space in - * that arena at that moment. zhalloc() is then allowed to grab bits - * out of any of those arenas that have free space. - * - * Whenever fheap is NULL here, the loop below sweeps back over the - * entire heap list again, resetting the free space in every arena to - * the amount stashed by pushheap() and finding the arena with the most - * free space to optimize zhalloc()'s next search. When there's a lot - * of stuff already on the heap, this is an enormous amount of work, - * and performance goes to hell. - * - * Therefore, we defer freeing the most recently allocated arena until - * we reach popheap(). - * - * However, if the arena to which fheap points is unused, we want to - * reclaim space in earlier arenas, so we have no choice but to do the - * sweep for a new fheap. - */ - if (fheap && !fheap->sp) - fheap = NULL; /* We used to do this unconditionally */ - /* - * In other cases, either fheap is already correct, or it has never - * been set and this loop will do it, or it'll be reset from scratch - * on the next popheap(). So all that's needed here is to pick up - * the scan wherever the last pass [or the last popheap()] left off. - */ - for (h = (fheap ? fheap : heaps); h; h = hn) { - hn = h->next; - if (h->sp) { -#ifdef ZSH_MEM_DEBUG -#ifdef ZSH_VALGRIND - VALGRIND_MAKE_MEM_UNDEFINED((char *)arena(h) + h->sp->used, - h->used - h->sp->used); -#endif - memset(arena(h) + h->sp->used, 0xff, h->used - h->sp->used); -#endif - h->used = h->sp->used; - if (!fheap) { - if (h->used < ARENA_SIZEOF(h)) - fheap = h; - } else if (ARENA_SIZEOF(h) - h->used > - ARENA_SIZEOF(fheap) - fheap->used) - fheap = h; - hl = h; -#ifdef ZSH_HEAP_DEBUG - /* - * As the free makes the heap invalid, give it a new - * identifier. We're not popping it, so don't use - * the one in the heap stack. - */ - { - Heapid new_id = new_heap_id(); - if (heap_debug_verbosity & HDV_FREE) { - fprintf(stderr, "HEAP DEBUG: heap " HEAPID_FMT - " freed, new id is " HEAPID_FMT ".\n", - h->heap_id, new_id); - } - h->heap_id = new_id; - } -#endif -#ifdef ZSH_VALGRIND - VALGRIND_MEMPOOL_TRIM((char *)h, (char *)arena(h), h->used); -#endif - } else { - if (fheap == h) - fheap = NULL; - if (h->next) { - /* We want to cut this out of the arena list if we can */ - if (h == heaps) - hl = heaps = h->next; - else if (hl && hl->next == h) - hl->next = h->next; - else { - DPUTS(hl, "hl->next != h when freeing"); - hl = h; - continue; - } - h->next = NULL; - } else { - /* Leave an empty arena at the end until popped */ - h->used = 0; - fheap = hl = h; - break; - } -#ifdef USE_MMAP - munmap((void *) h, h->size); -#else - zfree(h, HEAPSIZE); -#endif -#ifdef ZSH_VALGRIND - VALGRIND_DESTROY_MEMPOOL((char *)h); -#endif - } - } - if (hl) - hl->next = NULL; - else - heaps = fheap = NULL; - - unqueue_signals(); -} - -/* reset heap to previous state and destroy state information */ - -/**/ -mod_export void -popheap(void) -{ - Heap h, hn, hl = NULL; - Heapstack hs; - - queue_signals(); - -#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG) - h_pop++; -#endif - - fheap = NULL; - for (h = heaps; h; h = hn) { - hn = h->next; - if ((hs = h->sp)) { - h->sp = hs->next; -#ifdef ZSH_MEM_DEBUG -#ifdef ZSH_VALGRIND - VALGRIND_MAKE_MEM_UNDEFINED((char *)arena(h) + hs->used, - h->used - hs->used); -#endif - memset(arena(h) + hs->used, 0xff, h->used - hs->used); -#endif - h->used = hs->used; -#ifdef ZSH_HEAP_DEBUG - if (heap_debug_verbosity & HDV_POP) { - fprintf(stderr, "HEAP DEBUG: heap " HEAPID_FMT - " popped, old heap was " HEAPID_FMT ".\n", - h->heap_id, hs->heap_id); - } - h->heap_id = hs->heap_id; -#endif -#ifdef ZSH_VALGRIND - VALGRIND_MEMPOOL_TRIM((char *)h, (char *)arena(h), h->used); -#endif - if (!fheap) { - if (h->used < ARENA_SIZEOF(h)) - fheap = h; - } else if (ARENA_SIZEOF(h) - h->used > - ARENA_SIZEOF(fheap) - fheap->used) - fheap = h; - zfree(hs, sizeof(*hs)); - - hl = h; - } else { - if (h->next) { - /* We want to cut this out of the arena list if we can */ - if (h == heaps) - hl = heaps = h->next; - else if (hl && hl->next == h) - hl->next = h->next; - else { - DPUTS(hl, "hl->next != h when popping"); - hl = h; - continue; - } - h->next = NULL; - } else if (hl == h) /* This is the last arena of all */ - hl = NULL; -#ifdef USE_MMAP - munmap((void *) h, h->size); -#else - zfree(h, HEAPSIZE); -#endif -#ifdef ZSH_VALGRIND - VALGRIND_DESTROY_MEMPOOL((char *)h); -#endif - } - } - if (hl) - hl->next = NULL; - else - heaps = NULL; - - unqueue_signals(); -} - -#ifdef USE_MMAP -/* - * Utility function to allocate a heap area of at least *n bytes. - * *n will be rounded up to the next page boundary. - */ -static Heap -mmap_heap_alloc(size_t *n) -{ - Heap h; - static size_t pgsz = 0; - - if (!pgsz) { - -#ifdef _SC_PAGESIZE - pgsz = sysconf(_SC_PAGESIZE); /* SVR4 */ -#else -# ifdef _SC_PAGE_SIZE - pgsz = sysconf(_SC_PAGE_SIZE); /* HPUX */ -# else - pgsz = getpagesize(); -# endif -#endif - - pgsz--; - } - *n = (*n + pgsz) & ~pgsz; - h = (Heap) mmap(NULL, *n, PROT_READ | PROT_WRITE, - MMAP_FLAGS, -1, 0); - if (h == ((Heap) -1)) { - zerr("fatal error: out of heap memory"); - exit(1); - } - - return h; -} -#endif - -/* check whether a pointer is within a memory pool */ - -/**/ -mod_export void * -zheapptr(void *p) -{ - Heap h; - queue_signals(); - for (h = heaps; h; h = h->next) - if ((char *)p >= arena(h) && - (char *)p + H_ISIZE < arena(h) + ARENA_SIZEOF(h)) - break; - unqueue_signals(); - return (h ? p : 0); -} - -/* allocate memory from the current memory pool */ - -/**/ -mod_export void * -zhalloc(size_t size) -{ - Heap h, hp = NULL; - size_t n; -#ifdef ZSH_VALGRIND - size_t req_size = size; - - if (size == 0) - return NULL; -#endif - - size = (size + H_ISIZE - 1) & ~(H_ISIZE - 1); - - queue_signals(); - -#if defined(ZSH_MEM) && defined(ZSH_MEM_DEBUG) - h_m[size < (1024 * H_ISIZE) ? (size / H_ISIZE) : 1024]++; -#endif - - /* find a heap with enough free space */ - - /* - * This previously assigned: - * h = ((fheap && ARENA_SIZEOF(fheap) >= (size + fheap->used)) - * ? fheap : heaps); - * but we think that nothing upstream of fheap has more free space, - * so why start over at heaps just because fheap has too little? - */ - for (h = (fheap ? fheap : heaps); h; h = h->next) { - hp = h; - if (ARENA_SIZEOF(h) >= (n = size + h->used)) { - void *ret; - - h->used = n; - ret = arena(h) + n - size; - unqueue_signals(); -#ifdef ZSH_HEAP_DEBUG - last_heap_id = h->heap_id; - if (heap_debug_verbosity & HDV_ALLOC) { - fprintf(stderr, "HEAP DEBUG: allocated memory from heap " - HEAPID_FMT ".\n", h->heap_id); - } -#endif -#ifdef ZSH_VALGRIND - VALGRIND_MEMPOOL_ALLOC((char *)h, (char *)ret, req_size); -#endif - return ret; - } - } - { - /* not found, allocate new heap */ -#if defined(ZSH_MEM) && !defined(USE_MMAP) - static int called = 0; - void *foo = called ? (void *)malloc(HEAPFREE) : NULL; - /* tricky, see above */ -#endif - - n = HEAP_ARENA_SIZE > size ? HEAPSIZE : size + sizeof(*h); - -#ifdef USE_MMAP - h = mmap_heap_alloc(&n); -#else - h = (Heap) zalloc(n); -#endif - -#if defined(ZSH_MEM) && !defined(USE_MMAP) - if (called) - zfree(foo, HEAPFREE); - called = 1; -#endif - - h->size = n; - h->used = size; - h->next = NULL; - h->sp = NULL; -#ifdef ZSH_HEAP_DEBUG - h->heap_id = new_heap_id(); - if (heap_debug_verbosity & HDV_CREATE) { - fprintf(stderr, "HEAP DEBUG: create new heap " HEAPID_FMT ".\n", - h->heap_id); - } -#endif -#ifdef ZSH_VALGRIND - VALGRIND_CREATE_MEMPOOL((char *)h, 0, 0); - VALGRIND_MAKE_MEM_NOACCESS((char *)arena(h), - n - ((char *)arena(h)-(char *)h)); - VALGRIND_MEMPOOL_ALLOC((char *)h, (char *)arena(h), req_size); -#endif - - DPUTS(hp && hp->next, "failed to find end of chain in zhalloc"); - if (hp) - hp->next = h; - else - heaps = h; - fheap = h; - - unqueue_signals(); -#ifdef ZSH_HEAP_DEBUG - last_heap_id = h->heap_id; - if (heap_debug_verbosity & HDV_ALLOC) { - fprintf(stderr, "HEAP DEBUG: allocated memory from heap " - HEAPID_FMT ".\n", h->heap_id); - } -#endif - return arena(h); - } -} - -/**/ -mod_export void * -hrealloc(char *p, size_t old, size_t new) -{ - Heap h, ph; - -#ifdef ZSH_VALGRIND - size_t new_req = new; -#endif - - old = (old + H_ISIZE - 1) & ~(H_ISIZE - 1); - new = (new + H_ISIZE - 1) & ~(H_ISIZE - 1); - - if (old == new) - return p; - if (!old && !p) -#ifdef ZSH_VALGRIND - return zhalloc(new_req); -#else - return zhalloc(new); -#endif - - /* find the heap with p */ - - queue_signals(); - for (h = heaps, ph = NULL; h; ph = h, h = h->next) - if (p >= arena(h) && p < arena(h) + ARENA_SIZEOF(h)) - break; - - DPUTS(!h, "BUG: hrealloc() called for non-heap memory."); - DPUTS(h->sp && arena(h) + h->sp->used > p, - "BUG: hrealloc() wants to realloc pushed memory"); - - /* - * If the end of the old chunk is before the used pointer, - * more memory has been zhalloc'ed afterwards. - * We can't tell if that's still in use, obviously, since - * that's the whole point of heap memory. - * We have no choice other than to grab some more memory - * somewhere else and copy in the old stuff. - */ - if (p + old < arena(h) + h->used) { - if (new > old) { -#ifdef ZSH_VALGRIND - char *ptr = (char *) zhalloc(new_req); -#else - char *ptr = (char *) zhalloc(new); -#endif - memcpy(ptr, p, old); -#ifdef ZSH_MEM_DEBUG - memset(p, 0xff, old); -#endif -#ifdef ZSH_VALGRIND - VALGRIND_MEMPOOL_FREE((char *)h, (char *)p); - /* - * zhalloc() marked h,ptr,new as an allocation so we don't - * need to do that here. - */ -#endif - unqueue_signals(); - return ptr; - } else { -#ifdef ZSH_VALGRIND - VALGRIND_MEMPOOL_FREE((char *)h, (char *)p); - if (p) { - VALGRIND_MEMPOOL_ALLOC((char *)h, (char *)p, - new_req); - VALGRIND_MAKE_MEM_DEFINED((char *)h, (char *)p); - } -#endif - unqueue_signals(); - return new ? p : NULL; - } - } - - DPUTS(p + old != arena(h) + h->used, "BUG: hrealloc more than allocated"); - - /* - * We now know there's nothing afterwards in the heap, now see if - * there's nothing before. Then we can reallocate the whole thing. - * Otherwise, we need to keep the stuff at the start of the heap, - * then allocate a new one too; this is handled below. (This will - * guarantee we occupy a full heap next time round, provided we - * don't use the heap for anything else.) - */ - if (p == arena(h)) { -#ifdef ZSH_HEAP_DEBUG - Heapid heap_id = h->heap_id; -#endif - /* - * Zero new seems to be a special case saying we've finished - * with the specially reallocated memory, see scanner() in glob.c. - */ - if (!new) { - if (ph) - ph->next = h->next; - else - heaps = h->next; - fheap = NULL; -#ifdef USE_MMAP - munmap((void *) h, h->size); -#else - zfree(h, HEAPSIZE); -#endif -#ifdef ZSH_VALGRIND - VALGRIND_DESTROY_MEMPOOL((char *)h); -#endif - unqueue_signals(); - return NULL; - } - if (new > ARENA_SIZEOF(h)) { - Heap hnew; - /* - * Not enough memory in this heap. Allocate a new - * one of sufficient size. - * - * To avoid this happening too often, allocate - * chunks in multiples of HEAPSIZE. - * (Historical note: there didn't used to be any - * point in this since we didn't consistently record - * the allocated size of the heap, but now we do.) - */ - size_t n = (new + sizeof(*h) + HEAPSIZE); - n -= n % HEAPSIZE; - fheap = NULL; - -#ifdef USE_MMAP - { - /* - * I don't know any easy portable way of requesting - * a mmap'd segment be extended, so simply allocate - * a new one and copy. - */ - hnew = mmap_heap_alloc(&n); - /* Copy the entire heap, header (with next pointer) included */ - memcpy(hnew, h, h->size); - munmap((void *)h, h->size); - } -#else - hnew = (Heap) realloc(h, n); -#endif -#ifdef ZSH_VALGRIND - VALGRIND_MEMPOOL_FREE((char *)h, p); - VALGRIND_DESTROY_MEMPOOL((char *)h); - VALGRIND_CREATE_MEMPOOL((char *)hnew, 0, 0); - VALGRIND_MEMPOOL_ALLOC((char *)hnew, (char *)arena(hnew), - new_req); - VALGRIND_MAKE_MEM_DEFINED((char *)hnew, (char *)arena(hnew)); -#endif - h = hnew; - - h->size = n; - if (ph) - ph->next = h; - else - heaps = h; - } -#ifdef ZSH_VALGRIND - else { - VALGRIND_MEMPOOL_FREE((char *)h, (char *)p); - VALGRIND_MEMPOOL_ALLOC((char *)h, (char *)p, new_req); - VALGRIND_MAKE_MEM_DEFINED((char *)h, (char *)p); - } -#endif - h->used = new; -#ifdef ZSH_HEAP_DEBUG - h->heap_id = heap_id; -#endif - unqueue_signals(); - return arena(h); - } -#ifndef USE_MMAP - DPUTS(h->used > ARENA_SIZEOF(h), "BUG: hrealloc at invalid address"); -#endif - if (h->used + (new - old) <= ARENA_SIZEOF(h)) { - h->used += new - old; - unqueue_signals(); -#ifdef ZSH_VALGRIND - VALGRIND_MEMPOOL_FREE((char *)h, (char *)p); - VALGRIND_MEMPOOL_ALLOC((char *)h, (char *)p, new_req); - VALGRIND_MAKE_MEM_DEFINED((char *)h, (char *)p); -#endif - return p; - } else { - char *t = zhalloc(new); - memcpy(t, p, old > new ? new : old); - h->used -= old; -#ifdef ZSH_MEM_DEBUG - memset(p, 0xff, old); -#endif -#ifdef ZSH_VALGRIND - VALGRIND_MEMPOOL_FREE((char *)h, (char *)p); - /* t already marked as allocated by zhalloc() */ -#endif - unqueue_signals(); - return t; - } -} - -/**/ -#ifdef ZSH_HEAP_DEBUG -/* - * Check if heap_id is the identifier of a currently valid heap, - * including any heap buried on the stack, or of permanent memory. - * Return 0 if so, else 1. - * - * This gets confused by use of switch_heaps(). That's because so do I. - */ - -/**/ -mod_export int -memory_validate(Heapid heap_id) -{ - Heap h; - Heapstack hs; - LinkNode node; - - if (heap_id == HEAPID_PERMANENT) - return 0; - - queue_signals(); - for (h = heaps; h; h = h->next) { - if (h->heap_id == heap_id) { - unqueue_signals(); - return 0; - } - for (hs = heaps->sp; hs; hs = hs->next) { - if (hs->heap_id == heap_id) { - unqueue_signals(); - return 0; - } - } - } - - if (heaps_saved) { - for (node = firstnode(heaps_saved); node; incnode(node)) { - for (h = (Heap)getdata(node); h; h = h->next) { - if (h->heap_id == heap_id) { - unqueue_signals(); - return 0; - } - for (hs = heaps->sp; hs; hs = hs->next) { - if (hs->heap_id == heap_id) { - unqueue_signals(); - return 0; - } - } - } - } - } - - unqueue_signals(); - return 1; -} -/**/ -#endif - -/* allocate memory from the current memory pool and clear it */ - -/**/ -mod_export void * -hcalloc(size_t size) -{ - void *ptr; - - ptr = zhalloc(size); - memset(ptr, 0, size); - return ptr; -} - -/* allocate permanent memory */ - -/**/ -mod_export void * -zalloc(size_t size) -{ - void *ptr; - - if (!size) - size = 1; - queue_signals(); - if (!(ptr = (void *) malloc(size))) { - zerr("fatal error: out of memory"); - exit(1); - } - unqueue_signals(); - - return ptr; -} - -/**/ -mod_export void * -zshcalloc(size_t size) -{ - void *ptr = zalloc(size); - if (!size) - size = 1; - memset(ptr, 0, size); - return ptr; -} - -/* This front-end to realloc is used to make sure we have a realloc * - * that conforms to POSIX realloc. Older realloc's can fail if * - * passed a NULL pointer, but POSIX realloc should handle this. A * - * better solution would be for configure to check if realloc is * - * POSIX compliant, but I'm not sure how to do that. */ - -/**/ -mod_export void * -zrealloc(void *ptr, size_t size) -{ - queue_signals(); - if (ptr) { - if (size) { - /* Do normal realloc */ - if (!(ptr = (void *) realloc(ptr, size))) { - zerr("fatal error: out of memory"); - exit(1); - } - unqueue_signals(); - return ptr; - } - else - /* If ptr is not NULL, but size is zero, * - * then object pointed to is freed. */ - free(ptr); - - ptr = NULL; - } else { - /* If ptr is NULL, then behave like malloc */ - if (!(ptr = (void *) malloc(size))) { - zerr("fatal error: out of memory"); - exit(1); - } - } - unqueue_signals(); - - return ptr; -} - -/**/ -#ifdef ZSH_MEM - -/* - Below is a simple segment oriented memory allocator for systems on - which it is better than the system's one. Memory is given in blocks - aligned to an integer multiple of sizeof(union mem_align), which will - probably be 64-bit as it is the longer of zlong or double. Each block is - preceded by a header which contains the length of the data part (in - bytes). In allocated blocks only this field of the structure m_hdr is - senseful. In free blocks the second field (next) is a pointer to the next - free segment on the free list. - - On top of this simple allocator there is a second allocator for small - chunks of data. It should be both faster and less space-consuming than - using the normal segment mechanism for such blocks. - For the first M_NSMALL-1 possible sizes memory is allocated in arrays - that can hold M_SNUM blocks. Each array is stored in one segment of the - main allocator. In these segments the third field of the header structure - (free) contains a pointer to the first free block in the array. The - last field (used) gives the number of already used blocks in the array. - - If the macro name ZSH_MEM_DEBUG is defined, some information about the memory - usage is stored. This information can than be viewed by calling the - builtin `mem' (which is only available if ZSH_MEM_DEBUG is set). - - If ZSH_MEM_WARNING is defined, error messages are printed in case of errors. - - If ZSH_SECURE_FREE is defined, free() checks if the given address is really - one that was returned by malloc(), it ignores it if it wasn't (printing - an error message if ZSH_MEM_WARNING is also defined). -*/ -#if !defined(__hpux) && !defined(DGUX) && !defined(__osf__) -# if defined(_BSD) -# ifndef HAVE_BRK_PROTO - extern int brk _((caddr_t)); -# endif -# ifndef HAVE_SBRK_PROTO - extern caddr_t sbrk _((int)); -# endif -# else -# ifndef HAVE_BRK_PROTO - extern int brk _((void *)); -# endif -# ifndef HAVE_SBRK_PROTO - extern void *sbrk _((int)); -# endif -# endif -#endif - -#if defined(_BSD) && !defined(STDC_HEADERS) -# define FREE_RET_T int -# define FREE_ARG_T char * -# define FREE_DO_RET -# define MALLOC_RET_T char * -# define MALLOC_ARG_T size_t -#else -# define FREE_RET_T void -# define FREE_ARG_T void * -# define MALLOC_RET_T void * -# define MALLOC_ARG_T size_t -#endif - -/* structure for building free list in blocks holding small blocks */ - -struct m_shdr { - struct m_shdr *next; /* next one on free list */ -#ifdef PAD_64_BIT - /* dummy to make this 64-bit aligned */ - struct m_shdr *dummy; -#endif -}; - -struct m_hdr { - zlong len; /* length of memory block */ -#if defined(PAD_64_BIT) && !defined(ZSH_64_BIT_TYPE) - /* either 1 or 2 zlong's, whichever makes up 64 bits. */ - zlong dummy1; -#endif - struct m_hdr *next; /* if free: next on free list - if block of small blocks: next one with - small blocks of same size*/ - struct m_shdr *free; /* if block of small blocks: free list */ - zlong used; /* if block of small blocks: number of used - blocks */ -#if defined(PAD_64_BIT) && !defined(ZSH_64_BIT_TYPE) - zlong dummy2; -#endif -}; - - -/* alignment for memory blocks */ - -#define M_ALIGN (sizeof(union mem_align)) - -/* length of memory header, length of first field of memory header and - minimal size of a block left free (if we allocate memory and take a - block from the free list that is larger than needed, it must have at - least M_MIN extra bytes to be splitted; if it has, the rest is put on - the free list) */ - -#define M_HSIZE (sizeof(struct m_hdr)) -#if defined(PAD_64_BIT) && !defined(ZSH_64_BIT_TYPE) -# define M_ISIZE (2*sizeof(zlong)) -#else -# define M_ISIZE (sizeof(zlong)) -#endif -#define M_MIN (2 * M_ISIZE) - -/* M_FREE is the number of bytes that have to be free before memory is - * given back to the system - * M_KEEP is the number of bytes that will be kept when memory is given - * back; note that this has to be less than M_FREE - * M_ALLOC is the number of extra bytes to request from the system */ - -#define M_FREE 32768 -#define M_KEEP 16384 -#define M_ALLOC M_KEEP - -/* a pointer to the last free block, a pointer to the free list (the blocks - on this list are kept in order - lowest address first) */ - -static struct m_hdr *m_lfree, *m_free; - -/* system's pagesize */ - -static long m_pgsz = 0; - -/* the highest and the lowest valid memory addresses, kept for fast validity - checks in free() and to find out if and when we can give memory back to - the system */ - -static char *m_high, *m_low; - -/* Management of blocks for small blocks: - Such blocks are kept in lists (one list for each of the sizes that are - allocated in such blocks). The lists are stored in the m_small array. - M_SIDX() calculates the index into this array for a given size. M_SNUM - is the size (in small blocks) of such blocks. M_SLEN() calculates the - size of the small blocks held in a memory block, given a pointer to the - header of it. M_SBLEN() gives the size of a memory block that can hold - an array of small blocks, given the size of these small blocks. M_BSLEN() - calculates the size of the small blocks held in a memory block, given the - length of that block (including the header of the memory block. M_NSMALL - is the number of possible block sizes that small blocks should be used - for. */ - - -#define M_SIDX(S) ((S) / M_ISIZE) -#define M_SNUM 128 -#define M_SLEN(M) ((M)->len / M_SNUM) -#if defined(PAD_64_BIT) && !defined(ZSH_64_BIT_TYPE) -/* Include the dummy in the alignment */ -#define M_SBLEN(S) ((S) * M_SNUM + sizeof(struct m_shdr *) + \ - 2*sizeof(zlong) + sizeof(struct m_hdr *)) -#define M_BSLEN(S) (((S) - sizeof(struct m_shdr *) - \ - 2*sizeof(zlong) - sizeof(struct m_hdr *)) / M_SNUM) -#else -#define M_SBLEN(S) ((S) * M_SNUM + sizeof(struct m_shdr *) + \ - sizeof(zlong) + sizeof(struct m_hdr *)) -#define M_BSLEN(S) (((S) - sizeof(struct m_shdr *) - \ - sizeof(zlong) - sizeof(struct m_hdr *)) / M_SNUM) -#endif -#define M_NSMALL 8 - -static struct m_hdr *m_small[M_NSMALL]; - -#ifdef ZSH_MEM_DEBUG - -static int m_s = 0, m_b = 0; -static int m_m[1025], m_f[1025]; - -static struct m_hdr *m_l; - -#endif /* ZSH_MEM_DEBUG */ - -MALLOC_RET_T -malloc(MALLOC_ARG_T size) -{ - struct m_hdr *m, *mp, *mt; - long n, s, os = 0; -#ifndef USE_MMAP - struct heap *h, *hp, *hf = NULL, *hfp = NULL; -#endif - - /* some systems want malloc to return the highest valid address plus one - if it is called with an argument of zero. - - TODO: really? Suppose we allocate more memory, so - that this is now in bounds, then a more rational application - that thinks it can free() anything it malloc'ed, even - of zero length, calls free for it? Aren't we in big - trouble? Wouldn't it be safer just to allocate some - memory anyway? - - If the above comment is really correct, then at least - we need to check in free() if we're freeing memory - at m_high. - */ - - if (!size) -#if 1 - size = 1; -#else - return (MALLOC_RET_T) m_high; -#endif - - queue_signals(); /* just queue signals rather than handling them */ - - /* first call, get page size */ - - if (!m_pgsz) { - -#ifdef _SC_PAGESIZE - m_pgsz = sysconf(_SC_PAGESIZE); /* SVR4 */ -#else -# ifdef _SC_PAGE_SIZE - m_pgsz = sysconf(_SC_PAGE_SIZE); /* HPUX */ -# else - m_pgsz = getpagesize(); -# endif -#endif - - m_free = m_lfree = NULL; - } - size = (size + M_ALIGN - 1) & ~(M_ALIGN - 1); - - /* Do we need a small block? */ - - if ((s = M_SIDX(size)) && s < M_NSMALL) { - /* yep, find a memory block with free small blocks of the - appropriate size (if we find it in this list, this means that - it has room for at least one more small block) */ - for (mp = NULL, m = m_small[s]; m && !m->free; mp = m, m = m->next); - - if (m) { - /* we found one */ - struct m_shdr *sh = m->free; - - m->free = sh->next; - m->used++; - - /* if all small blocks in this block are allocated, the block is - put at the end of the list blocks with small blocks of this - size (i.e., we try to keep blocks with free blocks at the - beginning of the list, to make the search faster) */ - - if (m->used == M_SNUM && m->next) { - for (mt = m; mt->next; mt = mt->next); - - mt->next = m; - if (mp) - mp->next = m->next; - else - m_small[s] = m->next; - m->next = NULL; - } -#ifdef ZSH_MEM_DEBUG - m_m[size / M_ISIZE]++; -#endif - - unqueue_signals(); - return (MALLOC_RET_T) sh; - } - /* we still want a small block but there were no block with a free - small block of the requested size; so we use the real allocation - routine to allocate a block for small blocks of this size */ - os = size; - size = M_SBLEN(size); - } else - s = 0; - - /* search the free list for an block of at least the requested size */ - for (mp = NULL, m = m_free; m && m->len < size; mp = m, m = m->next); - -#ifndef USE_MMAP - - /* if there is an empty zsh heap at a lower address we steal it and take - the memory from it, putting the rest on the free list (remember - that the blocks on the free list are ordered) */ - - for (hp = NULL, h = heaps; h; hp = h, h = h->next) - if (!h->used && - (!hf || h < hf) && - (!m || ((char *)m) > ((char *)h))) - hf = h, hfp = hp; - - if (hf) { - /* we found such a heap */ - Heapstack hso, hsn; - - /* delete structures on the list holding the heap states */ - for (hso = hf->sp; hso; hso = hsn) { - hsn = hso->next; - zfree(hso, sizeof(*hso)); - } - /* take it from the list of heaps */ - if (hfp) - hfp->next = hf->next; - else - heaps = hf->next; - /* now we simply free it and than search the free list again */ - zfree(hf, HEAPSIZE); - - for (mp = NULL, m = m_free; m && m->len < size; mp = m, m = m->next); - } -#endif - if (!m) { - long nal; - /* no matching free block was found, we have to request new - memory from the system */ - n = (size + M_HSIZE + M_ALLOC + m_pgsz - 1) & ~(m_pgsz - 1); - - if (((char *)(m = (struct m_hdr *)sbrk(n))) == ((char *)-1)) { - DPUTS1(1, "MEM: allocation error at sbrk, size %L.", n); - unqueue_signals(); - return NULL; - } - if ((nal = ((long)(char *)m) & (M_ALIGN-1))) { - if ((char *)sbrk(M_ALIGN - nal) == (char *)-1) { - DPUTS(1, "MEM: allocation error at sbrk."); - unqueue_signals(); - return NULL; - } - m = (struct m_hdr *) ((char *)m + (M_ALIGN - nal)); - } - /* set m_low, for the check in free() */ - if (!m_low) - m_low = (char *)m; - -#ifdef ZSH_MEM_DEBUG - m_s += n; - - if (!m_l) - m_l = m; -#endif - - /* save new highest address */ - m_high = ((char *)m) + n; - - /* initialize header */ - m->len = n - M_ISIZE; - m->next = NULL; - - /* put it on the free list and set m_lfree pointing to it */ - if ((mp = m_lfree)) - m_lfree->next = m; - m_lfree = m; - } - if ((n = m->len - size) > M_MIN) { - /* the block we want to use has more than M_MIN bytes plus the - number of bytes that were requested; we split it in two and - leave the rest on the free list */ - struct m_hdr *mtt = (struct m_hdr *)(((char *)m) + M_ISIZE + size); - - mtt->len = n - M_ISIZE; - mtt->next = m->next; - - m->len = size; - - /* put the rest on the list */ - if (m_lfree == m) - m_lfree = mtt; - - if (mp) - mp->next = mtt; - else - m_free = mtt; - } else if (mp) { - /* the block we found wasn't the first one on the free list */ - if (m == m_lfree) - m_lfree = mp; - mp->next = m->next; - } else { - /* it was the first one */ - m_free = m->next; - if (m == m_lfree) - m_lfree = m_free; - } - - if (s) { - /* we are allocating a block that should hold small blocks */ - struct m_shdr *sh, *shn; - - /* build the free list in this block and set `used' filed */ - m->free = sh = (struct m_shdr *)(((char *)m) + - sizeof(struct m_hdr) + os); - - for (n = M_SNUM - 2; n--; sh = shn) - shn = sh->next = sh + s; - sh->next = NULL; - - m->used = 1; - - /* put the block on the list of blocks holding small blocks if - this size */ - m->next = m_small[s]; - m_small[s] = m; - -#ifdef ZSH_MEM_DEBUG - m_m[os / M_ISIZE]++; -#endif - - unqueue_signals(); - return (MALLOC_RET_T) (((char *)m) + sizeof(struct m_hdr)); - } -#ifdef ZSH_MEM_DEBUG - m_m[m->len < (1024 * M_ISIZE) ? (m->len / M_ISIZE) : 1024]++; -#endif - - unqueue_signals(); - return (MALLOC_RET_T) & m->next; -} - -/* this is an internal free(); the second argument may, but need not hold - the size of the block the first argument is pointing to; if it is the - right size of this block, freeing it will be faster, though; the value - 0 for this parameter means: `don't know' */ - -/**/ -mod_export void -zfree(void *p, int sz) -{ - struct m_hdr *m = (struct m_hdr *)(((char *)p) - M_ISIZE), *mp, *mt = NULL; - int i; -# ifdef DEBUG - int osz = sz; -# endif - -#ifdef ZSH_SECURE_FREE - sz = 0; -#else - sz = (sz + M_ALIGN - 1) & ~(M_ALIGN - 1); -#endif - - if (!p) - return; - - /* first a simple check if the given address is valid */ - if (((char *)p) < m_low || ((char *)p) > m_high || - ((long)p) & (M_ALIGN - 1)) { - DPUTS(1, "BUG: attempt to free storage at invalid address"); - return; - } - - queue_signals(); - - fr_rec: - - if ((i = sz / M_ISIZE) < M_NSMALL || !sz) - /* if the given sizes says that it is a small block, find the - memory block holding it; we search all blocks with blocks - of at least the given size; if the size parameter is zero, - this means, that all blocks are searched */ - for (; i < M_NSMALL; i++) { - for (mp = NULL, mt = m_small[i]; - mt && (((char *)mt) > ((char *)p) || - (((char *)mt) + mt->len) < ((char *)p)); - mp = mt, mt = mt->next); - - if (mt) { - /* we found the block holding the small block */ - struct m_shdr *sh = (struct m_shdr *)p; - -#ifdef ZSH_SECURE_FREE - struct m_shdr *sh2; - - /* check if the given address is equal to the address of - the first small block plus an integer multiple of the - block size */ - if ((((char *)p) - (((char *)mt) + sizeof(struct m_hdr))) % - M_BSLEN(mt->len)) { - - DPUTS(1, "BUG: attempt to free storage at invalid address"); - unqueue_signals(); - return; - } - /* check, if the address is on the (block-intern) free list */ - for (sh2 = mt->free; sh2; sh2 = sh2->next) - if (((char *)p) == ((char *)sh2)) { - - DPUTS(1, "BUG: attempt to free already free storage"); - unqueue_signals(); - return; - } -#endif - DPUTS(M_BSLEN(mt->len) < osz, - "BUG: attempt to free more than allocated."); - -#ifdef ZSH_MEM_DEBUG - m_f[M_BSLEN(mt->len) / M_ISIZE]++; - memset(sh, 0xff, M_BSLEN(mt->len)); -#endif - - /* put the block onto the free list */ - sh->next = mt->free; - mt->free = sh; - - if (--mt->used) { - /* if there are still used blocks in this block, we - put it at the beginning of the list with blocks - holding small blocks of the same size (since we - know that there is at least one free block in it, - this will make allocation of small blocks faster; - it also guarantees that long living memory blocks - are preferred over younger ones */ - if (mp) { - mp->next = mt->next; - mt->next = m_small[i]; - m_small[i] = mt; - } - unqueue_signals(); - return; - } - /* if there are no more used small blocks in this - block, we free the whole block */ - if (mp) - mp->next = mt->next; - else - m_small[i] = mt->next; - - m = mt; - p = (void *) & m->next; - - break; - } else if (sz) { - /* if we didn't find a block and a size was given, try it - again as if no size were given */ - sz = 0; - goto fr_rec; - } - } -#ifdef ZSH_MEM_DEBUG - if (!mt) - m_f[m->len < (1024 * M_ISIZE) ? (m->len / M_ISIZE) : 1024]++; -#endif - -#ifdef ZSH_SECURE_FREE - /* search all memory blocks, if one of them is at the given address */ - for (mt = (struct m_hdr *)m_low; - ((char *)mt) < m_high; - mt = (struct m_hdr *)(((char *)mt) + M_ISIZE + mt->len)) - if (((char *)p) == ((char *)&mt->next)) - break; - - /* no block was found at the given address */ - if (((char *)mt) >= m_high) { - DPUTS(1, "BUG: attempt to free storage at invalid address"); - unqueue_signals(); - return; - } -#endif - - /* see if the block is on the free list */ - for (mp = NULL, mt = m_free; mt && mt < m; mp = mt, mt = mt->next); - - if (m == mt) { - /* it is, ouch! */ - DPUTS(1, "BUG: attempt to free already free storage"); - unqueue_signals(); - return; - } - DPUTS(m->len < osz, "BUG: attempt to free more than allocated"); -#ifdef ZSH_MEM_DEBUG - memset(p, 0xff, m->len); -#endif - if (mt && ((char *)mt) == (((char *)m) + M_ISIZE + m->len)) { - /* the block after the one we are freeing is free, we put them - together */ - m->len += mt->len + M_ISIZE; - m->next = mt->next; - - if (mt == m_lfree) - m_lfree = m; - } else - m->next = mt; - - if (mp && ((char *)m) == (((char *)mp) + M_ISIZE + mp->len)) { - /* the block before the one we are freeing is free, we put them - together */ - mp->len += m->len + M_ISIZE; - mp->next = m->next; - - if (m == m_lfree) - m_lfree = mp; - } else if (mp) - /* otherwise, we just put it on the free list */ - mp->next = m; - else { - m_free = m; - if (!m_lfree) - m_lfree = m_free; - } - - /* if the block we have just freed was at the end of the process heap - and now there is more than one page size of memory, we can give - it back to the system (and we do it ;-) */ - if ((((char *)m_lfree) + M_ISIZE + m_lfree->len) == m_high && - m_lfree->len >= m_pgsz + M_MIN + M_FREE) { - long n = (m_lfree->len - M_MIN - M_KEEP) & ~(m_pgsz - 1); - - m_lfree->len -= n; -#ifdef HAVE_BRK - if (brk(m_high -= n) == -1) { -#else - m_high -= n; - if (sbrk(-n) == (void *)-1) { -#endif /* HAVE_BRK */ - DPUTS(1, "MEM: allocation error at brk."); - } - -#ifdef ZSH_MEM_DEBUG - m_b += n; -#endif - } - unqueue_signals(); -} - -FREE_RET_T -free(FREE_ARG_T p) -{ - zfree(p, 0); /* 0 means: size is unknown */ - -#ifdef FREE_DO_RET - return 0; -#endif -} - -/* this one is for strings (and only strings, real strings, real C strings, - those that have a zero byte at the end) */ - -/**/ -mod_export void -zsfree(char *p) -{ - if (p) - zfree(p, strlen(p) + 1); -} - -MALLOC_RET_T -realloc(MALLOC_RET_T p, MALLOC_ARG_T size) -{ - struct m_hdr *m = (struct m_hdr *)(((char *)p) - M_ISIZE), *mt; - char *r; - int i, l = 0; - - /* some system..., see above */ - if (!p && size) { - queue_signals(); - r = malloc(size); - unqueue_signals(); - return (MALLOC_RET_T) r; - } - - /* and some systems even do this... */ - if (!p || !size) - return (MALLOC_RET_T) p; - - queue_signals(); /* just queue signals caught rather than handling them */ - - /* check if we are reallocating a small block, if we do, we have - to compute the size of the block from the sort of block it is in */ - for (i = 0; i < M_NSMALL; i++) { - for (mt = m_small[i]; - mt && (((char *)mt) > ((char *)p) || - (((char *)mt) + mt->len) < ((char *)p)); - mt = mt->next); - - if (mt) { - l = M_BSLEN(mt->len); - break; - } - } - if (!l) - /* otherwise the size of the block is in the memory just before - the given address */ - l = m->len; - - /* now allocate the new block, copy the old contents, and free the - old block */ - r = malloc(size); - memcpy(r, (char *)p, (size > l) ? l : size); - free(p); - - unqueue_signals(); - return (MALLOC_RET_T) r; -} - -MALLOC_RET_T -calloc(MALLOC_ARG_T n, MALLOC_ARG_T size) -{ - long l; - char *r; - - if (!(l = n * size)) - return (MALLOC_RET_T) m_high; - - /* - * use realloc() (with a NULL `p` argument it behaves exactly the same - * as malloc() does) to prevent an infinite loop caused by sibling-call - * optimizations (the malloc() call would otherwise be replaced by an - * unconditional branch back to line 1719 ad infinitum). - */ - r = realloc(NULL, l); - - memset(r, 0, l); - - return (MALLOC_RET_T) r; -} - -#ifdef ZSH_MEM_DEBUG - -/**/ -int -bin_mem(char *name, char **argv, Options ops, int func) -{ - int i, ii, fi, ui, j; - struct m_hdr *m, *mf, *ms; - char *b, *c, buf[40]; - long u = 0, f = 0, to, cu; - - queue_signals(); - if (OPT_ISSET(ops,'v')) { - printf("The lower and the upper addresses of the heap. Diff gives\n"); - printf("the difference between them, i.e. the size of the heap.\n\n"); - } - printf("low mem %ld\t high mem %ld\t diff %ld\n", - (long)m_l, (long)m_high, (long)(m_high - ((char *)m_l))); - - if (OPT_ISSET(ops,'v')) { - printf("\nThe number of bytes that were allocated using sbrk() and\n"); - printf("the number of bytes that were given back to the system\n"); - printf("via brk().\n"); - } - printf("\nsbrk %d\tbrk %d\n", m_s, m_b); - - if (OPT_ISSET(ops,'v')) { - printf("\nInformation about the sizes that were allocated or freed.\n"); - printf("For each size that were used the number of mallocs and\n"); - printf("frees is shown. Diff gives the difference between these\n"); - printf("values, i.e. the number of blocks of that size that is\n"); - printf("currently allocated. Total is the product of size and diff,\n"); - printf("i.e. the number of bytes that are allocated for blocks of\n"); - printf("this size. The last field gives the accumulated number of\n"); - printf("bytes for all sizes.\n"); - } - printf("\nsize\tmalloc\tfree\tdiff\ttotal\tcum\n"); - for (i = 0, cu = 0; i < 1024; i++) - if (m_m[i] || m_f[i]) { - to = (long) i * M_ISIZE * (m_m[i] - m_f[i]); - printf("%ld\t%d\t%d\t%d\t%ld\t%ld\n", - (long)i * M_ISIZE, m_m[i], m_f[i], m_m[i] - m_f[i], - to, (cu += to)); - } - - if (m_m[i] || m_f[i]) - printf("big\t%d\t%d\t%d\n", m_m[i], m_f[i], m_m[i] - m_f[i]); - - if (OPT_ISSET(ops,'v')) { - printf("\nThe list of memory blocks. For each block the following\n"); - printf("information is shown:\n\n"); - printf("num\tthe number of this block\n"); - printf("tnum\tlike num but counted separately for used and free\n"); - printf("\tblocks\n"); - printf("addr\tthe address of this block\n"); - printf("len\tthe length of the block\n"); - printf("state\tthe state of this block, this can be:\n"); - printf("\t used\tthis block is used for one big block\n"); - printf("\t free\tthis block is free\n"); - printf("\t small\tthis block is used for an array of small blocks\n"); - printf("cum\tthe accumulated sizes of the blocks, counted\n"); - printf("\tseparately for used and free blocks\n"); - printf("\nFor blocks holding small blocks the number of free\n"); - printf("blocks, the number of used blocks and the size of the\n"); - printf("blocks is shown. For otherwise used blocks the first few\n"); - printf("bytes are shown as an ASCII dump.\n"); - } - printf("\nblock list:\nnum\ttnum\taddr\t\tlen\tstate\tcum\n"); - for (m = m_l, mf = m_free, ii = fi = ui = 1; ((char *)m) < m_high; - m = (struct m_hdr *)(((char *)m) + M_ISIZE + m->len), ii++) { - for (j = 0, ms = NULL; j < M_NSMALL && !ms; j++) - for (ms = m_small[j]; ms; ms = ms->next) - if (ms == m) - break; - - if (m == mf) - buf[0] = '\0'; - else if (m == ms) - sprintf(buf, "%ld %ld %ld", (long)(M_SNUM - ms->used), - (long)ms->used, - (long)(m->len - sizeof(struct m_hdr)) / M_SNUM + 1); - - else { - for (i = 0, b = buf, c = (char *)&m->next; i < 20 && i < m->len; - i++, c++) - *b++ = (*c >= ' ' && *c < 127) ? *c : '.'; - *b = '\0'; - } - - printf("%d\t%d\t%ld\t%ld\t%s\t%ld\t%s\n", ii, - (m == mf) ? fi++ : ui++, - (long)m, (long)m->len, - (m == mf) ? "free" : ((m == ms) ? "small" : "used"), - (m == mf) ? (f += m->len) : (u += m->len), - buf); - - if (m == mf) - mf = mf->next; - } - - if (OPT_ISSET(ops,'v')) { - printf("\nHere is some information about the small blocks used.\n"); - printf("For each size the arrays with the number of free and the\n"); - printf("number of used blocks are shown.\n"); - } - printf("\nsmall blocks:\nsize\tblocks (free/used)\n"); - - for (i = 0; i < M_NSMALL; i++) - if (m_small[i]) { - printf("%ld\t", (long)i * M_ISIZE); - - for (ii = 0, m = m_small[i]; m; m = m->next) { - printf("(%ld/%ld) ", (long)(M_SNUM - m->used), - (long)m->used); - if (!((++ii) & 7)) - printf("\n\t"); - } - putchar('\n'); - } - if (OPT_ISSET(ops,'v')) { - printf("\n\nBelow is some information about the allocation\n"); - printf("behaviour of the zsh heaps. First the number of times\n"); - printf("pushheap(), popheap(), and freeheap() were called.\n"); - } - printf("\nzsh heaps:\n\n"); - - printf("push %d\tpop %d\tfree %d\n\n", h_push, h_pop, h_free); - - if (OPT_ISSET(ops,'v')) { - printf("\nThe next list shows for several sizes the number of times\n"); - printf("memory of this size were taken from heaps.\n\n"); - } - printf("size\tmalloc\ttotal\n"); - for (i = 0; i < 1024; i++) - if (h_m[i]) - printf("%ld\t%d\t%ld\n", (long)i * H_ISIZE, h_m[i], - (long)i * H_ISIZE * h_m[i]); - if (h_m[1024]) - printf("big\t%d\n", h_m[1024]); - - unqueue_signals(); - return 0; -} - -#endif - -/**/ -#else /* not ZSH_MEM */ - -/**/ -mod_export void -zfree(void *p, UNUSED(int sz)) -{ - free(p); -} - -/**/ -mod_export void -zsfree(char *p) -{ - free(p); -} - -/**/ -#endif |