mirrors/gcc
1
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2024-11-26 04:14:06 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

configure.ac: Handle --enable-gc-debug.

Browse Source 
* configure.ac: Handle --enable-gc-debug.
	* configure: Regenerate.
	* include/config.h.in (LIBGCJ_GC_DEBUG): Add.
	* boehm.cc: Include gc_mark.h, javaxfc.h, but no GC private files.
	Rearrange include file order.
	(GC_DEBUG): Set if LIBGCJ_GC_DEBUG is set.
	(GC_finalize_all, GC_debug_generic_malloc): Don't declare.
	(disable_gc_mutex): Delete along with all references.
	(_Jv_MarkObj, _Jv_MarkArray): Use public types,
	adjust for debug header size.
	(_Jv_AllocObj, _Jv_allocPtrFreeObj): Define out of line for
	debug case.
	(_Jv_AllocArray): Declare min_heap_addr only if needed.
	(gcj_describe_type_fn): New.
	(_Jv_InitGC): Use GC_new_free_list, GC_new_proc, and GC_new_kind.
	Register gcj_describe_type_fn.
	* include/boehm-gc.h:
	(_Jv_AllocObj, _Jv_allocPtrFreeObj):
	Don't define, but declare, for debug case.
	* java/lang/natObject.cc:
	(GC_DEBUG): Define if LIBGCJ_GC_DEBUG is set.

From-SVN: r86686
This commit is contained in:
Hans Boehm 2004-08-28 00:45:56 +00:00 committed by Hans Boehm
parent 3c1cbf58a6
commit ed3479983d
7 changed files with 196 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
libjava/ChangeLog
View File

@ -1,3 +1,27 @@
2004-08-27 Hans Boehm <Hans.Boehm@hp.com>
* configure.ac: Handle --enable-gc-debug.
* configure: Regenerate.
* include/config.h.in (LIBGCJ_GC_DEBUG): Add.
* boehm.cc: Include gc_mark.h, javaxfc.h, but no GC private files.
Rearrange include file order.
(GC_DEBUG): Set if LIBGCJ_GC_DEBUG is set.
(GC_finalize_all, GC_debug_generic_malloc): Don't declare.
(disable_gc_mutex): Delete along with all references.
(_Jv_MarkObj, _Jv_MarkArray): Use public types,
adjust for debug header size.
(_Jv_AllocObj, _Jv_allocPtrFreeObj): Define out of line for
debug case.
(_Jv_AllocArray): Declare min_heap_addr only if needed.
(gcj_describe_type_fn): New.
(_Jv_InitGC): Use GC_new_free_list, GC_new_proc, and GC_new_kind.
Register gcj_describe_type_fn.
* include/boehm-gc.h:
(_Jv_AllocObj, _Jv_allocPtrFreeObj):
Don't define, but declare, for debug case.
* java/lang/natObject.cc:
(GC_DEBUG): Define if LIBGCJ_GC_DEBUG is set.
2004-08-26 Mark Wielaard <mark@klomp.org>
Fixes PR libgcj/17002:

228
libjava/boehm.cc
View File

