X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=libjava%2Fboehm.cc;h=855d23cb024a83180e289c3a9e104a35b42be351;hb=73c24b62727247ca680456ad8e84fd001daca5ab;hp=c41dab94387ca1df21052da53931eb291d49a5b9;hpb=2c60951ba0efef23e2b765964b5dc0f1f49438a9;p=pf3gnuchains%2Fgcc-fork.git diff --git a/libjava/boehm.cc b/libjava/boehm.cc index c41dab94387..855d23cb024 100644 --- a/libjava/boehm.cc +++ b/libjava/boehm.cc @@ -1,6 +1,7 @@ // boehm.cc - interface between libjava and Boehm GC. -/* Copyright (C) 1998, 1999 Cygnus Solutions +/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + Free Software Foundation This file is part of libgcj. @@ -11,61 +12,65 @@ details. */ #include #include +#include -#include -#include #include -#include +#include + +#include +#include +#include + +// More nastiness: the GC wants to define TRUE and FALSE. We don't +// need the Java definitions (themselves a hack), so we undefine them. +#undef TRUE +#undef FALSE + +// We include two autoconf headers. Avoid multiple definition warnings. +#undef PACKAGE_NAME +#undef PACKAGE_STRING +#undef PACKAGE_TARNAME +#undef PACKAGE_VERSION + +#ifdef HAVE_DLFCN_H +#undef _GNU_SOURCE +#define _GNU_SOURCE +#include +#endif -// We need to include gc_priv.h. However, it tries to include -// config.h if it hasn't already been included. So we force the -// inclusion of the Boehm config.h. extern "C" { -#include -#include -#include - - // These aren't declared in any Boehm GC header. - void GC_finalize_all (void); - ptr_t GC_debug_generic_malloc (size_t size, int k, GC_EXTRA_PARAMS); -}; +#include -// FIXME: this should probably be defined in some GC header. -#ifdef GC_DEBUG -# define GC_GENERIC_MALLOC(Size, Type) \ - GC_debug_generic_malloc (Size, Type, GC_EXTRAS) -#else -# define GC_GENERIC_MALLOC(Size, Type) GC_generic_malloc (Size, Type) +// Set GC_DEBUG before including gc.h! +#ifdef LIBGCJ_GC_DEBUG +# define GC_DEBUG #endif -// We must check for plausibility ourselves. -#define MAYBE_MARK(Obj, Top, Limit, Source, Exit) \ - if ((ptr_t) (Obj) >= GC_least_plausible_heap_addr \ - && (ptr_t) (Obj) <= GC_greatest_plausible_heap_addr) \ - PUSH_CONTENTS (Obj, Top, Limit, Source, Exit) - -#define ObjectClass _CL_Q34java4lang6Object -extern java::lang::Class ObjectClass; -#define ClassClass _CL_Q34java4lang5Class -extern java::lang::Class ClassClass; +#include +#include +#include // GC_finalize_all declaration. - +#ifdef THREAD_LOCAL_ALLOC +# define GC_REDIRECT_TO_LOCAL +# include +#endif -// Nonzero if this module has been initialized. -static int initialized = 0; + // From boehm's misc.c + void GC_enable(); + void GC_disable(); +}; -// `kind' index used when allocating Java objects. -static int obj_kind_x; +#define MAYBE_MARK(Obj, Top, Limit, Source) \ + Top=GC_MARK_AND_PUSH((GC_PTR) Obj, Top, Limit, (GC_PTR *) Source) // `kind' index used when allocating Java arrays. static int array_kind_x; -// Freelist used for Java objects. -static ptr_t *obj_free_list; - // Freelist used for Java arrays. -static ptr_t *array_free_list; +static void **array_free_list; + +static int _Jv_GC_has_static_roots (const char *filename, void *, size_t); @@ -73,88 +78,103 @@ static ptr_t *array_free_list; // object. We use `void *' arguments and return, and not what the // Boehm GC wants, to avoid pollution in our headers. void * -_Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/) +_Jv_MarkObj (void *addr, void *msp, void *msl, void *env) { - mse *mark_stack_ptr = (mse *) msp; - mse *mark_stack_limit = (mse *) msl; + struct GC_ms_entry *mark_stack_ptr = (struct GC_ms_entry *)msp; + struct GC_ms_entry *mark_stack_limit = (struct GC_ms_entry *)msl; + + if (env == (void *)1) /* Object allocated with debug allocator. */ + addr = (GC_PTR)GC_USR_PTR_FROM_BASE(addr); jobject obj = (jobject) addr; _Jv_VTable *dt = *(_Jv_VTable **) addr; - // We check this in case a GC occurs before the vtbl is set. FIXME: - // should use allocation lock while initializing object. - if (! dt) + // The object might not yet have its vtable set, or it might + // really be an object on the freelist. In either case, the vtable slot + // will either be 0, or it will point to a cleared object. + // This assumes Java objects have size at least 3 words, + // including the header. But this should remain true, since this + // should only be used with debugging allocation or with large objects. + if (__builtin_expect (! dt || !(dt -> get_finalizer()), false)) return mark_stack_ptr; jclass klass = dt->clas; + GC_PTR p; - // Every object has a sync_info pointer. - word w = (word) obj->sync_info; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, obj, o1label); - // Mark the object's class. - w = (word) klass; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, obj, o2label); + p = (GC_PTR) dt; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj); - if (klass == &ClassClass) +# ifndef JV_HASH_SYNCHRONIZATION + // Every object has a sync_info pointer. + p = (GC_PTR) obj->sync_info; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj); +# endif + + if (__builtin_expect (klass == &java::lang::Class::class$, false)) { + // Currently we allocate some of the memory referenced from class objects + // as pointerfree memory, and then mark it more intelligently here. + // We ensure that the ClassClass mark descriptor forces invocation of + // this procedure. + // Correctness of this is subtle, but it looks OK to me for now. For the incremental + // collector, we need to make sure that the class object is written whenever + // any of the subobjects are altered and may need rescanning. This may be tricky + // during construction, and this may not be the right way to do this with + // incremental collection. + // If we overflow the mark stack, we will rescan the class object, so we should + // be OK. The same applies if we redo the mark phase because win32 unmapped part + // of our root set. - HB jclass c = (jclass) addr; - w = (word) c->next; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c2label); - w = (word) c->name; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c3label); - w = (word) c->superclass; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c4label); - for (int i = 0; i < c->constants.size; ++i) - { - w = (word) c->constants.data[i]; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c5label); - } + p = (GC_PTR) c->name; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + p = (GC_PTR) c->superclass; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + p = (GC_PTR) c->constants.tags; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + p = (GC_PTR) c->constants.data; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); // If the class is an array, then the methods field holds a // pointer to the element class. If the class is primitive, // then the methods field holds a pointer to the array class. - w = (word) c->methods; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c6label); - - if (! c->isArray() && ! c->isPrimitive()) - { - // Scan each method in the cases where `methods' really - // points to a methods structure. - for (int i = 0; i < c->method_count; ++i) - { - w = (word) c->methods[i].name; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, - cm1label); - w = (word) c->methods[i].signature; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, - cm2label); - // FIXME: `ncode' entry? - } - } - - // Mark all the fields. - w = (word) c->fields; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8label); - for (int i = 0; i < c->field_count; ++i) - { -#ifndef COMPACT_FIELDS - w = (word) c->fields[i].name; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8alabel); -#endif - w = (word) c->fields[i].type; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8blabel); - } - - w = (word) c->vtable; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c9label); - w = (word) c->interfaces; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cAlabel); - for (int i = 0; i < c->interface_count; ++i) - { - w = (word) c->interfaces[i]; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cClabel); - } - w = (word) c->loader; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cBlabel); + p = (GC_PTR) c->methods; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + p = (GC_PTR) c->fields; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + // The vtable might be allocated even for compiled code. + p = (GC_PTR) c->vtable; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + p = (GC_PTR) c->interfaces; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + p = (GC_PTR) c->loader; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + // The dispatch tables can be allocated at runtime. + p = (GC_PTR) c->ancestors; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + p = (GC_PTR) c->idt; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + p = (GC_PTR) c->arrayclass; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + p = (GC_PTR) c->protectionDomain; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + p = (GC_PTR) c->hack_signers; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + p = (GC_PTR) c->aux_info; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + p = (GC_PTR) c->reflection_data; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); + + // The class chain must be marked for runtime-allocated Classes + // loaded by the bootstrap ClassLoader. + p = (GC_PTR) c->next_or_version; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c); } else { @@ -166,7 +186,7 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/) // Note: occasionally `klass' can be null. For instance, this // can happen if a GC occurs between the point where an object // is allocated and where the vtbl slot is set. - while (klass && klass != &ObjectClass) + while (klass && klass != &java::lang::Object::class$) { jfieldID field = JvGetFirstInstanceField (klass); jint max = JvNumInstanceFields (klass); @@ -176,11 +196,10 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/) if (JvFieldIsRef (field)) { jobject val = JvGetObjectField (obj, field); - w = (word) val; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, - obj, elabel); + p = (GC_PTR) val; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj); } - field = field->getNextInstanceField (); + field = field->getNextField (); } klass = klass->getSuperclass(); } @@ -193,61 +212,199 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /*env*/) // array (of objects). We use `void *' arguments and return, and not // what the Boehm GC wants, to avoid pollution in our headers. void * -_Jv_MarkArray (void *addr, void *msp, void *msl, void * /*env*/) +_Jv_MarkArray (void *addr, void *msp, void *msl, void *env) { - mse *mark_stack_ptr = (mse *) msp; - mse *mark_stack_limit = (mse *) msl; + struct GC_ms_entry *mark_stack_ptr = (struct GC_ms_entry *)msp; + struct GC_ms_entry *mark_stack_limit = (struct GC_ms_entry *)msl; + + if (env == (void *)1) /* Object allocated with debug allocator. */ + addr = (void *)GC_USR_PTR_FROM_BASE(addr); jobjectArray array = (jobjectArray) addr; _Jv_VTable *dt = *(_Jv_VTable **) addr; - // We check this in case a GC occurs before the vtbl is set. FIXME: - // should use allocation lock while initializing object. - if (! dt) + // Assumes size >= 3 words. That's currently true since arrays have + // a vtable, sync pointer, and size. If the sync pointer goes away, + // we may need to round up the size. + if (__builtin_expect (! dt || !(dt -> get_finalizer()), false)) return mark_stack_ptr; - jclass klass = dt->clas; + GC_PTR p; - // Every object has a sync_info pointer. - word w = (word) array->sync_info; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, array, e1label); - // Mark the object's class. - w = (word) klass; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, obj, o2label); + p = (GC_PTR) dt; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array); + +# ifndef JV_HASH_SYNCHRONIZATION + // Every object has a sync_info pointer. + p = (GC_PTR) array->sync_info; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array); +# endif for (int i = 0; i < JvGetArrayLength (array); ++i) { jobject obj = elements (array)[i]; - w = (word) obj; - MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, array, e2label); + p = (GC_PTR) obj; + MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array); } return mark_stack_ptr; } -// Allocate space for a new Java object. FIXME: this might be the -// wrong interface; we might prefer to pass in the object type as -// well. It isn't important for this collector, but it might be for -// other collectors. +// Generate a GC marking descriptor for a class. +// +// We assume that the gcj mark proc has index 0. This is a dubious assumption, +// since another one could be registered first. But the compiler also +// knows this, so in that case everything else will break, too. +#define GCJ_DEFAULT_DESCR GC_MAKE_PROC(GC_GCJ_RESERVED_MARK_PROC_INDEX,0) + void * -_Jv_AllocObj (jsize size) +_Jv_BuildGCDescr(jclass self) { - return GC_GENERIC_MALLOC (size, obj_kind_x); + jlong desc = 0; + jint bits_per_word = CHAR_BIT * sizeof (void *); + + // Note: for now we only consider a bitmap mark descriptor. We + // could also handle the case where the first N fields of a type are + // references. However, this is not very likely to be used by many + // classes, and it is easier to compute things this way. + + // The vtable pointer. + desc |= 1ULL << (bits_per_word - 1); +#ifndef JV_HASH_SYNCHRONIZATION + // The sync_info field. + desc |= 1ULL << (bits_per_word - 2); +#endif + + for (jclass klass = self; klass != NULL; klass = klass->getSuperclass()) + { + jfieldID field = JvGetFirstInstanceField(klass); + int count = JvNumInstanceFields(klass); + + for (int i = 0; i < count; ++i) + { + if (field->isRef()) + { + unsigned int off = field->getOffset(); + // If we run into a weird situation, we bail. + if (off % sizeof (void *) != 0) + return (void *) (GCJ_DEFAULT_DESCR); + off /= sizeof (void *); + // If we find a field outside the range of our bitmap, + // fall back to procedure marker. The bottom 2 bits are + // reserved. + if (off >= (unsigned) bits_per_word - 2) + return (void *) (GCJ_DEFAULT_DESCR); + desc |= 1ULL << (bits_per_word - off - 1); + } + + field = field->getNextField(); + } + } + + // For bitmap mark type, bottom bits are 01. + desc |= 1; + // Bogus warning avoidance (on many platforms). + return (void *) (unsigned long) desc; } -// Allocate space for a new Java array. FIXME: again, this might be -// the wrong interface. +// Allocate some space that is known to be pointer-free. void * -_Jv_AllocArray (jsize size) +_Jv_AllocBytes (jsize size) { - return GC_GENERIC_MALLOC (size, array_kind_x); + void *r = GC_MALLOC_ATOMIC (size); + // We have to explicitly zero memory here, as the GC doesn't + // guarantee that PTRFREE allocations are zeroed. Note that we + // don't have to do this for other allocation types because we set + // the `ok_init' flag in the type descriptor. + memset (r, 0, size); + return r; } -// Allocate some space that is known to be pointer-free. +#ifdef LIBGCJ_GC_DEBUG + void * -_Jv_AllocBytes (jsize size) +_Jv_AllocObj (jsize size, jclass klass) { - return GC_GENERIC_MALLOC (size, PTRFREE); + return GC_GCJ_MALLOC (size, klass->vtable); } +void * +_Jv_AllocPtrFreeObj (jsize size, jclass klass) +{ +#ifdef JV_HASH_SYNCHRONIZATION + void * obj = GC_MALLOC_ATOMIC(size); + *((_Jv_VTable **) obj) = klass->vtable; +#else + void * obj = GC_GCJ_MALLOC(size, klass->vtable); +#endif + return obj; +} + +#endif /* LIBGCJ_GC_DEBUG */ +// In the non-debug case, the above two functions are defined +// as inline functions in boehm-gc.h. In the debug case we +// really want to take advantage of the definitions in gc_gcj.h. + +// Allocate space for a new Java array. +// Used only for arrays of objects. +void * +_Jv_AllocArray (jsize size, jclass klass) +{ + void *obj; + +#ifdef LIBGCJ_GC_DEBUG + // There isn't much to lose by scanning this conservatively. + // If we didn't, the mark proc would have to understand that + // it needed to skip the header. + obj = GC_MALLOC(size); +#else + const jsize min_heap_addr = 16*1024; + // A heuristic. If size is less than this value, the size + // stored in the array can't possibly be misinterpreted as + // a pointer. Thus we lose nothing by scanning the object + // completely conservatively, since no misidentification can + // take place. + + if (size < min_heap_addr) + obj = GC_MALLOC(size); + else + obj = GC_generic_malloc (size, array_kind_x); +#endif + *((_Jv_VTable **) obj) = klass->vtable; + return obj; +} + +/* Allocate space for a new non-Java object, which does not have the usual + Java object header but may contain pointers to other GC'ed objects. */ +void * +_Jv_AllocRawObj (jsize size) +{ + return (void *) GC_MALLOC (size ? size : 1); +} + +#ifdef INTERPRETER +typedef _Jv_ClosureList *closure_list_pointer; + +/* Release closures in a _Jv_ClosureList. */ +static void +finalize_closure_list (GC_PTR obj, GC_PTR) +{ + _Jv_ClosureList **clpp = (_Jv_ClosureList **)obj; + _Jv_ClosureList::releaseClosures (clpp); +} + +/* Allocate a double-indirect pointer to a _Jv_ClosureList that will + get garbage-collected after this double-indirect pointer becomes + unreachable by any other objects, including finalizable ones. */ +_Jv_ClosureList ** +_Jv_ClosureListFinalizer () +{ + _Jv_ClosureList **clpp; + clpp = (_Jv_ClosureList **)_Jv_AllocBytes (sizeof (*clpp)); + GC_REGISTER_FINALIZER_UNREACHABLE (clpp, finalize_closure_list, + NULL, NULL, NULL); + return clpp; +} +#endif // INTERPRETER + static void call_finalizer (GC_PTR obj, GC_PTR client_data) { @@ -260,7 +417,7 @@ call_finalizer (GC_PTR obj, GC_PTR client_data) void _Jv_RegisterFinalizer (void *object, _Jv_FinalizerFunc *meth) { - GC_REGISTER_FINALIZER_NO_ORDER (object, call_finalizer, meth, + GC_REGISTER_FINALIZER_NO_ORDER (object, call_finalizer, (GC_PTR) meth, NULL, NULL); } @@ -288,80 +445,317 @@ _Jv_GCTotalMemory (void) return GC_get_heap_size (); } -/* Sum size of each hblk. */ -static void -sum_blocks (struct hblk *h, word arg) +long +_Jv_GCFreeMemory (void) { - long *sump = (long *) arg; - /* This evil computation is from boehm-gc/checksums.c. */ - hdr *hhdr = HDR (h); - int bytes = WORDS_TO_BYTES (hhdr->hb_sz); - bytes += HDR_BYTES + HBLKSIZE - 1; - bytes &= ~ (HBLKSIZE - 1); - *sump += bytes; + return GC_get_free_bytes (); } -/* This turns out to be expensive to implement. For now, we don't - care. We could make it less expensive, perhaps, but that would - require some changes to the collector. */ -long -_Jv_GCFreeMemory (void) +void +_Jv_GCSetInitialHeapSize (size_t size) +{ + size_t current = GC_get_heap_size (); + if (size > current) + GC_expand_hp (size - current); +} + +void +_Jv_GCSetMaximumHeapSize (size_t size) +{ + GC_set_max_heap_size ((GC_word) size); +} + +int +_Jv_SetGCFreeSpaceDivisor (int div) +{ + return (int)GC_set_free_space_divisor ((GC_word)div); +} + +void +_Jv_DisableGC (void) { - long sum = 0; - GC_apply_to_all_blocks (sum_blocks, &sum); - return sum; + GC_disable(); +} + +void +_Jv_EnableGC (void) +{ + GC_enable(); +} + +static void * handle_out_of_memory(size_t) +{ + _Jv_ThrowNoMemory(); +} + +static void +gcj_describe_type_fn(void *obj, char *out_buf) +{ + _Jv_VTable *dt = *(_Jv_VTable **) obj; + + if (! dt /* Shouldn't happen */) + { + strcpy(out_buf, "GCJ (bad)"); + return; + } + jclass klass = dt->clas; + if (!klass /* shouldn't happen */) + { + strcpy(out_buf, "GCJ (bad)"); + return; + } + jstring name = klass -> getName(); + size_t len = name -> length(); + if (len >= GC_TYPE_DESCR_LEN) len = GC_TYPE_DESCR_LEN - 1; + JvGetStringUTFRegion (name, 0, len, out_buf); + out_buf[len] = '\0'; } void _Jv_InitGC (void) { int proc; - DCL_LOCK_STATE; + static bool gc_initialized; + + if (gc_initialized) + return; + + gc_initialized = 1; + + // Ignore pointers that do not point to the start of an object. + GC_all_interior_pointers = 0; + +#if defined (HAVE_DLFCN_H) && defined (HAVE_DLADDR) + // Tell the collector to ask us before scanning DSOs. + GC_register_has_static_roots_callback (_Jv_GC_has_static_roots); +#endif + + // Configure the collector to use the bitmap marking descriptors that we + // stash in the class vtable. + // We always use mark proc descriptor 0, since the compiler knows + // about it. + GC_init_gcj_malloc (0, (void *) _Jv_MarkObj); + + // Cause an out of memory error to be thrown from the allocators, + // instead of returning 0. This is cheaper than checking on allocation. + GC_oom_fn = handle_out_of_memory; + + GC_java_finalization = 1; + + // We use a different mark procedure for object arrays. This code + // configures a different object `kind' for object array allocation and + // marking. + array_free_list = GC_new_free_list(); + proc = GC_new_proc((GC_mark_proc)_Jv_MarkArray); + array_kind_x = GC_new_kind(array_free_list, GC_MAKE_PROC (proc, 0), 0, 1); + + // Arrange to have the GC print Java class names in backtraces, etc. + GC_register_describe_type_fn(GC_gcj_kind, gcj_describe_type_fn); + GC_register_describe_type_fn(GC_gcj_debug_kind, gcj_describe_type_fn); +} + +#ifdef JV_HASH_SYNCHRONIZATION +// Allocate an object with a fake vtable pointer, which causes only +// the first field (beyond the fake vtable pointer) to be traced. +// Eventually this should probably be generalized. + +static _Jv_VTable trace_one_vtable = { + 0, // class pointer + (void *)(2 * sizeof(void *)), + // descriptor; scan 2 words incl. vtable ptr. + // Least significant bits must be zero to + // identify this as a length descriptor + {0} // First method +}; + +void * +_Jv_AllocTraceOne (jsize size /* includes vtable slot */) +{ + return GC_GCJ_MALLOC (size, &trace_one_vtable); +} + +// Ditto for two words. +// the first field (beyond the fake vtable pointer) to be traced. +// Eventually this should probably be generalized. + +static _Jv_VTable trace_two_vtable = +{ + 0, // class pointer + (void *)(3 * sizeof(void *)), + // descriptor; scan 3 words incl. vtable ptr. + {0} // First method +}; + +void * +_Jv_AllocTraceTwo (jsize size /* includes vtable slot */) +{ + return GC_GCJ_MALLOC (size, &trace_two_vtable); +} + +#endif /* JV_HASH_SYNCHRONIZATION */ + +void +_Jv_GCInitializeFinalizers (void (*notifier) (void)) +{ + GC_finalize_on_demand = 1; + GC_finalizer_notifier = notifier; +} + +void +_Jv_GCRegisterDisappearingLink (jobject *objp) +{ + // This test helps to ensure that we meet a precondition of + // GC_general_register_disappearing_link, viz. "Obj must be a + // pointer to the first word of an object we allocated." + if (GC_base(*objp)) + GC_general_register_disappearing_link ((GC_PTR *) objp, (GC_PTR) *objp); +} + +jboolean +_Jv_GCCanReclaimSoftReference (jobject) +{ + // For now, always reclaim soft references. FIXME. + return true; +} + + + +#if defined (HAVE_DLFCN_H) && defined (HAVE_DLADDR) + +// We keep a store of the filenames of DSOs that need to be +// conservatively scanned by the garbage collector. During collection +// the gc calls _Jv_GC_has_static_roots() to see if the data segment +// of a DSO should be scanned. +typedef struct filename_node +{ + char *name; + struct filename_node *link; +} filename_node; + +#define FILENAME_STORE_SIZE 17 +static filename_node *filename_store[FILENAME_STORE_SIZE]; - DISABLE_SIGNALS (); - LOCK (); +// Find a filename in filename_store. +static filename_node ** +find_file (const char *filename) +{ + int index = strlen (filename) % FILENAME_STORE_SIZE; + filename_node **node = &filename_store[index]; + + while (*node) + { + if (strcmp ((*node)->name, filename) == 0) + return node; + node = &(*node)->link; + } + + return node; +} - if (initialized) +// Print the store of filenames of DSOs that need collection. +void +_Jv_print_gc_store (void) +{ + for (int i = 0; i < FILENAME_STORE_SIZE; i++) { - UNLOCK (); - ENABLE_SIGNALS (); - return; + filename_node *node = filename_store[i]; + while (node) + { + fprintf (stderr, "%s\n", node->name); + node = node->link; + } + } +} + +// Create a new node in the store of libraries to collect. +static filename_node * +new_node (const char *filename) +{ + filename_node *node = (filename_node*)_Jv_Malloc (sizeof (filename_node)); + node->name = (char *)_Jv_Malloc (strlen (filename) + 1); + node->link = NULL; + strcpy (node->name, filename); + + return node; +} + +// Nonzero if the gc should scan this lib. +static int +_Jv_GC_has_static_roots (const char *filename, void *, size_t) +{ + if (filename == NULL || strlen (filename) == 0) + // No filename; better safe than sorry. + return 1; + + filename_node **node = find_file (filename); + if (*node) + return 1; + + return 0; +} + +#endif + +// Register the DSO that contains p for collection. +void +_Jv_RegisterLibForGc (const void *p __attribute__ ((__unused__))) +{ +#if defined (HAVE_DLFCN_H) && defined (HAVE_DLADDR) + Dl_info info; + + if (dladdr (const_cast(p), &info) != 0) + { + filename_node **node = find_file (info.dli_fname); + if (! *node) + *node = new_node (info.dli_fname); } - initialized = 1; - - // Set up state for marking and allocation of Java objects. - obj_free_list = (ptr_t *) GC_generic_malloc_inner ((MAXOBJSZ + 1) - * sizeof (ptr_t), - PTRFREE); - memset (obj_free_list, 0, (MAXOBJSZ + 1) * sizeof (ptr_t)); - - proc = GC_n_mark_procs++; - GC_mark_procs[proc] = (mark_proc) _Jv_MarkObj; - - obj_kind_x = GC_n_kinds++; - GC_obj_kinds[obj_kind_x].ok_freelist = obj_free_list; - GC_obj_kinds[obj_kind_x].ok_reclaim_list = 0; - GC_obj_kinds[obj_kind_x].ok_descriptor = MAKE_PROC (proc, 0); - GC_obj_kinds[obj_kind_x].ok_relocate_descr = FALSE; - GC_obj_kinds[obj_kind_x].ok_init = TRUE; - - // Set up state for marking and allocation of arrays of Java - // objects. - array_free_list = (ptr_t *) GC_generic_malloc_inner ((MAXOBJSZ + 1) - * sizeof (ptr_t), - PTRFREE); - memset (array_free_list, 0, (MAXOBJSZ + 1) * sizeof (ptr_t)); - - proc = GC_n_mark_procs++; - GC_mark_procs[proc] = (mark_proc) _Jv_MarkArray; - - array_kind_x = GC_n_kinds++; - GC_obj_kinds[array_kind_x].ok_freelist = array_free_list; - GC_obj_kinds[array_kind_x].ok_reclaim_list = 0; - GC_obj_kinds[array_kind_x].ok_descriptor = MAKE_PROC (proc, 0); - GC_obj_kinds[array_kind_x].ok_relocate_descr = FALSE; - GC_obj_kinds[array_kind_x].ok_init = TRUE; - - UNLOCK (); - ENABLE_SIGNALS (); +#endif +} + +void +_Jv_SuspendThread (_Jv_Thread_t *thread) +{ +#if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \ + && !defined(GC_WIN32_THREADS) && !defined(GC_DARWIN_THREADS) + GC_suspend_thread (_Jv_GetPlatformThreadID (thread)); +#endif +} + +void +_Jv_ResumeThread (_Jv_Thread_t *thread) +{ +#if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \ + && !defined(GC_WIN32_THREADS) && !defined(GC_DARWIN_THREADS) + GC_resume_thread (_Jv_GetPlatformThreadID (thread)); +#endif +} + +int +_Jv_IsThreadSuspended (_Jv_Thread_t *thread) +{ +#if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \ + && !defined(GC_WIN32_THREADS) && !defined(GC_DARWIN_THREADS) + return GC_is_thread_suspended (_Jv_GetPlatformThreadID (thread)); +#else + return 0; +#endif +} + +void +_Jv_GCAttachThread () +{ + // The registration interface is only defined on posixy systems and + // only actually works if pthread_getattr_np is defined. + // FIXME: until gc7 it is simpler to disable this on solaris. +#if defined(HAVE_PTHREAD_GETATTR_NP) && !defined(GC_SOLARIS_THREADS) + GC_register_my_thread (); +#endif +} + +void +_Jv_GCDetachThread () +{ +#if defined(HAVE_PTHREAD_GETATTR_NP) && !defined(GC_SOLARIS_THREADS) + GC_unregister_my_thread (); +#endif }