// boehm.cc - interface between libjava and Boehm GC.
-/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
This file is part of libgcj.
#include <gcj/cni.h>
#include <java/lang/Class.h>
+#include <java/lang/reflect/Modifier.h>
#include <java-interp.h>
// More nastiness: the GC wants to define TRUE and FALSE. We don't
extern "C"
{
-#include <gc_priv.h>
-#include <gc_mark.h>
+#include <private/gc_priv.h>
+#include <private/gc_pmark.h>
+#include <gc_gcj.h>
// These aren't declared in any Boehm GC header.
void GC_finalize_all (void);
&& (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;
-
\f
// Nonzero if this module has been initialized.
static int initialized = 0;
+#if 0
// `kind' index used when allocating Java objects.
static int obj_kind_x;
-// `kind' index used when allocating Java arrays.
-static int array_kind_x;
-
// Freelist used for Java objects.
static ptr_t *obj_free_list;
+#endif /* 0 */
+
+// `kind' index used when allocating Java arrays.
+static int array_kind_x;
// Freelist used for Java arrays.
static ptr_t *array_free_list;
+// Lock used to protect access to Boehm's GC_enable/GC_disable functions.
+static _Jv_Mutex_t disable_gc_mutex;
+
\f
// This is called by the GC during the mark phase. It marks a Java
// 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;
+ // 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.
+
_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;
+ ptr_t 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);
+# ifndef JV_HASH_SYNCHRONIZATION
+ // Every object has a sync_info pointer.
+ p = (ptr_t) obj->sync_info;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj, o1label);
+# endif
// Mark the object's class.
- w = (word) klass;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, obj, o2label);
+ p = (ptr_t) klass;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj, o2label);
- if (klass == &ClassClass)
+ 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;
-#if 0
- // The next field should probably not be marked, since this is
- // only used in the class hash table. Marking this field
- // basically prohibits class unloading. --Kresten
- w = (word) c->next;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c2label);
-#endif
-
- 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);
+ 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 */
- w = (word) c->constants.data[i].p;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c5label);
+ p = (ptr_t) c->constants.data[i].p;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c5label);
}
#ifdef INTERPRETER
if (_Jv_IsInterpretedClass (c))
{
- w = (word) c->constants.tags;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c5alabel);
- w = (word) c->constants.data;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c5blabel);
+ 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
// 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);
+ p = (ptr_t) c->methods;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c6label);
if (! c->isArray() && ! c->isPrimitive())
// 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,
+ p = (ptr_t) c->methods[i].name;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
cm1label);
- w = (word) c->methods[i].signature;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c,
+ p = (ptr_t) c->methods[i].signature;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
cm2label);
// FIXME: `ncode' entry?
// trampoline here, so we'll mark it.
if (_Jv_IsInterpretedClass (c))
{
- w = (word) c->methods[i].ncode;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c,
+ p = (ptr_t) c->methods[i].ncode;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
cm3label);
}
#endif
}
// Mark all the fields.
- w = (word) c->fields;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8label);
+ 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
- w = (word) field->name;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8alabel);
+ p = (ptr_t) field->name;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8alabel);
#endif
- w = (word) field->type;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8blabel);
+ 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 & 0x0008)
+ if ((field->flags & java::lang::reflect::Modifier::STATIC))
{
- w = (word) field->u.addr;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, c8clabel);
+ 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
if (JvFieldIsRef (field) && field->isResolved())
{
jobject val = *(jobject*) field->u.addr;
- w = (word) val;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit,
+ p = (ptr_t) val;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit,
c, c8elabel);
}
}
}
- 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);
+ 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)
{
- w = (word) c->interfaces[i];
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cClabel);
+ p = (ptr_t) c->interfaces[i];
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cClabel);
}
- w = (word) c->loader;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, c, cBlabel);
+ p = (ptr_t) c->loader;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cBlabel);
+ p = (ptr_t) c->arrayclass;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cDlabel);
#ifdef INTERPRETER
if (_Jv_IsInterpretedClass (c))
{
_Jv_InterpClass* ic = (_Jv_InterpClass*)c;
- w = (word) ic->interpreted_methods;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, ic, cElabel);
+ 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++)
{
- w = (word) ic->interpreted_methods[i];
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, ic, \
+ p = (ptr_t) ic->interpreted_methods[i];
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, \
cFlabel);
}
- w = (word) ic->field_initializers;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, ic, cGlabel);
+ p = (ptr_t) ic->field_initializers;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, cGlabel);
}
#endif
// 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);
- w = (word) val;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit,
+ p = (ptr_t) val;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit,
obj, elabel);
}
field = field->getNextField ();
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;
+ ptr_t 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);
+# ifndef JV_HASH_SYNCHRONIZATION
+ // Every object has a sync_info pointer.
+ p = (ptr_t) array->sync_info;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array, e1label);
+# endif
// Mark the object's class.
- w = (word) klass;
- MAYBE_MARK (w, mark_stack_ptr, mark_stack_limit, obj, o2label);
+ p = (ptr_t) klass;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj, o2label);
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 = (ptr_t) obj;
+ MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array, e2label);
}
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.
-void *
-_Jv_AllocObj (jsize size)
-{
- return GC_GENERIC_MALLOC (size, obj_kind_x);
-}
+// Return GC descriptor for interpreted class
+#ifdef INTERPRETER
-// Allocate space for a new Java array. FIXME: again, this might be
-// the wrong interface.
+// 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_AllocArray (jsize size)
+_Jv_BuildGCDescr(jclass)
{
- return GC_GENERIC_MALLOC (size, array_kind_x);
+ /* FIXME: We should really look at the class and build the descriptor. */
+ return (void *)(GCJ_DEFAULT_DESCR);
}
+#endif
// Allocate some space that is known to be pointer-free.
void *
_Jv_AllocBytes (jsize size)
{
- void *r = GC_GENERIC_MALLOC (size, PTRFREE);
+ 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 (r != NULL)
- memset (r, 0, size);
+ memset (r, 0, size);
return r;
}
+// Allocate space for a new Java array.
+// Used only for arrays of objects.
+void *
+_Jv_AllocArray (jsize size, jclass klass)
+{
+ void *obj;
+ 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.
+
+#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);
+#endif
+ *((_Jv_VTable **) obj) = klass->vtable;
+ return obj;
+}
+
static void
call_finalizer (GC_PTR obj, GC_PTR client_data)
{
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);
+}
+
+static void * handle_out_of_memory(size_t)
+{
+ _Jv_ThrowNoMemory();
+}
+
void
_Jv_InitGC (void)
{
return;
}
initialized = 1;
+ UNLOCK ();
+
+ // Configure the collector to use the bitmap marking descriptors that we
+ // stash in the class vtable.
+ 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;
+
+ LOCK ();
+ 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] = (GC_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 = GC_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 ();
+}
+
+#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 lenght descriptor
+ {0} // First method
+};
+
+void *
+_Jv_AllocTraceOne (jsize size /* includes vtable slot */)
+{
+ return GC_GCJ_MALLOC (size, &trace_one_vtable);
+}
+
+#endif /* JV_HASH_SYNCHRONIZATION */
+
+#if 0
+void
+_Jv_InitGC (void)
+{
+ int proc;
+ DCL_LOCK_STATE;
+
+ DISABLE_SIGNALS ();
+ LOCK ();
+
+ if (initialized)
+ {
+ UNLOCK ();
+ ENABLE_SIGNALS ();
+ return;
+ }
+ initialized = 1;
GC_java_finalization = 1;
memset (obj_free_list, 0, (MAXOBJSZ + 1) * sizeof (ptr_t));
proc = GC_n_mark_procs++;
- GC_mark_procs[proc] = (mark_proc) _Jv_MarkObj;
+ GC_mark_procs[proc] = (GC_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_descriptor = GC_MAKE_PROC (proc, 0);
GC_obj_kinds[obj_kind_x].ok_relocate_descr = FALSE;
GC_obj_kinds[obj_kind_x].ok_init = TRUE;
memset (array_free_list, 0, (MAXOBJSZ + 1) * sizeof (ptr_t));
proc = GC_n_mark_procs++;
- GC_mark_procs[proc] = (mark_proc) _Jv_MarkArray;
+ GC_mark_procs[proc] = (GC_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_descriptor = GC_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 ();
}
+#endif /* 0 */