@ -10,6 +10,25 @@ details. */
#include <config.h>
extern "C"
{
#include <gc_config.h>
// Set GC_DEBUG before including gc.h!
#ifdef LIBGCJ_GC_DEBUG
# define GC_DEBUG
#endif
#include <gc_mark.h>
#include <gc_gcj.h>
#include <javaxfc.h> // GC_finalize_all declaration.
#ifdef THREAD_LOCAL_ALLOC
# define GC_REDIRECT_TO_LOCAL
# include <gc_local_alloc.h>
#endif
};
#include <stdio.h>
#include <limits.h>
@ -20,26 +39,6 @@ details. */
#include <java/lang/reflect/Modifier.h>
#include <java-interp.h>
// 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
extern "C"
{
#include <private/gc_pmark.h>
#include <gc_gcj.h>
#ifdef THREAD_LOCAL_ALLOC
# define GC_REDIRECT_TO_LOCAL
# include <gc_local_alloc.h>
#endif
// 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);
};
#define MAYBE_MARK(Obj, Top, Limit, Source, Exit) \
Top=GC_MARK_AND_PUSH((GC_PTR)Obj, Top, Limit, (GC_PTR *)Source)
@ -47,10 +46,7 @@ extern "C"
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;
static void * *array_free_list;
@ -58,15 +54,14 @@ static _Jv_Mutex_t disable_gc_mutex;
// 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
@ -78,15 +73,15 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
if (__builtin_expect (! dt || !(dt -> get_finalizer()), false))
return mark_stack_ptr;
jclass klass = dt->clas;
ptr_t p;
GC_PTR p;
# ifndef JV_HASH_SYNCHRONIZATION
// Every object has a sync_info pointer.
p = (ptr_t) obj->sync_info;
p = (GC_PTR) obj->sync_info;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj, o1label);
# endif
// Mark the object's class.
p = (ptr_t) klass;
p = (GC_PTR) klass;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj, o2label);
if (__builtin_expect (klass == &java::lang::Class::class$, false))
@ -105,25 +100,25 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
// of our root set. - HB
jclass c = (jclass) addr;
p = (ptr_t) c->name;
p = (GC_PTR) c->name;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c3label);
p = (ptr_t) c->superclass;
p = (GC_PTR) 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;
p = (GC_PTR) c->constants.data[i].p;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c5label);
}
#ifdef INTERPRETER
if (_Jv_IsInterpretedClass (c))
{
p = (ptr_t) c->constants.tags;
p = (GC_PTR) c->constants.tags;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c5alabel);
p = (ptr_t) c->constants.data;
p = (GC_PTR) c->constants.data;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c5blabel);
p = (ptr_t) c->vtable;
p = (GC_PTR) c->vtable;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c5clabel);
}
#endif
@ -131,7 +126,7 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
// 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;
p = (GC_PTR) c->methods;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c6label);
// The vtable might have been set, but the rest of the class
@ -147,34 +142,34 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
// points to a methods structure.
for (int i = 0; i < c->method_count; ++i)
{
p = (ptr_t) c->methods[i].name;
p = (GC_PTR) c->methods[i].name;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
cm1label);
p = (ptr_t) c->methods[i].signature;
p = (GC_PTR) c->methods[i].signature;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
cm2label);
}
}
// Mark all the fields.
p = (ptr_t) c->fields;
p = (GC_PTR) 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;
p = (GC_PTR) field->name;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8alabel);
#endif
p = (ptr_t) field->type;
p = (GC_PTR) 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;
p = (GC_PTR) field->u.addr;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c8clabel);
// also, if the static member is a reference,
@ -184,31 +179,31 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
if (JvFieldIsRef (field) && field->isResolved())
{
jobject val = *(jobject*) field->u.addr;
p = (ptr_t) val;
p = (GC_PTR) val;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit,
c, c8elabel);
}
}
}
p = (ptr_t) c->vtable;
p = (GC_PTR) c->vtable;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, c9label);
p = (ptr_t) c->interfaces;
p = (GC_PTR) 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];
p = (GC_PTR) c->interfaces[i];
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cClabel);
}
p = (ptr_t) c->loader;
p = (GC_PTR) c->loader;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cBlabel);
p = (ptr_t) c->arrayclass;
p = (GC_PTR) c->arrayclass;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cDlabel);
p = (ptr_t) c->protectionDomain;
p = (GC_PTR) c->protectionDomain;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cPlabel);
p = (ptr_t) c->hack_signers;
p = (GC_PTR) c->hack_signers;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cSlabel);
p = (ptr_t) c->aux_info;
p = (GC_PTR) c->aux_info;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cTlabel);
#ifdef INTERPRETER
@ -216,12 +211,12 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
{
_Jv_InterpClass* ic = (_Jv_InterpClass*) c->aux_info;
p = (ptr_t) ic->interpreted_methods;
p = (GC_PTR) 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];
p = (GC_PTR) ic->interpreted_methods[i];
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, \
cFlabel);
@ -233,7 +228,7 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
= (_Jv_InterpMethod *) ic->interpreted_methods[i];
if (im)
{
p = (ptr_t) im->prepared;
p = (GC_PTR) im->prepared;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, \
cFlabel);
}
@ -241,12 +236,12 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
// The interpreter installs a heap-allocated trampoline
// here, so we'll mark it.
p = (ptr_t) c->methods[i].ncode;
p = (GC_PTR) c->methods[i].ncode;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c,
cm3label);
}
p = (ptr_t) ic->field_initializers;
p = (GC_PTR) ic->field_initializers;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, cGlabel);
}
@ -273,7 +268,7 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
if (JvFieldIsRef (field))
{
jobject val = JvGetObjectField (obj, field);
p = (ptr_t) val;
p = (GC_PTR) val;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit,
obj, elabel);
}
@ -290,10 +285,13 @@ _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;
@ -303,21 +301,21 @@ _Jv_MarkArray (void *addr, void *msp, void *msl, void * /*env*/)
if (__builtin_expect (! dt || !(dt -> get_finalizer()), false))
return mark_stack_ptr;
jclass klass = dt->clas;
ptr_t p;
GC_PTR p;
# ifndef JV_HASH_SYNCHRONIZATION
// Every object has a sync_info pointer.
p = (ptr_t) array->sync_info;
p = (GC_PTR) array->sync_info;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array, e1label);
# endif
// Mark the object's class.
p = (ptr_t) klass;
p = (GC_PTR) klass;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, &(dt -> clas), o2label);
for (int i = 0; i < JvGetArrayLength (array); ++i)
{
jobject obj = elements (array)[i];
p = (ptr_t) obj;
p = (GC_PTR) obj;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array, e2label);
}
@ -366,7 +364,7 @@ _Jv_BuildGCDescr(jclass self)
// If we find a field outside the range of our bitmap,
// fall back to procedure marker. The bottom 2 bits are
// reserved.
if (off >= bits_per_word - 2)
if (off >= (unsigned)bits_per_word - 2)
return (void *) (GCJ_DEFAULT_DESCR);
desc |= 1ULL << (bits_per_word - off - 1);
}
@ -394,12 +392,44 @@ _Jv_AllocBytes (jsize 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
@ -407,12 +437,6 @@ _Jv_AllocArray (jsize size, jclass klass)
// 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
@ -497,17 +521,13 @@ 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)
@ -515,6 +535,29 @@ 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)
{
@ -525,6 +568,8 @@ _Jv_InitGC (void)
// 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,
@ -535,23 +580,14 @@ _Jv_InitGC (void)
// 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));
// 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);
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);
/* 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

17
libjava/configure vendored
View File

@ -869,6 +869,7 @@ Optional Features:
allow compilation of several files at once
--enable-libgcj-debug enable runtime debugging code
--enable-gc-debug include full support for pointer backtracing etc.
--enable-interpreter enable interpreter
--enable-sjlj-exceptions
force use of builtin_setjmp for exceptions
@ -4735,7 +4736,7 @@ test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
case $host in
*-*-irix6*)
# Find out which ABI we are using.
echo '#line 4738 "configure"' > conftest.$ac_ext
echo '#line 4739 "configure"' > conftest.$ac_ext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
@ -5716,6 +5717,18 @@ _ACEOF
fi
fi;
# Check for gc debugging. This option is handled both here and in the GC.
# Check whether --enable-gc-debug or --disable-gc-debug was given.
if test "${enable_gc_debug+set}" = set; then
enableval="$enable_gc_debug"
if test "$enable_gc_debug" = "yes"; then
cat >>confdefs.h <<\_ACEOF
#define LIBGCJ_GC_DEBUG 1
_ACEOF
fi
fi;
# See if the user has the interpreter included.
# Check whether --enable-interpreter or --disable-interpreter was given.
if test "${enable_interpreter+set}" = set; then
@ -5752,7 +5765,7 @@ if test "${enable_sjlj_exceptions+set}" = set; then
:
else
cat > conftest.$ac_ext << EOF
#line 5755 "configure"
#line 5768 "configure"
struct S { ~S(); };
void bar();
void foo()

7
libjava/configure.ac
View File

@ -253,6 +253,13 @@ AC_ARG_ENABLE(libgcj-debug,
LIBGCJDEBUG="true"
fi])
# Check for gc debugging. This option is handled both here and in the GC.
AC_ARG_ENABLE(gc-debug,
[ --enable-gc-debug include full support for pointer backtracing etc.],
[ if test "$enable_gc_debug" = "yes"; then
AC_DEFINE(LIBGCJ_GC_DEBUG)
fi])
# See if the user has the interpreter included.
AC_ARG_ENABLE(interpreter,
AS_HELP_STRING([--enable-interpreter],

12
libjava/include/boehm-gc.h
View File

@ -35,6 +35,8 @@ extern "C" void * GC_local_gcj_malloc(size_t, void *);
extern "C" void * GC_local_malloc_atomic(size_t);
#endif
#ifndef LIBGCJ_GC_DEBUG
inline void *
_Jv_AllocObj (jsize size, jclass klass)
{
@ -67,6 +69,16 @@ _Jv_AllocPtrFreeObj (jsize size, jclass klass)
return obj;
}
#else /* LIBGCJ_GC_DEBUG */
void *
_Jv_AllocObj (jsize size, jclass klass);
void *
_Jv_AllocPtrFreeObj (jsize size, jclass klass);
#endif /* LIBGCJ_GC_DEBUG */
// _Jv_AllocBytes (jsize size) should go here, too. But clients don't
// usually include this header.

3
libjava/include/config.h.in
View File

@ -366,6 +366,9 @@
/* Indicate that linker is not able to 8-byte align static data */
#undef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS
/* Define if we want to use debug calls into the garbage collector. */
#undef LIBGCJ_GC_DEBUG
/* Define if using POSIX threads on Linux. */
#undef LINUX_THREADS

3
libjava/java/lang/natObject.cc
View File

@ -286,6 +286,9 @@ _Jv_ObjectCheckMonitor (jobject obj)
// operations is already ridiculous, and would become worse if we
// went through the proper intermediaries.
#else
# ifdef LIBGCJ_GC_DEBUG
# define GC_DEBUG
# endif
# include "gc.h"
#endif