diff --git a/polymer/eduke32/build/include/malloc.c.h b/polymer/eduke32/build/include/malloc.c.h index e996d1570..374028b26 100644 --- a/polymer/eduke32/build/include/malloc.c.h +++ b/polymer/eduke32/build/include/malloc.c.h @@ -4,7 +4,7 @@ http://creativecommons.org/licenses/publicdomain. Send questions, comments, complaints, performance data, etc to dl@cs.oswego.edu -* Version pre-2.8.4 Mon Nov 27 11:22:37 2006 (dl at gee) +* Version 2.8.4 Wed May 27 09:56:23 2009 Doug Lea (dl at gee) Note: There may be an updated version of this malloc obtainable at ftp://gee.cs.oswego.edu/pub/misc/malloc.c @@ -245,7 +245,8 @@ USE_LOCKS default: 0 (false) pthread or WIN32 mutex lock/unlock. (If set true, this can be overridden on a per-mspace basis for mspace versions.) If set to a non-zero value other than 1, locks are used, but their - implementation is left out, so lock functions must be supplied manually. + implementation is left out, so lock functions must be supplied manually, + as described below. USE_SPIN_LOCKS default: 1 iff USE_LOCKS and on x86 using gcc or MSC If true, uses custom spin locks for locking. This is currently @@ -495,7 +496,6 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #endif /* WIN32 */ #ifdef WIN32 #define WIN32_LEAN_AND_MEAN -// #define _WIN32_WINNT 0x403 #include #define HAVE_MMAP 1 #define HAVE_MORECORE 0 @@ -532,6 +532,12 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #include /* For size_t */ #endif /* LACKS_SYS_TYPES_H */ +#if (defined(__GNUC__) && ((defined(__i386__) || defined(__x86_64__)))) || (defined(_MSC_VER) && _MSC_VER>=1310) +#define SPIN_LOCKS_AVAILABLE 1 +#else +#define SPIN_LOCKS_AVAILABLE 0 +#endif + /* The maximum possible size_t value has all bits set */ #define MAX_SIZE_T (~(size_t)0) @@ -566,11 +572,11 @@ MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP #define USE_LOCKS 0 #endif /* USE_LOCKS */ #ifndef USE_SPIN_LOCKS -#if USE_LOCKS && (defined(__GNUC__) && ((defined(__i386__) || defined(__x86_64__)))) || (defined(_MSC_VER) && _MSC_VER>=1310) +#if USE_LOCKS && SPIN_LOCKS_AVAILABLE #define USE_SPIN_LOCKS 1 #else #define USE_SPIN_LOCKS 0 -#endif /* USE_LOCKS && ... */ +#endif /* USE_LOCKS && SPIN_LOCKS_AVAILABLE. */ #endif /* USE_SPIN_LOCKS */ #ifndef INSECURE #define INSECURE 0 @@ -1144,15 +1150,17 @@ size_t destroy_mspace(mspace msp); mspace create_mspace_with_base(void* base, size_t capacity, int locked); /* - mspace_mmap_large_chunks controls whether requests for large chunks - are allocated in their own mmapped regions, separate from others in - this mspace. By default this is enabled, which reduces - fragmentation. However, such chunks are not necessarily released to - the system upon destroy_mspace. Disabling by setting to false may - increase fragmentation, but avoids leakage when relying on - destroy_mspace to release all memory allocated using this space. + mspace_track_large_chunks controls whether requests for large chunks + are allocated in their own untracked mmapped regions, separate from + others in this mspace. By default large chunks are not tracked, + which reduces fragmentation. However, such chunks are not + necessarily released to the system upon destroy_mspace. Enabling + tracking by setting to true may increase fragmentation, but avoids + leakage when relying on destroy_mspace to release all memory + allocated using this space. The function returns the previous + setting. */ -int mspace_mmap_large_chunks(mspace msp, int enable); +int mspace_track_large_chunks(mspace msp, int enable); /* @@ -1280,7 +1288,7 @@ int mspace_mallopt(int, int); #ifndef LACKS_ERRNO_H #include /* for MALLOC_FAILURE_ACTION */ #endif /* LACKS_ERRNO_H */ -#if FOOTERS +#if FOOTERS || DEBUG #include /* for magic initialization */ #endif /* FOOTERS */ #ifndef LACKS_STDLIB_H @@ -1288,6 +1296,7 @@ int mspace_mallopt(int, int); #endif /* LACKS_STDLIB_H */ #ifdef DEBUG #if ABORT_ON_ASSERT_FAILURE +#undef assert #define assert(x) if(!(x)) ABORT #else /* ABORT_ON_ASSERT_FAILURE */ #include @@ -1308,7 +1317,14 @@ int mspace_mallopt(int, int); #endif /* USE_BUILTIN_FFS */ #if HAVE_MMAP #ifndef LACKS_SYS_MMAN_H +/* On some versions of linux, mremap decl in mman.h needs __USE_GNU set */ +#if (defined(linux) && !defined(__USE_GNU)) +#define __USE_GNU 1 +#include /* for mmap */ +#undef __USE_GNU +#else #include /* for mmap */ +#endif /* linux */ #endif /* LACKS_SYS_MMAN_H */ #ifndef LACKS_FCNTL_H #include @@ -1602,7 +1618,6 @@ static FORCEINLINE int win32munmap(void* ptr, size_t size) { * Define CALL_MMAP/CALL_MUNMAP/CALL_DIRECT_MMAP */ #if HAVE_MMAP - #define IS_MMAPPED_BIT (SIZE_T_ONE) #define USE_MMAP_BIT (SIZE_T_ONE) #ifdef MMAP @@ -1621,7 +1636,6 @@ static FORCEINLINE int win32munmap(void* ptr, size_t size) { #define CALL_DIRECT_MMAP(s) DIRECT_MMAP_DEFAULT(s) #endif /* DIRECT_MMAP */ #else /* HAVE_MMAP */ - #define IS_MMAPPED_BIT (SIZE_T_ZERO) #define USE_MMAP_BIT (SIZE_T_ZERO) #define MMAP(s) MFAIL @@ -1671,29 +1685,33 @@ static FORCEINLINE int win32munmap(void* ptr, size_t size) { Because lock-protected regions generally have bounded times, it is OK to use the supplied simple spinlocks in the custom versions for - x86. + x86. Spinlocks are likely to improve performance for lightly + contended applications, but worsen performance under heavy + contention. If USE_LOCKS is > 1, the definitions of lock routines here are - bypassed, in which case you will need to define at least - INITIAL_LOCK, ACQUIRE_LOCK, RELEASE_LOCK and possibly TRY_LOCK - (which is not used in this malloc, but commonly needed in - extensions.) + bypassed, in which case you will need to define the type MLOCK_T, + and at least INITIAL_LOCK, ACQUIRE_LOCK, RELEASE_LOCK and possibly + TRY_LOCK (which is not used in this malloc, but commonly needed in + extensions.) You must also declare a + static MLOCK_T malloc_global_mutex = { initialization values };. + */ #if USE_LOCKS == 1 -#if USE_SPIN_LOCKS +#if USE_SPIN_LOCKS && SPIN_LOCKS_AVAILABLE #ifndef WIN32 /* Custom pthread-style spin locks on x86 and x64 for gcc */ struct pthread_mlock_t { volatile unsigned int l; - volatile unsigned int c; - volatile pthread_t threadid; + unsigned int c; + pthread_t threadid; }; #define MLOCK_T struct pthread_mlock_t #define CURRENT_THREAD pthread_self() -#define INITIAL_LOCK(sl) (memset(sl, 0, sizeof(MLOCK_T)), 0) +#define INITIAL_LOCK(sl) ((sl)->threadid = 0, (sl)->l = (sl)->c = 0, 0) #define ACQUIRE_LOCK(sl) pthread_acquire_lock(sl) #define RELEASE_LOCK(sl) pthread_release_lock(sl) #define TRY_LOCK(sl) pthread_try_lock(sl) @@ -1722,10 +1740,11 @@ static FORCEINLINE int pthread_acquire_lock (MLOCK_T *sl) { : "memory", "cc"); if (!ret) { assert(!sl->threadid); - sl->c = 1; sl->threadid = CURRENT_THREAD; + sl->c = 1; return 0; } + } if ((++spins & SPINS_PER_YIELD) == 0) { #if defined (__SVR4) && defined (__sun) /* solaris */ thr_yield(); @@ -1739,14 +1758,13 @@ static FORCEINLINE int pthread_acquire_lock (MLOCK_T *sl) { } } } -} static FORCEINLINE void pthread_release_lock (MLOCK_T *sl) { - assert(sl->l != 0); + volatile unsigned int* lp = &sl->l; + assert(*lp != 0); assert(sl->threadid == CURRENT_THREAD); if (--sl->c == 0) { sl->threadid = 0; - volatile unsigned int* lp = &sl->l; int prev = 0; int ret; __asm__ __volatile__ ("lock; xchgl %0, %1" @@ -1774,8 +1792,8 @@ static FORCEINLINE int pthread_try_lock (MLOCK_T *sl) { : "memory", "cc"); if (!ret) { assert(!sl->threadid); - sl->c = 1; sl->threadid = CURRENT_THREAD; + sl->c = 1; return 1; } } @@ -1785,16 +1803,15 @@ static FORCEINLINE int pthread_try_lock (MLOCK_T *sl) { #else /* WIN32 */ /* Custom win32-style spin locks on x86 and x64 for MSC */ -struct win32_mlock_t -{ +struct win32_mlock_t { volatile long l; - volatile unsigned int c; - volatile long threadid; + unsigned int c; + long threadid; }; #define MLOCK_T struct win32_mlock_t -#define CURRENT_THREAD win32_getcurrentthreadid() -#define INITIAL_LOCK(sl) (memset(sl, 0, sizeof(MLOCK_T)), 0) +#define CURRENT_THREAD GetCurrentThreadId() +#define INITIAL_LOCK(sl) ((sl)->threadid = 0, (sl)->l = (sl)->c = 0, 0) #define ACQUIRE_LOCK(sl) win32_acquire_lock(sl) #define RELEASE_LOCK(sl) win32_release_lock(sl) #define TRY_LOCK(sl) win32_try_lock(sl) @@ -1802,36 +1819,19 @@ struct win32_mlock_t static MLOCK_T malloc_global_mutex = { 0, 0, 0}; -static FORCEINLINE long win32_getcurrentthreadid() { -#ifdef _MSC_VER -#if defined(_M_IX86) - long *threadstruct=(long *)__readfsdword(0x18); - long threadid=threadstruct[0x24/sizeof(long)]; - return threadid; -#elif defined(_M_X64) - /* todo */ - return GetCurrentThreadId(); -#else - return GetCurrentThreadId(); -#endif -#else - return GetCurrentThreadId(); -#endif -} - static FORCEINLINE int win32_acquire_lock (MLOCK_T *sl) { int spins = 0; for (;;) { if (sl->l != 0) { - if (sl->threadid == CURRENT_THREAD) { + if (sl->threadid == (signed)CURRENT_THREAD) { ++sl->c; return 0; } } else { if (!interlockedexchange(&sl->l, 1)) { - assert(!sl->threadid); - sl->c=CURRENT_THREAD; + assert(!sl->1855 +); sl->threadid = CURRENT_THREAD; sl->c = 1; return 0; @@ -1853,7 +1853,7 @@ static FORCEINLINE void win32_release_lock (MLOCK_T *sl) { static FORCEINLINE int win32_try_lock (MLOCK_T *sl) { if(sl->l != 0) { - if (sl->threadid == CURRENT_THREAD) { + if (sl->threadid == (signed)CURRENT_THREAD) { ++sl->c; return 1; } @@ -1909,9 +1909,9 @@ static int pthread_init_lock (MLOCK_T *sl) { #define MLOCK_T CRITICAL_SECTION #define CURRENT_THREAD GetCurrentThreadId() #define INITIAL_LOCK(s) (!InitializeCriticalSectionAndSpinCount((s), 0x80000000|4000)) -#define ACQUIRE_LOCK(s) (EnterCriticalSection(s), 0) -#define RELEASE_LOCK(s) LeaveCriticalSection(s) -#define TRY_LOCK(s) TryEnterCriticalSection(s) +#define ACQUIRE_LOCK(s) (EnterCriticalSection(sl), 0) +#define RELEASE_LOCK(s) LeaveCriticalSection(sl) +#define TRY_LOCK(s) TryEnterCriticalSection(sl) #define NEED_GLOBAL_LOCK_INIT static MLOCK_T malloc_global_mutex; @@ -1959,8 +1959,12 @@ static void init_malloc_global_mutex() { #endif /* USE_LOCKS */ #if USE_LOCKS +#ifndef ACQUIRE_MALLOC_GLOBAL_LOCK #define ACQUIRE_MALLOC_GLOBAL_LOCK() ACQUIRE_LOCK(&malloc_global_mutex); +#endif +#ifndef RELEASE_MALLOC_GLOBAL_LOCK #define RELEASE_MALLOC_GLOBAL_LOCK() RELEASE_LOCK(&malloc_global_mutex); +#endif #else /* USE_LOCKS */ #define ACQUIRE_MALLOC_GLOBAL_LOCK() #define RELEASE_MALLOC_GLOBAL_LOCK() @@ -2063,8 +2067,9 @@ static void init_malloc_global_mutex() { The C (CINUSE_BIT) bit, stored in the unused second-lowest bit of the chunk size redundantly records whether the current chunk is - inuse. This redundancy enables usage checks within free and realloc, - and reduces indirection when freeing and consolidating chunks. + inuse (unless the chunk is mmapped). This redundancy enables usage + checks within free and realloc, and reduces indirection when freeing + and consolidating chunks. Each freshly allocated chunk must have both cinuse and pinuse set. That is, each allocated chunk borders either a previously allocated @@ -2093,9 +2098,8 @@ static void init_malloc_global_mutex() { space is still allocated for it (TOP_FOOT_SIZE) to enable separation or merging when space is extended. - 3. Chunks allocated via mmap, which have the lowest-order bit - (IS_MMAPPED_BIT) set in their prev_foot fields, and do not set - PINUSE_BIT in their head fields. Because they are allocated + 3. Chunks allocated via mmap, have both cinuse and pinuse bits + cleared in their head fields. Because they are allocated one-by-one, each must carry its own prev_foot field, which is also used to hold the offset this chunk has within its mmapped region, which is needed to preserve alignment. Each mmapped @@ -2161,9 +2165,7 @@ typedef unsigned int flag_t; /* The type of various bit flag sets */ /* The head field of a chunk is or'ed with PINUSE_BIT when previous adjacent chunk in use, and or'ed with CINUSE_BIT if this chunk is in - use. If the chunk was obtained with mmap, the prev_foot field has - IS_MMAPPED_BIT set, otherwise holding the offset of the base of the - mmapped region to the base of the chunk. + use, unless mmapped, in which case both bits are cleared. FLAG4_BIT is not used by this malloc, but might be useful in extensions. */ @@ -2180,10 +2182,12 @@ typedef unsigned int flag_t; /* The type of various bit flag sets */ /* extraction of fields from head words */ #define cinuse(p) ((p)->head & CINUSE_BIT) #define pinuse(p) ((p)->head & PINUSE_BIT) +#define is_inuse(p) (((p)->head & INUSE_BITS) != PINUSE_BIT) +#define is_mmapped(p) (((p)->head & INUSE_BITS) == 0) + #define chunksize(p) ((p)->head & ~(FLAG_BITS)) #define clear_pinuse(p) ((p)->head &= ~PINUSE_BIT) -#define clear_cinuse(p) ((p)->head &= ~CINUSE_BIT) /* Treat space at ptr +/- offset as a chunk */ #define chunk_plus_offset(p, s) ((mchunkptr)(((char*)(p)) + (s))) @@ -2208,9 +2212,6 @@ typedef unsigned int flag_t; /* The type of various bit flag sets */ #define set_free_with_pinuse(p, s, n)\ (clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s)) -#define is_mmapped(p)\ - (!((p)->head & PINUSE_BIT) && ((p)->prev_foot & IS_MMAPPED_BIT)) - /* Get the internal overhead associated with chunk p */ #define overhead_for(p)\ (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD) @@ -2381,7 +2382,7 @@ typedef struct malloc_tree_chunk* tbinptr; /* The type of bins of trees */ and so should not try to deallocate or merge with others. (This currently holds only for the initial segment passed into create_mspace_with_base.) - * If IS_MMAPPED_BIT set, the segment may be merged with + * If USE_MMAP_BIT set, the segment may be merged with other surrounding mmapped segments and trimmed/de-allocated using munmap. * If neither bit is set, then the segment was obtained using @@ -2396,7 +2397,7 @@ struct malloc_segment { flag_t sflags; /* mmap and extern flag */ }; -#define is_mmapped_segment(S) ((S)->sflags & IS_MMAPPED_BIT) +#define is_mmapped_segment(S) ((S)->sflags & USE_MMAP_BIT) #define is_extern_segment(S) ((S)->sflags & EXTERN_BIT) typedef struct malloc_segment msegment; @@ -2543,7 +2544,7 @@ struct malloc_params { static struct malloc_params mparams; /* Ensure mparams initialized */ -#define ensure_initialization() if (mparams.magic == 0) init_mparams() +#define ensure_initialization() (void)(mparams.magic != 0 || init_mparams()) #if !ONLY_MSPACES @@ -2752,7 +2753,7 @@ static size_t traverse_and_check(mstate m); I = NTREEBINS-1;\ else {\ unsigned int K;\ - __asm__("bsrl\t%1, %0\n\t" : "=r" (K) : "rm" (X));\ + __asm__("bsrl\t%1, %0\n\t" : "=r" (K) : "g" (X));\ I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\ }\ } @@ -2850,7 +2851,7 @@ static size_t traverse_and_check(mstate m); #define compute_bit2idx(X, I)\ {\ unsigned int J;\ - __asm__("bsfl\t%1, %0\n\t" : "=r" (J) : "rm" (X));\ + __asm__("bsfl\t%1, %0\n\t" : "=r" (J) : "g" (X));\ I = (bindex_t)J;\ } @@ -2921,15 +2922,15 @@ static size_t traverse_and_check(mstate m); #define ok_address(M, a) ((char*)(a) >= (M)->least_addr) /* Check if address of next chunk n is higher than base chunk p */ #define ok_next(p, n) ((char*)(p) < (char*)(n)) -/* Check if p has its cinuse bit on */ -#define ok_cinuse(p) cinuse(p) +/* Check if p has inuse status */ +#define ok_inuse(p) is_inuse(p) /* Check if p has its pinuse bit on */ #define ok_pinuse(p) pinuse(p) #else /* !INSECURE */ #define ok_address(M, a) (1) #define ok_next(b, n) (1) -#define ok_cinuse(p) (1) +#define ok_inuse(p) (1) #define ok_pinuse(p) (1) #endif /* !INSECURE */ @@ -2958,6 +2959,8 @@ static size_t traverse_and_check(mstate m); #define mark_inuse_foot(M,p,s) +/* Macros for setting head/foot of non-mmapped chunks */ + /* Set cinuse bit and pinuse bit of next chunk */ #define set_inuse(M,p,s)\ ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\ @@ -3058,7 +3061,6 @@ static int init_mparams(void) { INITIAL_LOCK(&gm->mutex); #endif -#if (FOOTERS && !INSECURE) { #if USE_DEV_RANDOM int fd; @@ -3078,13 +3080,9 @@ static int init_mparams(void) { #endif magic |= (size_t)8U; /* ensure nonzero */ magic &= ~(size_t)7U; /* improve chances of fault for bad values */ - } -#else /* (FOOTERS && !INSECURE) */ - magic = (size_t)0x58585858U; -#endif /* (FOOTERS && !INSECURE) */ - mparams.magic = magic; } + } RELEASE_MALLOC_GLOBAL_LOCK(); return 1; @@ -3092,8 +3090,9 @@ static int init_mparams(void) { /* support for mallopt */ static int change_mparam(int param_number, int value) { - size_t val = (value == -1)? MAX_SIZE_T : (size_t)value; + size_t val; ensure_initialization(); + val = (value == -1)? MAX_SIZE_T : (size_t)value; switch(param_number) { case M_TRIM_THRESHOLD: mparams.trim_threshold = val; @@ -3139,7 +3138,7 @@ static void do_check_top_chunk(mstate m, mchunkptr p) { /* Check properties of (inuse) mmapped chunks */ static void do_check_mmapped_chunk(mstate m, mchunkptr p) { size_t sz = chunksize(p); - size_t len = (sz + (p->prev_foot & ~IS_MMAPPED_BIT) + MMAP_FOOT_PAD); + size_t len = (sz + (p->prev_foot) + MMAP_FOOT_PAD); assert(is_mmapped(p)); assert(use_mmap(m)); assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD)); @@ -3153,7 +3152,7 @@ static void do_check_mmapped_chunk(mstate m, mchunkptr p) { /* Check properties of inuse chunks */ static void do_check_inuse_chunk(mstate m, mchunkptr p) { do_check_any_chunk(m, p); - assert(cinuse(p)); + assert(is_inuse(p)); assert(next_pinuse(p)); /* If not pinuse and not mmapped, previous chunk has OK offset */ assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p); @@ -3166,7 +3165,7 @@ static void do_check_free_chunk(mstate m, mchunkptr p) { size_t sz = chunksize(p); mchunkptr next = chunk_plus_offset(p, sz); do_check_any_chunk(m, p); - assert(!cinuse(p)); + assert(!is_inuse(p)); assert(!next_pinuse(p)); assert (!is_mmapped(p)); if (p != m->dv && p != m->top) { @@ -3175,7 +3174,7 @@ static void do_check_free_chunk(mstate m, mchunkptr p) { assert(is_aligned(chunk2mem(p))); assert(next->prev_foot == sz); assert(pinuse(p)); - assert (next == m->top || cinuse(next)); + assert (next == m->top || is_inuse(next)); assert(p->fd->bk == p); assert(p->bk->fd == p); } @@ -3188,7 +3187,7 @@ static void do_check_free_chunk(mstate m, mchunkptr p) { static void do_check_malloced_chunk(mstate m, void* mem, size_t s) { if (mem != 0) { mchunkptr p = mem2chunk(mem); - size_t sz = p->head & ~(PINUSE_BIT|CINUSE_BIT); + size_t sz = p->head & ~INUSE_BITS; do_check_inuse_chunk(m, p); assert((sz & CHUNK_ALIGN_MASK) == 0); assert(sz >= MIN_CHUNK_SIZE); @@ -3215,7 +3214,7 @@ static void do_check_tree(mstate m, tchunkptr t) { do_check_any_chunk(m, ((mchunkptr)u)); assert(u->index == tindex); assert(chunksize(u) == tsize); - assert(!cinuse(u)); + assert(!is_inuse(u)); assert(!next_pinuse(u)); assert(u->fd->bk == u); assert(u->bk->fd == u); @@ -3333,13 +3332,13 @@ static size_t traverse_and_check(mstate m) { while (segment_holds(s, q) && q != m->top && q->head != FENCEPOST_HEAD) { sum += chunksize(q); - if (cinuse(q)) { + if (is_inuse(q)) { assert(!bin_find(m, q)); do_check_inuse_chunk(m, q); } else { assert(q == m->dv || bin_find(m, q)); - assert(lastq == 0 || cinuse(lastq)); /* Not 2 consecutive free */ + assert(lastq == 0 || is_inuse(lastq)); /* Not 2 consecutive free */ do_check_free_chunk(m, q); } lastq = q; @@ -3400,7 +3399,7 @@ static struct mallinfo internal_mallinfo(mstate m) { q != m->top && q->head != FENCEPOST_HEAD) { size_t sz = chunksize(q); sum += sz; - if (!cinuse(q)) { + if (!is_inuse(q)) { mfree += sz; ++nfree; } @@ -3441,7 +3440,7 @@ static void internal_malloc_stats(mstate m) { mchunkptr q = align_as_chunk(s->base); while (segment_holds(s, q) && q != m->top && q->head != FENCEPOST_HEAD) { - if (!cinuse(q)) + if (!is_inuse(q)) used -= chunksize(q); q = next_chunk(q); } @@ -3714,9 +3713,7 @@ static void internal_malloc_stats(mstate m) { the mmapped region stored in the prev_foot field of the chunk. This allows reconstruction of the required argument to MUNMAP when freed, and also allows adjustment of the returned chunk to meet alignment - requirements (especially in memalign). There is also enough space - allocated to hold a fake next chunk of size SIZE_T_SIZE to maintain - the PINUSE bit so frees can be checked. + requirements (especially in memalign). */ /* Malloc using mmap */ @@ -3728,13 +3725,13 @@ static void* mmap_alloc(mstate m, size_t nb) { size_t offset = align_offset(chunk2mem(mm)); size_t psize = mmsize - offset - MMAP_FOOT_PAD; mchunkptr p = (mchunkptr)(mm + offset); - p->prev_foot = offset | IS_MMAPPED_BIT; - (p)->head = (psize|CINUSE_BIT); + p->prev_foot = offset; + p->head = psize; mark_inuse_foot(m, p, psize); chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD; chunk_plus_offset(p, psize+SIZE_T_SIZE)->head = 0; - if (mm < m->least_addr) + if (m->least_addr == 0 || mm < m->least_addr) m->least_addr = mm; if ((m->footprint += mmsize) > m->max_footprint) m->max_footprint = m->footprint; @@ -3756,7 +3753,7 @@ static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb) { (oldsize - nb) <= (mparams.granularity << 1)) return oldp; else { - size_t offset = oldp->prev_foot & ~IS_MMAPPED_BIT; + size_t offset = oldp->prev_foot; size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD; size_t newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK); char* cp = (char*)CALL_MREMAP((char*)oldp - offset, @@ -3764,7 +3761,7 @@ static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb) { if (cp != CMFAIL) { mchunkptr newp = (mchunkptr)(cp + offset); size_t psize = newmmsize - offset - MMAP_FOOT_PAD; - newp->head = (psize|CINUSE_BIT); + newp->head = psize; mark_inuse_foot(m, newp, psize); chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD; chunk_plus_offset(newp, psize+SIZE_T_SIZE)->head = 0; @@ -3853,7 +3850,7 @@ static void* prepend_alloc(mstate m, char* newbase, char* oldbase, set_size_and_pinuse_of_free_chunk(q, dsize); } else { - if (!cinuse(oldfirst)) { + if (!is_inuse(oldfirst)) { size_t nsize = chunksize(oldfirst); unlink_chunk(m, oldfirst, nsize); oldfirst = chunk_plus_offset(oldfirst, nsize); @@ -3931,8 +3928,8 @@ static void* sys_alloc(mstate m, size_t nb) { ensure_initialization(); - /* Directly map large chunks */ - if (use_mmap(m) && nb >= mparams.mmap_threshold) { + /* Directly map large chunks, but only if already initialized */ + if (use_mmap(m) && nb >= mparams.mmap_threshold && m->topsize != 0) { void* mem = mmap_alloc(m, nb); if (mem != 0) return mem; @@ -4026,7 +4023,7 @@ static void* sys_alloc(mstate m, size_t nb) { if (mp != CMFAIL) { tbase = mp; tsize = rsize; - mmap_flag = IS_MMAPPED_BIT; + mmap_flag = USE_MMAP_BIT; } } } @@ -4056,7 +4053,9 @@ static void* sys_alloc(mstate m, size_t nb) { m->max_footprint = m->footprint; if (!is_initialized(m)) { /* first-time initialization */ - m->seg.base = m->least_addr = tbase; + if (m->least_addr == 0 || tbase < m->least_addr) + m->least_addr = tbase; + m->seg.base = tbase; m->seg.size = tsize; m->seg.sflags = mmap_flag; m->magic = mparams.magic; @@ -4082,7 +4081,7 @@ static void* sys_alloc(mstate m, size_t nb) { sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next; if (sp != 0 && !is_extern_segment(sp) && - (sp->sflags & IS_MMAPPED_BIT) == mmap_flag && + (sp->sflags & USE_MMAP_BIT) == mmap_flag && segment_holds(sp, m->top)) { /* append */ sp->size += tsize; init_top(m, m->top, m->topsize + tsize); @@ -4095,7 +4094,7 @@ static void* sys_alloc(mstate m, size_t nb) { sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next; if (sp != 0 && !is_extern_segment(sp) && - (sp->sflags & IS_MMAPPED_BIT) == mmap_flag) { + (sp->sflags & USE_MMAP_BIT) == mmap_flag) { char* oldbase = sp->base; sp->base = tbase; sp->size += tsize; @@ -4139,7 +4138,7 @@ static size_t release_unused_segments(mstate m) { mchunkptr p = align_as_chunk(base); size_t psize = chunksize(p); /* Can unmap if first chunk holds entire segment and not pinned */ - if (!cinuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) { + if (!is_inuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) { tchunkptr tp = (tchunkptr)p; assert(segment_holds(sp, (char*)sp)); if (p == m->dv) { @@ -4364,7 +4363,7 @@ static void* internal_realloc(mstate m, void* oldmem, size_t bytes) { /* Try to either shrink or extend into top. Else malloc-copy-free */ - if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) && + if (RTCHECK(ok_address(m, oldp) && ok_inuse(oldp) && ok_next(oldp, next) && ok_pinuse(next))) { size_t nb = request2size(bytes); if (is_mmapped(oldp)) @@ -4375,7 +4374,7 @@ static void* internal_realloc(mstate m, void* oldmem, size_t bytes) { if (rsize >= MIN_CHUNK_SIZE) { mchunkptr remainder = chunk_plus_offset(newp, nb); set_inuse(m, newp, nb); - set_inuse(m, remainder, rsize); + set_inuse_and_pinuse(m, remainder, rsize); extra = chunk2mem(remainder); } } @@ -4396,6 +4395,11 @@ static void* internal_realloc(mstate m, void* oldmem, size_t bytes) { POSTACTION(m); return 0; } +#if DEBUG + if (newp != 0) { + check_inuse_chunk(m, newp); /* Check requires lock */ + } +#endif POSTACTION(m); @@ -4403,7 +4407,6 @@ static void* internal_realloc(mstate m, void* oldmem, size_t bytes) { if (extra != 0) { internal_free(m, extra); } - check_inuse_chunk(m, newp); return chunk2mem(newp); } else { @@ -4468,7 +4471,7 @@ static void* internal_memalign(mstate m, size_t alignment, size_t bytes) { if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */ newp->prev_foot = p->prev_foot + leadsize; - newp->head = (newsize|CINUSE_BIT); + newp->head = newsize; } else { /* Otherwise, give back leader, use the rest */ set_inuse(m, newp, newsize); @@ -4796,13 +4799,12 @@ void dlfree(void* mem) { #endif /* FOOTERS */ if (!PREACTION(fm)) { check_inuse_chunk(fm, p); - if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) { + if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) { size_t psize = chunksize(p); mchunkptr next = chunk_plus_offset(p, psize); if (!pinuse(p)) { size_t prevsize = p->prev_foot; - if ((prevsize & IS_MMAPPED_BIT) != 0) { - prevsize &= ~IS_MMAPPED_BIT; + if (is_mmapped(p)) { psize += prevsize + MMAP_FOOT_PAD; if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) fm->footprint -= psize; @@ -4954,8 +4956,8 @@ void* dlpvalloc(size_t bytes) { } int dlmalloc_trim(size_t pad) { - ensure_initialization(); int result = 0; + ensure_initialization(); if (!PREACTION(gm)) { result = sys_trim(gm, pad); POSTACTION(gm); @@ -4990,7 +4992,7 @@ int dlmallopt(int param_number, int value) { size_t dlmalloc_usable_size(void* mem) { if (mem != 0) { mchunkptr p = mem2chunk(mem); - if (cinuse(p)) + if (is_inuse(p)) return chunksize(p) - overhead_for(p); } return 0; @@ -5007,7 +5009,7 @@ static mstate init_user_mstate(char* tbase, size_t tsize) { mstate m = (mstate)(chunk2mem(msp)); memset(m, 0, msize); INITIAL_LOCK(&m->mutex); - msp->head = (msize|PINUSE_BIT|CINUSE_BIT); + msp->head = (msize|INUSE_BITS); m->seg.base = m->least_addr = tbase; m->seg.size = m->footprint = m->max_footprint = tsize; m->magic = mparams.magic; @@ -5035,7 +5037,7 @@ mspace create_mspace(size_t capacity, int locked) { char* tbase = (char*)(CALL_MMAP(tsize)); if (tbase != CMFAIL) { m = init_user_mstate(tbase, tsize); - m->seg.sflags = IS_MMAPPED_BIT; + m->seg.sflags = USE_MMAP_BIT; set_lock(m, locked); } } @@ -5056,13 +5058,13 @@ mspace create_mspace_with_base(void* base, size_t capacity, int locked) { return (mspace)m; } -int mspace_mmap_large_chunks(mspace msp, int enable) { +int mspace_track_large_chunks(mspace msp, int enable) { int ret = 0; mstate ms = (mstate)msp; if (!PREACTION(ms)) { - if (use_mmap(ms)) + if (!use_mmap(ms)) ret = 1; - if (enable) + if (!enable) enable_mmap(ms); else disable_mmap(ms); @@ -5081,7 +5083,7 @@ size_t destroy_mspace(mspace msp) { size_t size = sp->size; flag_t flag = sp->sflags; sp = sp->next; - if ((flag & IS_MMAPPED_BIT) && !(flag & EXTERN_BIT) && + if ((flag & USE_MMAP_BIT) && !(flag & EXTERN_BIT) && CALL_MUNMAP(base, size) == 0) freed += size; } @@ -5213,11 +5215,11 @@ void* mspace_malloc(mspace msp, size_t bytes) { } void mspace_free(mspace msp, void* mem) { - UNREFERENCED_PARAMETER(msp); if (mem != 0) { mchunkptr p = mem2chunk(mem); #if FOOTERS mstate fm = get_mstate_for(p); + msp = msp; /* placate people compiling -Wunused */ #else /* FOOTERS */ mstate fm = (mstate)msp; #endif /* FOOTERS */ @@ -5227,13 +5229,12 @@ void mspace_free(mspace msp, void* mem) { } if (!PREACTION(fm)) { check_inuse_chunk(fm, p); - if (RTCHECK(ok_address(fm, p) && ok_cinuse(p))) { + if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) { size_t psize = chunksize(p); mchunkptr next = chunk_plus_offset(p, psize); if (!pinuse(p)) { size_t prevsize = p->prev_foot; - if ((prevsize & IS_MMAPPED_BIT) != 0) { - prevsize &= ~IS_MMAPPED_BIT; + if (is_mmapped(p)) { psize += prevsize + MMAP_FOOT_PAD; if (CALL_MUNMAP((char*)p - prevsize, psize) == 0) fm->footprint -= psize; @@ -5452,7 +5453,7 @@ struct mallinfo mspace_mallinfo(mspace msp) { size_t mspace_usable_size(void* mem) { if (mem != 0) { mchunkptr p = mem2chunk(mem); - if (cinuse(p)) + if (is_inuse(p)) return chunksize(p) - overhead_for(p); } return 0; @@ -5558,13 +5559,15 @@ int mspace_mallopt(int param_number, int value) { /* ----------------------------------------------------------------------- History: - V2.8.4 (not yet released) - * Add mspace_mmap_large_chunks; thanks to Jean Brouwers + V2.8.4 Wed May 27 09:56:23 2009 Doug Lea (dl at gee) + * Use zeros instead of prev foot for is_mmapped + * Add mspace_track_large_chunks; thanks to Jean Brouwers + * Fix set_inuse in internal_realloc; thanks to Jean Brouwers * Fix insufficient sys_alloc padding when using 16byte alignment * Fix bad error check in mspace_footprint - * Adaptations for ptmalloc, courtesy of Wolfram Gloger. - * Reentrant spin locks, courtesy of Earl Chew and others - * Win32 improvements, courtesy of Niall Douglas and Earl Chew + * Adaptations for ptmalloc; thanks to Wolfram Gloger. + * Reentrant spin locks; thanks to Earl Chew and others + * Win32 improvements; thanks to Niall Douglas and Earl Chew * Add NO_SEGMENT_TRAVERSAL and MAX_RELEASE_CHECK_RATE options * Extension hook in malloc_state * Various small adjustments to reduce warnings on some compilers diff --git a/polymer/eduke32/build/include/nedmalloc.h b/polymer/eduke32/build/include/nedmalloc.h index 44ab695c4..1d0aba78a 100644 --- a/polymer/eduke32/build/include/nedmalloc.h +++ b/polymer/eduke32/build/include/nedmalloc.h @@ -166,6 +166,12 @@ Optionally can also retrieve pool. */ EXTSPEC void *nedgetvalue(nedpool **p, void *mem) THROWSPEC; +/* Trims the thread cache for the calling thread, returning any existing cache +data to the central pool. Remember to ALWAYS call with zero if you used the +system pool. Setting disable to non-zero replicates neddisablethreadcache(). +*/ +EXTSPEC void nedtrimthreadcache(nedpool *p, int disable) THROWSPEC; + /* Disables the thread cache for the calling thread, returning any existing cache data to the central pool. Remember to ALWAYS call with zero if you used the system pool. diff --git a/polymer/eduke32/build/src/kplib.c b/polymer/eduke32/build/src/kplib.c index f28336377..10699d512 100644 --- a/polymer/eduke32/build/src/kplib.c +++ b/polymer/eduke32/build/src/kplib.c @@ -206,7 +206,7 @@ int32_t bitrev(int32_t, int32_t); "beg: shr ebx, 1"\ "adc eax, eax"\ "dec ecx"\ - "jnz int16_t beg"\ + "jnz short beg"\ parm [ebx][ecx]\ modify nomemory exact [eax ebx ecx]\ value [eax] @@ -263,7 +263,7 @@ static _inline int32_t bitrev(int32_t b, int32_t c) beg: shr edx, 1 adc eax, eax sub ecx, 1 - jnz int16_t beg + jnz short beg } } @@ -602,26 +602,26 @@ int32_t Paeth686(int32_t, int32_t, int32_t); void rgbhlineasm(int32_t, int32_t, int32_t, int32_t); #pragma aux rgbhlineasm =\ "sub ecx, edx"\ - "jle int16_t endit"\ + "jle short endit"\ "add edx, offset olinbuf"\ "cmp dword ptr trnsrgb, 0"\ - "jz int16_t begit2"\ + "jz short begit2"\ "begit: mov eax, dword ptr [ecx+edx]"\ "or eax, 0xff000000"\ "cmp eax, dword ptr trnsrgb"\ - "jne int16_t skipit"\ + "jne short skipit"\ "and eax, 0xffffff"\ "skipit: sub ecx, 3"\ "mov [edi], eax"\ "lea edi, [edi+ebx]"\ - "jnz int16_t begit"\ - "jmp int16_t endit"\ + "jnz short begit"\ + "jmp short endit"\ "begit2: mov eax, dword ptr [ecx+edx]"\ "or eax, 0xff000000"\ "sub ecx, 3"\ "mov [edi], eax"\ "lea edi, [edi+ebx]"\ - "jnz int16_t begit2"\ + "jnz short begit2"\ "endit:"\ parm [ecx][edx][edi][ebx]\ modify exact [eax ecx edi]\ @@ -630,14 +630,14 @@ void rgbhlineasm(int32_t, int32_t, int32_t, int32_t); void pal8hlineasm(int32_t, int32_t, int32_t, int32_t); #pragma aux pal8hlineasm =\ "sub ecx, edx"\ - "jle int16_t endit"\ + "jle short endit"\ "add edx, offset olinbuf"\ "begit: movzx eax, byte ptr [ecx+edx]"\ "mov eax, dword ptr palcol[eax*4]"\ "dec ecx"\ "mov [edi], eax"\ "lea edi, [edi+ebx]"\ - "jnz int16_t begit"\ + "jnz short begit"\ "endit:"\ parm [ecx][edx][edi][ebx]\ modify exact [eax ecx edi]\ @@ -684,29 +684,29 @@ static _inline void rgbhlineasm(int32_t c, int32_t d, int32_t t, int32_t b) mov edi, t mov ebx, b sub ecx, edx - jle int16_t endit + jle short endit add edx, offset olinbuf cmp dword ptr trnsrgb, 0 - jz int16_t begit2 + jz short begit2 begit: mov eax, dword ptr [ecx+edx] or eax, 0xff000000 cmp eax, dword ptr trnsrgb - jne int16_t skipit + jne short skipit and eax, 0xffffff skipit: sub ecx, 3 mov [edi], eax lea edi, [edi+ebx] - jnz int16_t begit - jmp int16_t endit + jnz short begit + jmp short endit begit2: mov eax, dword ptr [ecx+edx] or eax, 0xff000000 sub ecx, 3 mov [edi], eax lea edi, [edi+ebx] - jnz int16_t begit2 + jnz short begit2 endit: pop edi pop ebx @@ -720,7 +720,7 @@ static _inline void pal8hlineasm(int32_t c, int32_t d, int32_t t, int32_t b) mov ecx, c mov edx, d sub ecx, edx - jle int16_t endit + jle short endit push ebx push edi @@ -732,7 +732,7 @@ begit:movzx eax, byte ptr [ecx+edx] sub ecx, 1 mov [edi], eax lea edi, [edi+ebx] - jnz int16_t begit + jnz short begit pop edi pop ebx endit: diff --git a/polymer/eduke32/build/src/nedmalloc.c b/polymer/eduke32/build/src/nedmalloc.c index df2580f2b..7722d5909 100644 --- a/polymer/eduke32/build/src/nedmalloc.c +++ b/polymer/eduke32/build/src/nedmalloc.c @@ -101,7 +101,7 @@ DEALINGS IN THE SOFTWARE. #define THREADCACHEMAXBINS (13-4) #elif THREADCACHEMAX == 65536 #define THREADCACHEMAXBINS (16-4) -#else +#else #error undefined size #endif #endif @@ -725,7 +725,7 @@ void *nedgetvalue(nedpool **p, void *mem) THROWSPEC return np->uservalue; } -void neddisablethreadcache(nedpool *p) THROWSPEC +void nedtrimthreadcache(nedpool *p, int disable) THROWSPEC { int mycache; if (!p) @@ -736,7 +736,7 @@ void neddisablethreadcache(nedpool *p) THROWSPEC mycache=(int)(size_t) TLSGET(p->mycache); if (!mycache) { /* Set to mspace 0 */ - if (TLSSET(p->mycache, (void *)-1)) abort(); + if (disable && TLSSET(p->mycache, (void *)-1)) abort(); } else if (mycache>0) { /* Set to last used mspace */ @@ -745,16 +745,23 @@ void neddisablethreadcache(nedpool *p) THROWSPEC printf("Threadcache utilisation: %lf%% in cache with %lf%% lost to other threads\n", 100.0*tc->successes/tc->mallocs, 100.0*((double) tc->mallocs-tc->frees)/tc->mallocs); #endif - if (TLSSET(p->mycache, (void *)(size_t)(-tc->mymspace))) abort(); + if (disable && TLSSET(p->mycache, (void *)(size_t)(-tc->mymspace))) abort(); tc->frees++; RemoveCacheEntries(p, tc, 0); assert(!tc->freeInCache); - tc->mymspace=-1; - tc->threadid=0; - mspace_free(0, p->caches[mycache-1]); - p->caches[mycache-1]=0; + if (disable) + { + tc->mymspace=-1; + tc->threadid=0; + mspace_free(0, p->caches[mycache-1]); + p->caches[mycache-1]=0; + } } } +void neddisablethreadcache(nedpool *p) THROWSPEC +{ + nedtrimthreadcache(p, 1); +} #define GETMSPACE(m,p,tc,ms,s,action) \ do \ @@ -783,12 +790,12 @@ static FORCEINLINE void GetThreadCache(nedpool **p, threadcache **tc, int *mymsp } mycache=(int)(size_t) TLSGET((*p)->mycache); if (mycache>0) - { + { /* Already have a cache */ *tc=(*p)->caches[mycache-1]; *mymspace=(*tc)->mymspace; } else if (!mycache) - { + { /* Need to allocate a new cache */ *tc=AllocCache(*p); if (!*tc) { /* Disable */ @@ -799,12 +806,12 @@ static FORCEINLINE void GetThreadCache(nedpool **p, threadcache **tc, int *mymsp *mymspace=(*tc)->mymspace; } else - { + { /* Cache disabled, but we do have an assigned thread pool */ *tc=0; *mymspace=-mycache-1; } assert(*mymspace>=0); - assert((long)(size_t)CURRENT_THREAD==(*tc)->threadid); + assert(!(*tc) || (long)(size_t)CURRENT_THREAD==(*tc)->threadid); #ifdef FULLSANITYCHECKS if (*tc) { @@ -918,7 +925,7 @@ void nedpfree(nedpool *p, void *mem) THROWSPEC struct mallinfo nedpmallinfo(nedpool *p) THROWSPEC { int n; - struct mallinfo ret ={0,0,0,0,0,0,0,0,0,0}; + struct mallinfo ret={0,0,0,0,0,0,0,0,0,0}; if (!p) { p=&syspool; if (!syspool.threads) InitPool(&syspool, 0, -1); } for (n=0; p->m[n]; n++) { diff --git a/polymer/eduke32/source/actors.c b/polymer/eduke32/source/actors.c index f91e96d09..9ce6b7cbd 100644 --- a/polymer/eduke32/source/actors.c +++ b/polymer/eduke32/source/actors.c @@ -395,9 +395,9 @@ int32_t A_MoveSprite(int32_t spritenum, const vec3_t *change, uint32_t cliptype) case 1: if (daz >= ActorExtra[spritenum].floorz) { - if (totalclock > ActorExtra[spritenum].temp_data[9]) + if (totalclock > ActorExtra[spritenum].lasttransport) { - ActorExtra[spritenum].temp_data[9] = totalclock + (TICSPERFRAME<<2); + ActorExtra[spritenum].lasttransport = totalclock + (TICSPERFRAME<<2); sprite[spritenum].x += (sprite[OW].x-SX); sprite[spritenum].y += (sprite[OW].y-SY); @@ -415,9 +415,9 @@ int32_t A_MoveSprite(int32_t spritenum, const vec3_t *change, uint32_t cliptype) case 2: if (daz <= ActorExtra[spritenum].ceilingz) { - if (totalclock > ActorExtra[spritenum].temp_data[9]) + if (totalclock > ActorExtra[spritenum].lasttransport) { - ActorExtra[spritenum].temp_data[9] = totalclock + (TICSPERFRAME<<2); + ActorExtra[spritenum].lasttransport = totalclock + (TICSPERFRAME<<2); sprite[spritenum].x += (sprite[OW].x-SX); sprite[spritenum].y += (sprite[OW].y-SY); sprite[spritenum].z = sector[sprite[OW].sectnum].floorz - daz + sector[sprite[i].sectnum].ceilingz; @@ -3278,7 +3278,7 @@ static void G_MoveTransports(void) ll = klabs(sprite[j].zvel); - if (totalclock > ActorExtra[j].temp_data[9]) + if (totalclock > ActorExtra[j].lasttransport) { warpspriteto = 0; if (ll && sectlotag == 2 && sprite[j].z < (sector[sect].ceilingz+ll)) @@ -3386,7 +3386,7 @@ static void G_MoveTransports(void) } break; case 1: - ActorExtra[j].temp_data[9] = totalclock + (TICSPERFRAME<<2); + ActorExtra[j].lasttransport = totalclock + (TICSPERFRAME<<2); sprite[j].x += (sprite[OW].x-SX); sprite[j].y += (sprite[OW].y-SY); @@ -3400,7 +3400,7 @@ static void G_MoveTransports(void) break; case 2: - ActorExtra[j].temp_data[9] = totalclock + (TICSPERFRAME<<2); + ActorExtra[j].lasttransport = totalclock + (TICSPERFRAME<<2); sprite[j].x += (sprite[OW].x-SX); sprite[j].y += (sprite[OW].y-SY); sprite[j].z = sector[sprite[OW].sectnum].floorz; diff --git a/polymer/eduke32/source/duke3d.h b/polymer/eduke32/source/duke3d.h index d58ff590c..11caa478d 100644 --- a/polymer/eduke32/source/duke3d.h +++ b/polymer/eduke32/source/duke3d.h @@ -540,7 +540,7 @@ spriteinterpolate sprpos[MAXSPRITES]; typedef struct { int32_t bposx,bposy,bposz; int32_t floorz,ceilingz,lastvx,lastvy; - int32_t flags; + int32_t flags,lasttransport,shootzvel; intptr_t temp_data[10]; // sometimes used to hold pointers to con code int16_t picnum,ang,extra,owner,movflag; int16_t tempang,actorstayput,dispicnum; diff --git a/polymer/eduke32/source/game.c b/polymer/eduke32/source/game.c index 9f9885993..fb77cf59c 100644 --- a/polymer/eduke32/source/game.c +++ b/polymer/eduke32/source/game.c @@ -4148,8 +4148,8 @@ void G_SE40(int32_t smoothratio) if (sect != -1) { int32_t renderz, picnum; - int16_t backupstat[numsectors]; - int32_t backupz[numsectors]; + int16_t backupstat[MAXSECTORS]; + int32_t backupz[MAXSECTORS]; int32_t i; int32_t pix_diff, newz; // initprintf("drawing ror\n"); diff --git a/polymer/eduke32/source/gameexec.c b/polymer/eduke32/source/gameexec.c index ae832dabc..bfd65e100 100644 --- a/polymer/eduke32/source/gameexec.c +++ b/polymer/eduke32/source/gameexec.c @@ -2068,16 +2068,16 @@ static int32_t X_DoExecute(register int32_t once) if (tw == CON_ZSHOOT || tw == CON_EZSHOOT) { - ActorExtra[vm.g_i].temp_data[9] = Gv_GetVarX(*insptr++); - if (ActorExtra[vm.g_i].temp_data[9] == 0) - ActorExtra[vm.g_i].temp_data[9] = 1; + ActorExtra[vm.g_i].shootzvel = Gv_GetVarX(*insptr++); + if (ActorExtra[vm.g_i].shootzvel == 0) + ActorExtra[vm.g_i].shootzvel = 1; } if ((vm.g_sp->sectnum < 0 || vm.g_sp->sectnum >= numsectors) /* && g_scriptSanityChecks */) { OSD_Printf(CON_ERROR "Invalid sector %d\n",g_errorLineNum,keyw[g_tw],vm.g_sp->sectnum); insptr++; - ActorExtra[vm.g_i].temp_data[9]=0; + ActorExtra[vm.g_i].shootzvel=0; break; } @@ -2086,7 +2086,7 @@ static int32_t X_DoExecute(register int32_t once) if (tw == CON_EZSHOOT || tw == CON_ESHOOT) aGameVars[g_iReturnVarID].val.lValue = j; - ActorExtra[vm.g_i].temp_data[9]=0; + ActorExtra[vm.g_i].shootzvel=0; } break; @@ -2102,23 +2102,23 @@ static int32_t X_DoExecute(register int32_t once) if (tw == CON_ZSHOOTVAR || tw == CON_EZSHOOTVAR) { - ActorExtra[vm.g_i].temp_data[9] = Gv_GetVarX(*insptr++); - if (ActorExtra[vm.g_i].temp_data[9] == 0) - ActorExtra[vm.g_i].temp_data[9] = 1; + ActorExtra[vm.g_i].shootzvel = Gv_GetVarX(*insptr++); + if (ActorExtra[vm.g_i].shootzvel == 0) + ActorExtra[vm.g_i].shootzvel = 1; } j=Gv_GetVarX(*insptr++); if ((vm.g_sp->sectnum < 0 || vm.g_sp->sectnum >= numsectors) /* && g_scriptSanityChecks */) { OSD_Printf(CON_ERROR "Invalid sector %d\n",g_errorLineNum,keyw[g_tw],vm.g_sp->sectnum); - ActorExtra[vm.g_i].temp_data[9]=0; + ActorExtra[vm.g_i].shootzvel=0; break; } lReturn = A_Shoot(vm.g_i, j); if (tw == CON_ESHOOTVAR || tw == CON_EZSHOOTVAR) aGameVars[g_iReturnVarID].val.lValue = lReturn; - ActorExtra[vm.g_i].temp_data[9]=0; + ActorExtra[vm.g_i].shootzvel=0; break; } diff --git a/polymer/eduke32/source/player.c b/polymer/eduke32/source/player.c index 6065c24d0..6d2b5975f 100644 --- a/polymer/eduke32/source/player.c +++ b/polymer/eduke32/source/player.c @@ -460,7 +460,7 @@ int32_t A_Shoot(int32_t i,int32_t atwith) } } - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; hitscan((const vec3_t *)&srcvect,sect, sintable[(sa+512)&2047], sintable[sa&2047],zvel<<6, @@ -682,7 +682,7 @@ int32_t A_Shoot(int32_t i,int32_t atwith) if (!g_player[p].ps->auto_aim) { zvel = (100-g_player[p].ps->horiz-g_player[p].ps->horizoff)<<5; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; hitscan((const vec3_t *)&srcvect,sect,sintable[(sa+512)&2047],sintable[sa&2047], zvel<<6,&hitinfo,CLIPMASK1); if (hitinfo.hitsprite != -1) @@ -734,7 +734,7 @@ int32_t A_Shoot(int32_t i,int32_t atwith) if (ProjectileData[atwith].cstat >= 0) s->cstat &= ~ProjectileData[atwith].cstat; else s->cstat &= ~257; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; hitscan((const vec3_t *)&srcvect,sect, sintable[(sa+512)&2047], sintable[sa&2047], @@ -1038,7 +1038,7 @@ DOSKIPBULLETHOLE: sx+(sintable[(348+sa+512)&2047]/448), sy+(sintable[(sa+348)&2047]/448), sz-(1<<8),atwith,0,14,14,sa,vel,zvel,i,4);*/ - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; j = A_InsertSprite(sect, srcvect.x+(sintable[(348+sa+512)&2047]/ProjectileData[atwith].offset), srcvect.y+(sintable[(sa+348)&2047]/ProjectileData[atwith].offset), @@ -1115,7 +1115,7 @@ DOSKIPBULLETHOLE: } } - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; hitscan((const vec3_t *)&srcvect,sect, sintable[(sa+512)&2047], sintable[sa&2047],zvel<<6, @@ -1270,7 +1270,7 @@ DOSKIPBULLETHOLE: if (!g_player[p].ps->auto_aim) { zvel = (100-g_player[p].ps->horiz-g_player[p].ps->horizoff)<<5; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; hitscan((const vec3_t *)&srcvect,sect,sintable[(sa+512)&2047],sintable[sa&2047], zvel<<6,&hitinfo,CLIPMASK1); if (hitinfo.hitsprite != -1) @@ -1321,7 +1321,7 @@ DOSKIPBULLETHOLE: } s->cstat &= ~257; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; hitscan((const vec3_t *)&srcvect,sect, sintable[(sa+512)&2047], sintable[sa&2047], @@ -1558,7 +1558,7 @@ SKIPBULLETHOLE: if (hitinfo.pos.x == 0) hitinfo.pos.x++; zvel = ((g_player[j].ps->oposz - srcvect.z + (3<<8))*vel) / hitinfo.pos.x; } - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; oldzvel = zvel; if (atwith == SPIT) @@ -1681,7 +1681,7 @@ SKIPBULLETHOLE: if (p >= 0 && j >= 0) l = j; else l = -1; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; j = A_InsertSprite(sect, srcvect.x+(sintable[(348+sa+512)&2047]/448), srcvect.y+(sintable[(sa+348)&2047]/448), @@ -1766,7 +1766,7 @@ SKIPBULLETHOLE: if (p >= 0) zvel = (100-g_player[p].ps->horiz-g_player[p].ps->horizoff)*32; else zvel = 0; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; srcvect.z -= g_player[p].ps->pyoff; hitscan((const vec3_t *)&srcvect,sect, @@ -1830,7 +1830,7 @@ SKIPBULLETHOLE: if (zvel < -4096) zvel = -2048; vel = x>>4; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; A_InsertSprite(sect, srcvect.x+(sintable[(512+sa+512)&2047]>>8), srcvect.y+(sintable[(sa+512)&2047]>>8), @@ -1892,7 +1892,7 @@ SKIPBULLETHOLE: if (sect < 0) break; s->cstat &= ~257; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; hitscan((const vec3_t *)&srcvect,sect, sintable[(sa+512)&2047], sintable[sa&2047], @@ -1971,7 +1971,7 @@ SKIPBULLETHOLE: zvel = ((g_player[j].ps->oposz-srcvect.z)*512) / l ; } else zvel = 0; - if (ActorExtra[i].temp_data[9]) zvel = ActorExtra[i].temp_data[9]; + if (ActorExtra[i].shootzvel) zvel = ActorExtra[i].shootzvel; j = A_InsertSprite(sect, srcvect.x+(sintable[(512+sa+512)&2047]>>12), srcvect.y+(sintable[(sa+512)&2047]>>12),