#include <config.h>
#include <stdio.h>
#include <limits.h>
#include <jvm.h>
#include <gcj/cni.h>
#include <java/lang/Class.h>
#include <java/lang/reflect/Modifier.h>
#include <java-interp.h>
#undef TRUE
#undef FALSE
extern "C"
{
#include <gc_config.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
void GC_enable();
void GC_disable();
};
#define MAYBE_MARK(Obj, Top, Limit, Source) \
Top=GC_MARK_AND_PUSH((GC_PTR) Obj, Top, Limit, (GC_PTR *) Source)
static int array_kind_x;
static void **array_free_list;
void *
_Jv_MarkObj (void *addr, void *msp, void *msl, void *env)
{
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)
addr = (GC_PTR)GC_USR_PTR_FROM_BASE(addr);
jobject obj = (jobject) addr;
_Jv_VTable *dt = *(_Jv_VTable **) addr;
if (__builtin_expect (! dt || !(dt -> get_finalizer()), false))
return mark_stack_ptr;
jclass klass = dt->clas;
GC_PTR p;
# ifndef JV_HASH_SYNCHRONIZATION
p = (GC_PTR) obj->sync_info;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj);
# endif
p = (GC_PTR) klass;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj);
if (__builtin_expect (klass == &java::lang::Class::class$, false))
{
jclass c = (jclass) addr;
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);
for (int i = 0; i < c->constants.size; ++i)
{
p = (GC_PTR) c->constants.data[i].p;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
}
#ifdef INTERPRETER
if (_Jv_IsInterpretedClass (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);
}
#endif
p = (GC_PTR) c->vtable;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
p = (GC_PTR) c->methods;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
if (__builtin_expect (c->name == NULL, false))
return mark_stack_ptr;
if (! c->isArray() && ! c->isPrimitive())
{
for (int i = 0; i < c->method_count; ++i)
{
p = (GC_PTR) c->methods[i].name;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
p = (GC_PTR) c->methods[i].signature;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
p = (GC_PTR) c->methods[i].throws;
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);
for (int i = 0; i < c->field_count; ++i)
{
_Jv_Field* field = &c->fields[i];
p = (GC_PTR) field->name;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
p = (GC_PTR) field->type;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
if ((field->flags & java::lang::reflect::Modifier::STATIC))
{
p = (GC_PTR) field->u.addr;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
if (JvFieldIsRef (field) && p && field->isResolved())
{
jobject val = *(jobject*) p;
p = (GC_PTR) val;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
}
}
}
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);
for (int i = 0; i < c->interface_count; ++i)
{
p = (GC_PTR) c->interfaces[i];
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);
p = (GC_PTR) c->ancestors;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
if (c->idt)
{
p = (GC_PTR) c->idt;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
if (c->isInterface())
{
p = (GC_PTR) c->idt->iface.ioffsets;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c->idt);
}
else if (! c->isPrimitive())
{
p = (GC_PTR) c->idt->cls.itable;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c->idt);
}
}
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);
#ifdef INTERPRETER
if (_Jv_IsInterpretedClass (c) && c->aux_info)
{
_Jv_InterpClass* ic = (_Jv_InterpClass*) c->aux_info;
p = (GC_PTR) ic->interpreted_methods;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
for (int i = 0; i < c->method_count; i++)
{
p = (GC_PTR) c->methods[i].ncode;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c);
using namespace java::lang::reflect;
if ((c->methods[i].accflags & Modifier::ABSTRACT) != 0)
continue;
p = (GC_PTR) ic->interpreted_methods[i];
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
if ((c->methods[i].accflags & Modifier::NATIVE) != 0)
{
_Jv_JNIMethod *jm
= (_Jv_JNIMethod *) ic->interpreted_methods[i];
if (jm)
{
p = (GC_PTR) jm->jni_arg_types;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, p);
}
}
else
{
_Jv_InterpMethod *im
= (_Jv_InterpMethod *) ic->interpreted_methods[i];
if (im)
{
p = (GC_PTR) im->prepared;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
}
}
}
p = (GC_PTR) ic->field_initializers;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic);
}
#endif
}
else
{
while (klass && klass != &java::lang::Object::class$)
{
jfieldID field = JvGetFirstInstanceField (klass);
jint max = JvNumInstanceFields (klass);
for (int i = 0; i < max; ++i)
{
if (JvFieldIsRef (field))
{
jobject val = JvGetObjectField (obj, field);
p = (GC_PTR) val;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, obj);
}
field = field->getNextField ();
}
klass = klass->getSuperclass();
}
}
return mark_stack_ptr;
}
void *
_Jv_MarkArray (void *addr, void *msp, void *msl, void *env)
{
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)
addr = (void *)GC_USR_PTR_FROM_BASE(addr);
jobjectArray array = (jobjectArray) addr;
_Jv_VTable *dt = *(_Jv_VTable **) addr;
if (__builtin_expect (! dt || !(dt -> get_finalizer()), false))
return mark_stack_ptr;
jclass klass = dt->clas;
GC_PTR p;
# ifndef JV_HASH_SYNCHRONIZATION
p = (GC_PTR) array->sync_info;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array);
# endif
p = (GC_PTR) klass;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, &(dt -> clas));
for (int i = 0; i < JvGetArrayLength (array); ++i)
{
jobject obj = elements (array)[i];
p = (GC_PTR) obj;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, array);
}
return mark_stack_ptr;
}
#define GCJ_DEFAULT_DESCR GC_MAKE_PROC(GC_GCJ_RESERVED_MARK_PROC_INDEX,0)
void *
_Jv_BuildGCDescr(jclass self)
{
jlong desc = 0;
jint bits_per_word = CHAR_BIT * sizeof (void *);
desc |= 1ULL << (bits_per_word - 1);
#ifndef JV_HASH_SYNCHRONIZATION
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 (off % sizeof (void *) != 0)
return (void *) (GCJ_DEFAULT_DESCR);
off /= sizeof (void *);
if (off >= (unsigned) bits_per_word - 2)
return (void *) (GCJ_DEFAULT_DESCR);
desc |= 1ULL << (bits_per_word - off - 1);
}
field = field->getNextField();
}
}
desc |= 1;
return (void *) (unsigned long) desc;
}
void *
_Jv_AllocBytes (jsize size)
{
void *r = GC_MALLOC_ATOMIC (size);
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
void *
_Jv_AllocArray (jsize size, jclass klass)
{
void *obj;
#ifdef LIBGCJ_GC_DEBUG
obj = GC_MALLOC(size);
#else
const jsize min_heap_addr = 16*1024;
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;
}
void *
_Jv_AllocRawObj (jsize size)
{
return (void *) GC_MALLOC (size);
}
static void
call_finalizer (GC_PTR obj, GC_PTR client_data)
{
_Jv_FinalizerFunc *fn = (_Jv_FinalizerFunc *) client_data;
jobject jobj = (jobject) obj;
(*fn) (jobj);
}
void
_Jv_RegisterFinalizer (void *object, _Jv_FinalizerFunc *meth)
{
GC_REGISTER_FINALIZER_NO_ORDER (object, call_finalizer, (GC_PTR) meth,
NULL, NULL);
}
void
_Jv_RunFinalizers (void)
{
GC_invoke_finalizers ();
}
void
_Jv_RunAllFinalizers (void)
{
GC_finalize_all ();
}
void
_Jv_RunGC (void)
{
GC_gcollect ();
}
long
_Jv_GCTotalMemory (void)
{
return GC_get_heap_size ();
}
long
_Jv_GCFreeMemory (void)
{
return GC_get_free_bytes ();
}
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);
}
void
_Jv_DisableGC (void)
{
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 )
{
strcpy(out_buf, "GCJ (bad)");
return;
}
jclass klass = dt->clas;
if (!klass )
{
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;
GC_all_interior_pointers = 0;
GC_init_gcj_malloc (0, (void *) _Jv_MarkObj);
GC_oom_fn = handle_out_of_memory;
GC_java_finalization = 1;
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);
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
static _Jv_VTable trace_one_vtable = {
0, (void *)(2 * sizeof(void *)),
{0} };
void *
_Jv_AllocTraceOne (jsize size )
{
return GC_GCJ_MALLOC (size, &trace_one_vtable);
}
static _Jv_VTable trace_two_vtable =
{
0, (void *)(3 * sizeof(void *)),
{0} };
void *
_Jv_AllocTraceTwo (jsize size )
{
return GC_GCJ_MALLOC (size, &trace_two_vtable);
}
#endif
void
_Jv_GCInitializeFinalizers (void (*notifier) (void))
{
GC_finalize_on_demand = 1;
GC_finalizer_notifier = notifier;
}
void
_Jv_GCRegisterDisappearingLink (jobject *objp)
{
if (GC_base(*objp))
GC_general_register_disappearing_link ((GC_PTR *) objp, (GC_PTR) *objp);
}
jboolean
_Jv_GCCanReclaimSoftReference (jobject)
{
return true;
}