// boehm.cc - interface between libjava and Boehm GC.
-/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+ Free Software Foundation
This file is part of libgcj.
#include <config.h>
#include <stdio.h>
+#include <limits.h>
#include <jvm.h>
#include <gcj/cni.h>
#undef TRUE
#undef FALSE
-extern "C"
-{
-#include <gc_priv.h>
-#include <gc_mark.h>
-#include <include/gc_gcj.h>
+// We include two autoconf headers. Avoid multiple definition warnings.
+#undef PACKAGE_NAME
+#undef PACKAGE_STRING
+#undef PACKAGE_TARNAME
+#undef PACKAGE_VERSION
- // 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);
-};
-
-// 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)
+#ifdef HAVE_DLFCN_H
+#undef _GNU_SOURCE
+#define _GNU_SOURCE
+#include <dlfcn.h>
#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)
+extern "C"
+{
+#include <gc_config.h>
-#define ObjectClass _CL_Q34java4lang6Object
-extern java::lang::Class ObjectClass;
-#define ClassClass _CL_Q34java4lang5Class
-extern java::lang::Class ClassClass;
+// Set GC_DEBUG before including gc.h!
+#ifdef LIBGCJ_GC_DEBUG
+# define GC_DEBUG
+#endif
-\f
+#include <gc_mark.h>
+#include <gc_gcj.h>
+#include <javaxfc.h> // GC_finalize_all declaration.
-// Nonzero if this module has been initialized.
-static int initialized = 0;
+#ifdef THREAD_LOCAL_ALLOC
+# define GC_REDIRECT_TO_LOCAL
+# include <gc_local_alloc.h>
+#endif
-#if 0
-// `kind' index used when allocating Java objects.
-static int obj_kind_x;
+ // From boehm's misc.c
+ void GC_enable();
+ void GC_disable();
+};
-// Freelist used for Java objects.
-static ptr_t *obj_free_list;
-#endif /* 0 */
+#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 arrays.
-static ptr_t *array_free_list;
+static void **array_free_list;
-// Lock used to protect access to Boehm's GC_enable/GC_disable functions.
-static _Jv_Mutex_t disable_gc_mutex;
+static int _Jv_GC_has_static_roots (const char *filename, void *, size_t);
\f
// 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;
- jobject obj = (jobject) addr;
+ struct GC_ms_entry *mark_stack_ptr = (struct GC_ms_entry *)msp;
+ struct GC_ms_entry *mark_stack_limit = (struct GC_ms_entry *)msl;
- // FIXME: if env is 1, this object was allocated through the debug
- // interface, and addr points to the beginning of the debug header.
- // In that case, we should really add the size of the header to addr.
+ 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;
// The object might not yet have its vtable set, or it might
if (__builtin_expect (! dt || !(dt -> get_finalizer()), false))
return mark_stack_ptr;
jclass klass = dt->clas;
+ GC_PTR p;
+
+ p = (GC_PTR) dt;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj);
- // Every object has a sync_info pointer.
- ptr_t p = (ptr_t) obj->sync_info;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj, o1label);
- // Mark the object's class.
- p = (ptr_t) klass;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj, o2label);
+# 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 == &ClassClass, false))
+ 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.
// of our root set. - HB
jclass c = (jclass) addr;
- p = (ptr_t) c->name;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c3label);
- p = (ptr_t) c->superclass;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c4label);
- for (int i = 0; i < c->constants.size; ++i)
- {
- /* FIXME: We could make this more precise by using the tags -KKT */
- p = (ptr_t) c->constants.data[i].p;
- MAYBE_MARK (p, 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);
-#ifdef INTERPRETER
- if (_Jv_IsInterpretedClass (c))
- {
- p = (ptr_t) c->constants.tags;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c5alabel);
- p = (ptr_t) c->constants.data;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c5blabel);
- p = (ptr_t) c->vtable;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c5clabel);
- }
-#endif
+ 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.
- p = (ptr_t) c->methods;
- MAYBE_MARK (p, 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)
- {
- p = (ptr_t) c->methods[i].name;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
- cm1label);
- p = (ptr_t) c->methods[i].signature;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
- cm2label);
-
- // FIXME: `ncode' entry?
-
-#ifdef INTERPRETER
- // The interpreter installs a heap-allocated
- // trampoline here, so we'll mark it.
- if (_Jv_IsInterpretedClass (c))
- {
- p = (ptr_t) c->methods[i].ncode;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
- cm3label);
- }
-#endif
- }
- }
-
- // Mark all the fields.
- p = (ptr_t) c->fields;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8label);
- for (int i = 0; i < c->field_count; ++i)
- {
- _Jv_Field* field = &c->fields[i];
-
-#ifndef COMPACT_FIELDS
- p = (ptr_t) field->name;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8alabel);
-#endif
- p = (ptr_t) field->type;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8blabel);
-
- // For the interpreter, we also need to mark the memory
- // containing static members
- if ((field->flags & java::lang::reflect::Modifier::STATIC))
- {
- p = (ptr_t) field->u.addr;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8clabel);
-
- // also, if the static member is a reference,
- // mark also the value pointed to. We check for isResolved
- // since marking can happen before memory is allocated for
- // static members.
- if (JvFieldIsRef (field) && field->isResolved())
- {
- jobject val = *(jobject*) field->u.addr;
- p = (ptr_t) val;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit,
- c, c8elabel);
- }
- }
- }
-
- p = (ptr_t) c->vtable;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c9label);
- p = (ptr_t) c->interfaces;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cAlabel);
- for (int i = 0; i < c->interface_count; ++i)
- {
- p = (ptr_t) c->interfaces[i];
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cClabel);
- }
- p = (ptr_t) c->loader;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cBlabel);
-
-#ifdef INTERPRETER
- if (_Jv_IsInterpretedClass (c))
- {
- _Jv_InterpClass* ic = (_Jv_InterpClass*)c;
-
- p = (ptr_t) ic->interpreted_methods;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, cElabel);
-
- for (int i = 0; i < c->method_count; i++)
- {
- p = (ptr_t) ic->interpreted_methods[i];
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, \
- cFlabel);
- }
-
- p = (ptr_t) ic->field_initializers;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, cGlabel);
-
- }
-#endif
-
+ 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);
}
else
{
// 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);
if (JvFieldIsRef (field))
{
jobject val = JvGetObjectField (obj, field);
- p = (ptr_t) val;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit,
- obj, elabel);
+ p = (GC_PTR) val;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj);
}
field = field->getNextField ();
}
// 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 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;
+
+ p = (GC_PTR) dt;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array);
- // Every object has a sync_info pointer.
- ptr_t p = (ptr_t) array->sync_info;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array, e1label);
- // Mark the object's class.
- p = (ptr_t) klass;
- MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj, o2label);
+# 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];
- p = (ptr_t) obj;
- MAYBE_MARK (p, 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;
}
-// Return GC descriptor for interpreted class
-#ifdef INTERPRETER
-
+// 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 MAKE_PROC(GCJ_RESERVED_MARK_PROC_INDEX,0)
+#define GCJ_DEFAULT_DESCR GC_MAKE_PROC(GC_GCJ_RESERVED_MARK_PROC_INDEX,0)
+
void *
-_Jv_BuildGCDescr(jclass klass)
+_Jv_BuildGCDescr(jclass self)
{
- /* FIXME: We should really look at the class and build the descriptor. */
- return (void *)(GCJ_DEFAULT_DESCR);
-}
+ 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
-// Allocate space for a new Java object.
+ 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 some space that is known to be pointer-free.
+void *
+_Jv_AllocBytes (jsize size)
+{
+ 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;
+}
+
+#ifdef LIBGCJ_GC_DEBUG
+
void *
_Jv_AllocObj (jsize size, jclass klass)
{
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
// completely conservatively, since no misidentification can
// take place.
-#ifdef 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
if (size < min_heap_addr)
obj = GC_MALLOC(size);
else
- obj = GC_GENERIC_MALLOC (size, array_kind_x);
+ obj = GC_generic_malloc (size, array_kind_x);
#endif
*((_Jv_VTable **) obj) = klass->vtable;
return obj;
}
-// Allocate some space that is known to be pointer-free.
+/* 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_AllocBytes (jsize size)
+_Jv_AllocRawObj (jsize size)
{
- 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.
- if (__builtin_expect (r != NULL, !NULL))
- memset (r, 0, size);
- return r;
+ return (void *) GC_MALLOC (size ? size : 1);
}
static void
GC_set_max_heap_size ((GC_word) size);
}
-// From boehm's misc.c
-extern "C" void GC_enable();
-extern "C" void GC_disable();
-
void
_Jv_DisableGC (void)
{
- _Jv_MutexLock (&disable_gc_mutex);
GC_disable();
- _Jv_MutexUnlock (&disable_gc_mutex);
}
void
_Jv_EnableGC (void)
{
- _Jv_MutexLock (&disable_gc_mutex);
GC_enable();
- _Jv_MutexUnlock (&disable_gc_mutex);
}
-void
-_Jv_InitGC (void)
+static void * handle_out_of_memory(size_t)
{
- int proc;
- DCL_LOCK_STATE;
+ _Jv_ThrowNoMemory();
+}
- DISABLE_SIGNALS ();
- LOCK ();
+static void
+gcj_describe_type_fn(void *obj, char *out_buf)
+{
+ _Jv_VTable *dt = *(_Jv_VTable **) obj;
- if (initialized)
+ if (! dt /* Shouldn't happen */)
+ {
+ strcpy(out_buf, "GCJ (bad)");
+ return;
+ }
+ jclass klass = dt->clas;
+ if (!klass /* shouldn't happen */)
{
- UNLOCK ();
- ENABLE_SIGNALS ();
+ strcpy(out_buf, "GCJ (bad)");
return;
}
- initialized = 1;
- UNLOCK ();
+ 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;
+ 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;
+
+#ifdef HAVE_DLFCN_H
+ // 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);
- LOCK ();
+ // 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. FIXME: see above.
- 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;
-
- _Jv_MutexInit (&disable_gc_mutex);
-
- UNLOCK ();
- ENABLE_SIGNALS ();
+ // 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);
}
-#if 0
+#endif /* JV_HASH_SYNCHRONIZATION */
+
void
-_Jv_InitGC (void)
+_Jv_GCInitializeFinalizers (void (*notifier) (void))
{
- int proc;
- DCL_LOCK_STATE;
+ GC_finalize_on_demand = 1;
+ GC_finalizer_notifier = notifier;
+}
- DISABLE_SIGNALS ();
- LOCK ();
+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);
+}
- if (initialized)
- {
- UNLOCK ();
- ENABLE_SIGNALS ();
- return;
- }
- initialized = 1;
+jboolean
+_Jv_GCCanReclaimSoftReference (jobject)
+{
+ // For now, always reclaim soft references. FIXME.
+ return true;
+}
- GC_java_finalization = 1;
+\f
+
+#ifdef HAVE_DLFCN_H
+
+// 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];
+
+// 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;
+}
+
+// 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++)
+ {
+ 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;
- // 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;
-
- _Jv_MutexInit (&disable_gc_mutex);
-
- UNLOCK ();
- ENABLE_SIGNALS ();
+ 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__)))
+{
+#ifdef HAVE_DLFCN_H
+ Dl_info info;
+
+ if (dladdr (const_cast<void *>(p), &info) != 0)
+ {
+ filename_node **node = find_file (info.dli_fname);
+ if (! *node)
+ *node = new_node (info.dli_fname);
+ }
+#endif
}
-#endif /* 0 */
+
OSDN Git Service
