? libltdl/autom4te.cache Index: config/alpha/alpha.c =================================================================== RCS file: /cvs/kaffe/kaffe/config/alpha/alpha.c,v retrieving revision 1.2 diff -u -r1.2 alpha.c --- config/alpha/alpha.c 20 Jun 2001 22:50:07 -0000 1.2 +++ config/alpha/alpha.c 16 Jun 2003 18:48:41 -0000 @@ -19,12 +19,12 @@ /* return register number that contains return address if function at pc is a frame-less procedure. Else return -1. */ int -__alpha_ra (int *pc) +__alpha_ra (uintp pc) { int *p; int reg; - for (p = pc; ; p++) { + for (p = (int *)pc; ; p++) { if ((*p & ~(0x1F << 16)) == 0x6be08001) { /* ret $31,($REG),1 */ reg = (*p >> 16) & 0x1F; @@ -55,8 +55,8 @@ __alpha_nextFrame (exceptionFrame *frame) { int *pc; - char *sp; - char *fp; + uintp sp; + uintp fp; int *p; int reg; @@ -74,14 +74,14 @@ asm volatile ("mov $15,%0" : "=r"(fp)); DBG(STACKTRACE, - dprintf ("firstFrame pc %p sp %p fp %p\n", pc, sp, fp); ); + dprintf ("firstFrame pc %p sp %p fp %p\n", pc, (int *) sp, (int *) fp); ); } else { pc = (int *)frame->pc; sp = frame->sp; fp = frame->fp; DBG(STACKTRACE, - dprintf ("nextFrame pc %p sp %p fp %p\n", pc, sp, fp); ); + dprintf ("nextFrame pc %p sp %p fp %p\n", pc, (int *) sp, (int *) fp); ); } if (!jthread_on_current_stack(sp)) { @@ -256,7 +256,7 @@ DBG(STACKTRACE, dprintf ("stq $%d,%d($sp) at %p\n", reg, low, p); ); - frame->pc = (char*) *(long *) (sp + low); + frame->pc = (uintp) *(long *) (sp + low); continue; } @@ -266,7 +266,7 @@ DBG(STACKTRACE, dprintf ("stq $fp,%d($sp) at %p\n", low, p); ); - frame->fp = (char*) *(long *) (sp + low); + frame->fp = (uintp) *(long *) (sp + low); continue; } } @@ -285,7 +285,7 @@ DBG(STACKTRACE, dprintf ("ldq $%d,%d($sp) at %p\n", reg, low, p); ); - frame->pc = (char*) *(long *) (sp + low); + frame->pc = (uintp) *(long *) (sp + low); use_fp = 1; continue; } @@ -296,7 +296,7 @@ DBG(STACKTRACE, dprintf ("ldq $fp,%d($sp) at %p\n", low, p); ); - frame->fp = (char*) *(long *) (sp + low); + frame->fp = (uintp) *(long *) (sp + low); continue; } } Index: config/alpha/linux/jit-md.h =================================================================== RCS file: /cvs/kaffe/kaffe/config/alpha/linux/jit-md.h,v retrieving revision 1.5 diff -u -r1.5 jit-md.h --- config/alpha/linux/jit-md.h 18 Jun 2001 10:38:04 -0000 1.5 +++ config/alpha/linux/jit-md.h 16 Jun 2003 18:48:41 -0000 @@ -64,12 +64,12 @@ /* Structure of exception frame on stack */ typedef struct _exceptionFrame { - char *pc; - char *sp; - char *fp; + uintp pc; + uintp sp; + uintp fp; } exceptionFrame; -int __alpha_ra (int *pc); +int __alpha_ra (uintp pc); exceptionFrame *__alpha_nextFrame (exceptionFrame *frame); /* Extract PC, FP and SP from the given frame */ Index: kaffe/kaffevm/classMethod.h =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/classMethod.h,v retrieving revision 1.54 diff -u -r1.54 classMethod.h --- kaffe/kaffevm/classMethod.h 24 May 2003 20:07:04 -0000 1.54 +++ kaffe/kaffevm/classMethod.h 16 Jun 2003 18:48:42 -0000 @@ -241,7 +241,7 @@ Utf8Const* name; parsed_signature_t* parsed_sig; accessFlags accflags; - short idx; /* Index into class->dtable */ + long idx; /* Index into class->dtable */ u2 stacksz; u2 localsz; /* Only used for static/final/constructor methods */ Index: kaffe/kaffevm/jni.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/jni.c,v retrieving revision 1.83 diff -u -r1.83 jni.c --- kaffe/kaffevm/jni.c 21 May 2003 09:09:49 -0000 1.83 +++ kaffe/kaffevm/jni.c 16 Jun 2003 18:48:42 -0000 @@ -105,7 +105,7 @@ #define KAFFE_JNI_SETEXCEPTFP(ebufp) { \ exceptionFrame currentFrameInfo; \ FIRSTFRAME(currentFrameInfo, 0); \ - vmExcept_setJNIFrame(ebufp, FPFRAME(¤tFrameInfo));\ + vmExcept_setJNIFrame(ebufp, (uintp) FPFRAME(¤tFrameInfo));\ } #else /* Index: kaffe/kaffevm/jit/icode.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/jit/icode.c,v retrieving revision 1.22 diff -u -r1.22 icode.c --- kaffe/kaffevm/jit/icode.c 17 Jun 2001 16:39:09 -0000 1.22 +++ kaffe/kaffevm/jit/icode.c 16 Jun 2003 18:48:42 -0000 @@ -3304,7 +3304,7 @@ /* 'obj' must be written back since it will be reused */ prepare_function_call(); /* FIXME: should there be a pusharg_int_const? */ - pusharg_ref_const((void*)(int)meth->idx, 2); + pusharg_ref_const((void*) meth->idx, 2); pusharg_class_const(meth->class, 1); pusharg_ref(obj, 0); call_soft(soft_lookupinterfacemethod); Index: kaffe/kaffevm/mem/gc-incremental.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/mem/gc-incremental.c,v retrieving revision 1.62 diff -u -r1.62 gc-incremental.c --- kaffe/kaffevm/mem/gc-incremental.c 11 Mar 2003 08:00:18 -0000 1.62 +++ kaffe/kaffevm/mem/gc-incremental.c 16 Jun 2003 18:48:42 -0000 @@ -860,19 +860,53 @@ int i; size_t bsz; int iLockRoot; + int times = 0; assert(gc_init != 0); assert(fidx < nrTypes && size != 0); - unit = gc_heap_malloc(size + sizeof(gc_unit)); - - /* keep pointer to object */ - mem = UTOMEM(unit); - if (unit == 0) { - return 0; - } + size += sizeof(gc_unit); lockStaticMutex(&gc_lock); + + for (unit=0; unit==0;) { + times++; + unit = gc_heap_malloc(size); + + /* keep pointer to object */ + mem = UTOMEM(unit); + if (unit == 0) { + switch (times) { + case 1: + /* Try invoking GC if it is available */ + if (garbageman != 0) { + unlockStaticMutex(&gc_lock); + adviseGC(); + lockStaticMutex(&gc_lock); + } + break; + + case 2: + /* Grow the heap */ + gc_heap_grow(size); + break; + + default: + if (DBGEXPR(CATCHOUTOFMEM, true, false)) { + /* + * If we ran out of memory, a OutOfMemoryException is + * thrown. If we fail to allocate memory for it, all + * is lost. + */ + static int ranout; + assert (ranout++ == 0 || !!!"Ran out of memory!"); + } + /* Guess we've really run out */ + unlockStaticMutex(&gc_lock); + return (0); + } + } + } info = GCMEM2BLOCK(mem); i = GCMEM2IDX(info, unit); Index: kaffe/kaffevm/mem/gc-mem.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/mem/gc-mem.c,v retrieving revision 1.43 diff -u -r1.43 gc-mem.c --- kaffe/kaffevm/mem/gc-mem.c 2 Jun 2003 14:15:47 -0000 1.43 +++ kaffe/kaffevm/mem/gc-mem.c 16 Jun 2003 18:48:42 -0000 @@ -41,7 +41,6 @@ static gc_block* gc_primitive_alloc(size_t); void gc_primitive_free(gc_block*); -static void* gc_system_alloc(size_t); uintp gc_heap_base; uintp gc_block_base; @@ -206,7 +205,7 @@ * of powers of two */ #define OBJSIZE(NR) \ - ((gc_pgsize-GCBLOCK_OVH-ROUNDUPALIGN(1)-(NR*(2+sizeof(void*))))/NR) + ((gc_pgsize-ROUNDUPALIGN(1)-(NR*(2+sizeof(void*))))/NR) /* For a given number of tiles in a block, work out the size of * the allocatable units which'll fit in them and build a translation @@ -280,11 +279,10 @@ gc_heap_initial_size = ROUNDUPPAGESIZE(gc_heap_initial_size); /* allocate heap of initial size from system */ - gc_system_alloc(gc_heap_initial_size); + gc_heap_grow(gc_heap_initial_size); } -/* - * gc_heap_malloc +/** * Allocate a piece of memory. */ void* @@ -292,11 +290,10 @@ { static int gc_heap_init = 0; size_t lnr; - gc_freeobj* mem; + gc_freeobj* mem = 0; gc_block** mptr; gc_block* blk; size_t nsz; - int times; int iLockRoot; /* Initialise GC heap first time in - we must assume single threaded @@ -309,8 +306,6 @@ lockStaticMutex(&gc_heap_lock); - times = 0; - DBG(SLACKANAL, if (GC_SMALL_OBJECT(sz)) { totalslack += (freelist[sztable[sz].list].sz - sz); @@ -318,9 +313,6 @@ } ) - rerun:; - times++; - DBG(GCDIAG, gc_heap_check(); ) @@ -342,8 +334,7 @@ else { blk = gc_small_block(nsz); if (blk == 0) { - nsz = gc_pgsize; - goto nospace; + goto out; } blk->next = *mptr; *mptr = blk; @@ -378,9 +369,7 @@ nsz = sz; blk = gc_large_block(nsz); if (blk == 0) { - nsz = nsz + GCBLOCK_OVH + sizeof(gcFuncs*) + ROUNDUPALIGN(1); - nsz = ROUNDUPPAGESIZE(nsz); - goto nospace; + goto out; } mem = GCBLOCK2FREE(blk, 0); GC_SET_STATE(blk, 0, GC_STATE_NORMAL); @@ -395,60 +384,13 @@ assert(GC_OBJECT_SIZE(mem) >= sz); + out: unlockStaticMutex(&gc_heap_lock); return (mem); - - /* --------------------------------------------------------------- */ - nospace:; - - /* Failed to find space in any freelists. Must try to get the - * memory from somewhere. - */ - - switch (times) { - case 1: - /* Try invoking GC if it is available */ - if (garbageman != 0) { - /* The other caller of invokeGC, Runtime.gc() can't - * give up this lock on its own, since it does not - * hold this lock. - */ - unlockStaticMutex(&gc_heap_lock); - adviseGC(); - lockStaticMutex(&gc_heap_lock); - } - break; - - case 2: - /* Get from the system */ - if (nsz < gc_heap_allocation_size) { - nsz = gc_heap_allocation_size; - } - gc_system_alloc(nsz); - break; - - default: - if (DBGEXPR(CATCHOUTOFMEM, true, false)) - { - /* - * If we ran out of memory, a OutOfMemoryException is - * thrown. If we fail to allocate memory for it, all - * is lost. - */ - static int ranout; - assert (ranout++ == 0 || !!!"Ran out of memory!"); - } - /* Guess we've really run out */ - unlockStaticMutex(&gc_heap_lock); - return (0); - } - - /* Try again */ - goto rerun; } -/* +/** * Free a piece of memory. */ void @@ -523,7 +465,7 @@ } else { /* Calculate true size of block */ - msz = info->size + GCBLOCK_OVH + ROUNDUPALIGN(1); + msz = info->size + ROUNDUPALIGN(1); msz = ROUNDUPPAGESIZE(msz); info->size = msz; gc_primitive_free(info); @@ -555,7 +497,7 @@ } /* Calculate number of objects in this block */ - nr = (gc_pgsize-GCBLOCK_OVH-ROUNDUPALIGN(1))/(sz+2); + nr = (gc_pgsize-ROUNDUPALIGN(1))/(sz+2); /* Setup the meta-data for the block */ DBG(GCDIAG, info->magic = GC_MAGIC); @@ -570,12 +512,14 @@ DBG(GCDIAG, memset(info->data, 0, sz * nr)); /* Build the objects into a free list */ - for (i = nr-1; i >= 0; i--) { + for (i = nr-1; i-- > 0;) { GCBLOCK2FREE(info, i)->next = GCBLOCK2FREE(info, i+1); GC_SET_COLOUR(info, i, GC_COLOUR_FREE); GC_SET_STATE(info, i, GC_STATE_NORMAL); } GCBLOCK2FREE(info, nr-1)->next = 0; + GC_SET_COLOUR(info, nr-1, GC_COLOUR_FREE); + GC_SET_STATE(info, nr-1, GC_STATE_NORMAL); info->free = GCBLOCK2FREE(info, 0); DBG(SLACKANAL, int slack = ((void *)info) @@ -596,7 +540,7 @@ size_t msz; /* Add in management overhead */ - msz = sz+GCBLOCK_OVH+2+ROUNDUPALIGN(1); + msz = sz+2+ROUNDUPALIGN(1); /* Round size up to a number of pages */ msz = ROUNDUPPAGESIZE(msz); @@ -1005,17 +949,33 @@ return GCMEM2BLOCK(heap_addr); } -static -void* -gc_system_alloc(size_t sz) +/** + * Grows the heap. + * + * @param sz minimum number of bytes to grow. + * @return 0 in case of an error, otherwise != 0 + */ +void * +gc_heap_grow(size_t sz) { gc_block* blk; + if (GC_SMALL_OBJECT(sz)) { + sz = gc_pgsize; + } else { + sz = sz + 2 + ROUNDUPALIGN(1); + sz = ROUNDUPPAGESIZE(sz); + } + + if (sz < gc_heap_allocation_size) { + sz = gc_heap_allocation_size; + } + assert(sz % gc_pgsize == 0); if (gc_heap_total == gc_heap_limit) { return (0); - } else if (gc_heap_total + sz > gc_heap_limit) { + } else if (gc_heap_total + sz > gc_heap_limit) { /* take as much memory as we can */ sz = gc_heap_limit - gc_heap_total; assert(sz % gc_pgsize == 0); @@ -1026,13 +986,14 @@ #endif blk = gc_block_alloc(sz); - -DBG(GCSYSALLOC, - dprintf("gc_system_alloc: %ld byte at %p\n", (long) sz, blk); ) + + DBG(GCSYSALLOC, + dprintf("gc_system_alloc: %ld byte at %p\n", (long) sz, blk); ) if (blk == 0) { return (0); } + gc_heap_total += sz; assert(gc_heap_total <= gc_heap_limit); Index: kaffe/kaffevm/mem/gc-mem.h =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/mem/gc-mem.h,v retrieving revision 1.15 diff -u -r1.15 gc-mem.h --- kaffe/kaffevm/mem/gc-mem.h 2 Jun 2003 14:15:47 -0000 1.15 +++ kaffe/kaffevm/mem/gc-mem.h 16 Jun 2003 18:48:42 -0000 @@ -14,6 +14,12 @@ #ifndef __gc_mem_h #define __gc_mem_h +#include "md.h" + +#if !defined(ALIGNMENT_OF_SIZE) +#define ALIGNMENT_OF_SIZE(S) (S) +#endif + #ifndef gc_pgsize extern size_t gc_pgsize; extern int gc_pgbits; @@ -44,7 +50,7 @@ * Alignment for gc_blocks * */ -#define MEMALIGN 8 +#define MEMALIGN (ALIGNMENT_OF_SIZE(sizeof(jdouble))) /** * rounds @V up to the next MEMALIGN boundary. @@ -69,6 +75,8 @@ extern void* gc_heap_malloc(size_t); extern void gc_heap_free(void*); +extern void* gc_heap_grow(size_t); + /** * Evaluates to the size of the object that contains address @M. * @@ -154,14 +162,12 @@ * Evaluates to the first usable address in gc_block @B. * */ -#define GCBLOCK2BASE(B) (((char *)gc_heap_base) \ - + gc_pgsize * ((B) - GC_BLOCKS)) - +#define GCBLOCK2BASE(B) (((char *)gc_heap_base) \ + + gc_pgsize * ((B) - GC_BLOCKS)) /* This is OK, gc_prim_(alloc|free) never assume GCBLOCKEND is really a valid block */ #define GCBLOCKEND(B) ((B) + (((B)->size+gc_pgsize-1)>>gc_pgbits)) -#define GCBLOCK_OVH 0 #define ASSERT_ONBLOCK(OBJ, BLK) assert(GCMEM2BLOCK(OBJ) == BLK)