#include <config.h>
#include <platform.h>
#include <stdio.h>
#include <java-interp.h>
#include <jvm.h>
#include <gcj/cni.h>
#include <string.h>
#include <limits.h>
#include <java-cpool.h>
#include <execution.h>
#include <java/lang/Class.h>
#include <java/lang/String.h>
#include <java/lang/StringBuffer.h>
#include <java/lang/Thread.h>
#include <java/lang/InternalError.h>
#include <java/lang/VirtualMachineError.h>
#include <java/lang/VerifyError.h>
#include <java/lang/NoSuchFieldError.h>
#include <java/lang/NoSuchMethodError.h>
#include <java/lang/ClassFormatError.h>
#include <java/lang/IllegalAccessError.h>
#include <java/lang/AbstractMethodError.h>
#include <java/lang/NoClassDefFoundError.h>
#include <java/lang/IncompatibleClassChangeError.h>
#include <java/lang/VerifyError.h>
#include <java/lang/VMClassLoader.h>
#include <java/lang/reflect/Modifier.h>
#include <java/security/CodeSource.h>
using namespace gcj;
bool gcj::verbose_class_flag;
typedef unsigned int uaddr __attribute__ ((mode (pointer)));
template<typename T>
struct aligner
{
char c;
T field;
};
#define ALIGNOF(TYPE) (offsetof (aligner<TYPE>, field))
int
_Jv_Linker::get_alignment_from_class (jclass klass)
{
if (klass == JvPrimClass (byte))
return ALIGNOF (jbyte);
else if (klass == JvPrimClass (short))
return ALIGNOF (jshort);
else if (klass == JvPrimClass (int))
return ALIGNOF (jint);
else if (klass == JvPrimClass (long))
return ALIGNOF (jlong);
else if (klass == JvPrimClass (boolean))
return ALIGNOF (jboolean);
else if (klass == JvPrimClass (char))
return ALIGNOF (jchar);
else if (klass == JvPrimClass (float))
return ALIGNOF (jfloat);
else if (klass == JvPrimClass (double))
return ALIGNOF (jdouble);
else
return ALIGNOF (jobject);
}
void
_Jv_Linker::resolve_field (_Jv_Field *field, java::lang::ClassLoader *loader)
{
if (! field->isResolved ())
{
_Jv_Utf8Const *sig = (_Jv_Utf8Const*)field->type;
field->type = _Jv_FindClassFromSignature (sig->chars(), loader);
field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
}
}
_Jv_Field *
_Jv_Linker::find_field_helper (jclass search, _Jv_Utf8Const *name,
_Jv_Utf8Const *type_name,
jclass *declarer)
{
while (search)
{
for (int i = 0; i < search->field_count; ++i)
{
_Jv_Field *field = &search->fields[i];
if (! _Jv_equalUtf8Consts (field->name, name))
continue;
if (! field->isResolved ())
resolve_field (field, search->loader);
if (_Jv_equalUtf8Consts (type_name, field->type->name))
{
*declarer = search;
return field;
}
}
for (int i = 0; i < search->interface_count; ++i)
{
_Jv_Field *result = find_field_helper (search->interfaces[i], name,
type_name, declarer);
if (result)
return result;
}
search = search->superclass;
}
return NULL;
}
bool
_Jv_Linker::has_field_p (jclass search, _Jv_Utf8Const *field_name)
{
for (int i = 0; i < search->field_count; ++i)
{
_Jv_Field *field = &search->fields[i];
if (_Jv_equalUtf8Consts (field->name, field_name))
return true;
}
return false;
}
_Jv_Field *
_Jv_Linker::find_field (jclass klass, jclass owner,
_Jv_Utf8Const *field_name,
_Jv_Utf8Const *field_type_name)
{
jclass field_type = _Jv_FindClassFromSignature (field_type_name->chars(),
klass->loader);
jclass found_class = 0;
_Jv_Field *the_field = find_field_helper (owner, field_name,
field_type->name, &found_class);
if (the_field == 0)
{
java::lang::StringBuffer *sb = new java::lang::StringBuffer();
sb->append(JvNewStringLatin1("field "));
sb->append(owner->getName());
sb->append(JvNewStringLatin1("."));
sb->append(_Jv_NewStringUTF(field_name->chars()));
sb->append(JvNewStringLatin1(" was not found."));
throw new java::lang::NoSuchFieldError (sb->toString());
}
if (_Jv_CheckAccess (klass, found_class, the_field->flags))
{
if (the_field->type != field_type)
throw new java::lang::LinkageError
(JvNewStringLatin1
("field type mismatch with different loaders"));
}
else
{
java::lang::StringBuffer *sb
= new java::lang::StringBuffer ();
sb->append(klass->getName());
sb->append(JvNewStringLatin1(": "));
sb->append(found_class->getName());
sb->append(JvNewStringLatin1("."));
sb->append(_Jv_NewStringUtf8Const (field_name));
throw new java::lang::IllegalAccessError(sb->toString());
}
return the_field;
}
_Jv_word
_Jv_Linker::resolve_pool_entry (jclass klass, int index)
{
using namespace java::lang::reflect;
_Jv_Constants *pool = &klass->constants;
if ((pool->tags[index] & JV_CONSTANT_ResolvedFlag) != 0)
return pool->data[index];
switch (pool->tags[index])
{
case JV_CONSTANT_Class:
{
_Jv_Utf8Const *name = pool->data[index].utf8;
jclass found;
if (name->first() == '[')
found = _Jv_FindClassFromSignature (name->chars(),
klass->loader);
else
found = _Jv_FindClass (name, klass->loader);
if (! found)
throw new java::lang::NoClassDefFoundError (name->toString());
jclass check;
for (check = found;
check && check->isArray();
check = check->getComponentType())
;
if ((found->accflags & Modifier::PUBLIC) == Modifier::PUBLIC
|| (_Jv_ClassNameSamePackage (check->name,
klass->name)))
{
pool->data[index].clazz = found;
pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
}
else
{
java::lang::StringBuffer *sb = new java::lang::StringBuffer ();
sb->append(klass->getName());
sb->append(JvNewStringLatin1(" can't access class "));
sb->append(found->getName());
throw new java::lang::IllegalAccessError(sb->toString());
}
}
break;
case JV_CONSTANT_String:
{
jstring str;
str = _Jv_NewStringUtf8Const (pool->data[index].utf8);
pool->data[index].o = str;
pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
}
break;
case JV_CONSTANT_Fieldref:
{
_Jv_ushort class_index, name_and_type_index;
_Jv_loadIndexes (&pool->data[index],
class_index,
name_and_type_index);
jclass owner = (resolve_pool_entry (klass, class_index)).clazz;
if (owner != klass)
_Jv_InitClass (owner);
_Jv_ushort name_index, type_index;
_Jv_loadIndexes (&pool->data[name_and_type_index],
name_index,
type_index);
_Jv_Utf8Const *field_name = pool->data[name_index].utf8;
_Jv_Utf8Const *field_type_name = pool->data[type_index].utf8;
_Jv_Field *the_field = find_field (klass, owner, field_name,
field_type_name);
pool->data[index].field = the_field;
pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
}
break;
case JV_CONSTANT_Methodref:
case JV_CONSTANT_InterfaceMethodref:
{
_Jv_ushort class_index, name_and_type_index;
_Jv_loadIndexes (&pool->data[index],
class_index,
name_and_type_index);
jclass owner = (resolve_pool_entry (klass, class_index)).clazz;
if (owner != klass)
_Jv_InitClass (owner);
_Jv_ushort name_index, type_index;
_Jv_loadIndexes (&pool->data[name_and_type_index],
name_index,
type_index);
_Jv_Utf8Const *method_name = pool->data[name_index].utf8;
_Jv_Utf8Const *method_signature = pool->data[type_index].utf8;
_Jv_Method *the_method = 0;
jclass found_class = 0;
wait_for_state (klass, JV_STATE_LOADED);
the_method = search_method_in_class (owner, klass,
method_name, method_signature);
if (the_method != 0)
{
found_class = owner;
goto end_of_method_search;
}
if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref)
{
_Jv_ifaces ifaces;
ifaces.count = 0;
ifaces.len = 4;
ifaces.list = (jclass *) _Jv_Malloc (ifaces.len
* sizeof (jclass *));
get_interfaces (owner, &ifaces);
for (int i = 0; i < ifaces.count; i++)
{
jclass cls = ifaces.list[i];
the_method = search_method_in_class (cls, klass, method_name,
method_signature);
if (the_method != 0)
{
found_class = cls;
break;
}
}
_Jv_Free (ifaces.list);
if (the_method != 0)
goto end_of_method_search;
}
for (jclass cls = owner->getSuperclass (); cls != 0;
cls = cls->getSuperclass ())
{
the_method = search_method_in_class (cls, klass, method_name,
method_signature);
if (the_method != 0)
{
found_class = cls;
break;
}
}
end_of_method_search:
if (the_method == 0)
{
java::lang::StringBuffer *sb = new java::lang::StringBuffer();
sb->append(JvNewStringLatin1("method "));
sb->append(owner->getName());
sb->append(JvNewStringLatin1("."));
sb->append(_Jv_NewStringUTF(method_name->chars()));
sb->append(JvNewStringLatin1(" with signature "));
sb->append(_Jv_NewStringUTF(method_signature->chars()));
sb->append(JvNewStringLatin1(" was not found."));
throw new java::lang::NoSuchMethodError (sb->toString());
}
int vtable_index = -1;
if (pool->tags[index] != JV_CONSTANT_InterfaceMethodref)
vtable_index = (jshort)the_method->index;
pool->data[index].rmethod
= klass->engine->resolve_method(the_method,
found_class,
((the_method->accflags
& Modifier::STATIC) != 0),
vtable_index);
pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
}
break;
}
return pool->data[index];
}
void
_Jv_Linker::resolve_class_ref (jclass klass, jclass *classref)
{
jclass ret = *classref;
if (ret && (uaddr) ret < (uaddr) klass->constants.size)
{
if (klass->state < JV_STATE_LINKED)
{
_Jv_Utf8Const *name = klass->constants.data[(uaddr) *classref].utf8;
ret = _Jv_FindClass (name, klass->loader);
if (! ret)
{
throw new java::lang::NoClassDefFoundError (name->toString());
}
}
else
ret = klass->constants.data[(uaddr) classref].clazz;
*classref = ret;
}
}
_Jv_Method *
_Jv_Linker::search_method_in_class (jclass cls, jclass klass,
_Jv_Utf8Const *method_name,
_Jv_Utf8Const *method_signature)
{
using namespace java::lang::reflect;
for (int i = 0; i < cls->method_count; i++)
{
_Jv_Method *method = &cls->methods[i];
if ( (!_Jv_equalUtf8Consts (method->name,
method_name))
|| (!_Jv_equalUtf8Consts (method->signature,
method_signature)))
continue;
if (_Jv_CheckAccess (klass, cls, method->accflags))
return method;
else
{
java::lang::StringBuffer *sb = new java::lang::StringBuffer();
sb->append(klass->getName());
sb->append(JvNewStringLatin1(": "));
sb->append(cls->getName());
sb->append(JvNewStringLatin1("."));
sb->append(_Jv_NewStringUTF(method_name->chars()));
sb->append(_Jv_NewStringUTF(method_signature->chars()));
throw new java::lang::IllegalAccessError (sb->toString());
}
}
return 0;
}
#define INITIAL_IOFFSETS_LEN 4
#define INITIAL_IFACES_LEN 4
static _Jv_IDispatchTable null_idt = { {SHRT_MAX, 0, NULL} };
void
_Jv_Linker::prepare_constant_time_tables (jclass klass)
{
if (klass->isPrimitive () || klass->isInterface ())
return;
if ((klass->idt != NULL) || klass->depth != 0)
return;
jclass klass0 = klass;
jboolean has_interfaces = 0;
while (klass0 != &java::lang::Object::class$)
{
has_interfaces += klass0->interface_count;
klass0 = klass0->superclass;
klass->depth++;
}
klass->ancestors = (jclass *) _Jv_Malloc (klass->depth
* sizeof (jclass));
klass0 = klass;
for (int index = 0; index < klass->depth; index++)
{
klass->ancestors[index] = klass0;
klass0 = klass0->superclass;
}
if ((klass->accflags & java::lang::reflect::Modifier::ABSTRACT) != 0)
return;
if (!has_interfaces)
{
klass->idt = &null_idt;
return;
}
klass->idt =
(_Jv_IDispatchTable *) _Jv_Malloc (sizeof (_Jv_IDispatchTable));
_Jv_ifaces ifaces;
ifaces.count = 0;
ifaces.len = INITIAL_IFACES_LEN;
ifaces.list = (jclass *) _Jv_Malloc (ifaces.len * sizeof (jclass *));
int itable_size = get_interfaces (klass, &ifaces);
if (ifaces.count > 0)
{
klass->idt->cls.itable =
(void **) _Jv_Malloc (itable_size * sizeof (void *));
klass->idt->cls.itable_length = itable_size;
jshort *itable_offsets =
(jshort *) _Jv_Malloc (ifaces.count * sizeof (jshort));
generate_itable (klass, &ifaces, itable_offsets);
jshort cls_iindex = find_iindex (ifaces.list, itable_offsets,
ifaces.count);
for (int i = 0; i < ifaces.count; i++)
{
ifaces.list[i]->idt->iface.ioffsets[cls_iindex] =
itable_offsets[i];
}
klass->idt->cls.iindex = cls_iindex;
_Jv_Free (ifaces.list);
_Jv_Free (itable_offsets);
}
else
{
klass->idt->cls.iindex = SHRT_MAX;
}
}
inline jshort
_Jv_Linker::indexof (void *item, void **list, jshort list_len)
{
for (int i=0; i < list_len; i++)
{
if (list[i] == item)
return i;
}
return -1;
}
jshort
_Jv_Linker::get_interfaces (jclass klass, _Jv_ifaces *ifaces)
{
jshort result = 0;
for (int i = 0; i < klass->interface_count; i++)
{
jclass iface = klass->interfaces[i];
wait_for_state(iface, JV_STATE_LINKED);
if (indexof (iface, (void **) ifaces->list, ifaces->count) == -1)
{
if (ifaces->count + 1 >= ifaces->len)
{
ifaces->len = ifaces->len * 2;
ifaces->list
= (jclass *) _Jv_Realloc (ifaces->list,
ifaces->len * sizeof(jclass));
}
ifaces->list[ifaces->count] = iface;
ifaces->count++;
result += get_interfaces (klass->interfaces[i], ifaces);
}
}
if (klass->isInterface())
result += klass->method_count + 1;
else if (klass->superclass)
result += get_interfaces (klass->superclass, ifaces);
return result;
}
void
_Jv_Linker::generate_itable (jclass klass, _Jv_ifaces *ifaces,
jshort *itable_offsets)
{
void **itable = klass->idt->cls.itable;
jshort itable_pos = 0;
for (int i = 0; i < ifaces->count; i++)
{
jclass iface = ifaces->list[i];
itable_offsets[i] = itable_pos;
itable_pos = append_partial_itable (klass, iface, itable, itable_pos);
if (iface->idt == NULL)
{
iface->idt
= (_Jv_IDispatchTable *) _Jv_Malloc (sizeof (_Jv_IDispatchTable));
jshort *ioffsets = (jshort *) _Jv_Malloc (INITIAL_IOFFSETS_LEN
* sizeof (jshort));
ioffsets[0] = INITIAL_IOFFSETS_LEN;
for (int i = 1; i < INITIAL_IOFFSETS_LEN; i++)
ioffsets[i] = -1;
iface->idt->iface.ioffsets = ioffsets;
}
}
}
jstring
_Jv_GetMethodString (jclass klass, _Jv_Method *meth,
jclass derived)
{
using namespace java::lang;
StringBuffer *buf = new StringBuffer (klass->name->toString());
buf->append (jchar ('.'));
buf->append (meth->name->toString());
buf->append ((jchar) ' ');
buf->append (meth->signature->toString());
if (derived)
{
buf->append(JvNewStringLatin1(" in "));
buf->append(derived->name->toString());
}
return buf->toString();
}
void
_Jv_ThrowNoSuchMethodError ()
{
throw new java::lang::NoSuchMethodError;
}
static void
_Jv_abstractMethodError (void)
{
throw new java::lang::AbstractMethodError();
}
jshort
_Jv_Linker::append_partial_itable (jclass klass, jclass iface,
void **itable, jshort pos)
{
using namespace java::lang::reflect;
itable[pos++] = (void *) iface;
_Jv_Method *meth;
for (int j=0; j < iface->method_count; j++)
{
meth = NULL;
for (jclass cl = klass; cl; cl = cl->getSuperclass())
{
meth = _Jv_GetMethodLocal (cl, iface->methods[j].name,
iface->methods[j].signature);
if (meth)
break;
}
if (meth && (meth->name->first() == '<'))
{
itable[pos] = NULL;
}
else if (meth)
{
if ((meth->accflags & Modifier::STATIC) != 0)
throw new java::lang::IncompatibleClassChangeError
(_Jv_GetMethodString (klass, meth));
if ((meth->accflags & Modifier::PUBLIC) == 0)
throw new java::lang::IllegalAccessError
(_Jv_GetMethodString (klass, meth));
if ((meth->accflags & Modifier::ABSTRACT) != 0)
itable[pos] = (void *) &_Jv_abstractMethodError;
else
itable[pos] = meth->ncode;
}
else
{
itable[pos] = (void *) _Jv_ThrowNoSuchMethodError;
}
pos++;
}
return pos;
}
static _Jv_Mutex_t iindex_mutex;
static bool iindex_mutex_initialized = false;
jshort
_Jv_Linker::find_iindex (jclass *ifaces, jshort *offsets, jshort num)
{
int i;
int j;
if (! iindex_mutex_initialized)
{
_Jv_MutexInit (&iindex_mutex);
iindex_mutex_initialized = true;
}
_Jv_MutexLock (&iindex_mutex);
for (i=1;; i++)
{
for (j=0;; j++)
{
if (j >= num)
goto found;
if (i >= ifaces[j]->idt->iface.ioffsets[0])
continue;
int ioffset = ifaces[j]->idt->iface.ioffsets[i];
if (ioffset >= 0 && ioffset != offsets[j])
break;
}
}
found:
for (j = 0; j < num; j++)
{
int len = ifaces[j]->idt->iface.ioffsets[0];
if (i >= len)
{
int newlen = 2 * len;
if (i >= newlen)
newlen = i + 3;
jshort *old_ioffsets = ifaces[j]->idt->iface.ioffsets;
jshort *new_ioffsets = (jshort *) _Jv_Malloc (newlen
* sizeof(jshort));
memcpy (&new_ioffsets[1], &old_ioffsets[1],
(len - 1) * sizeof (jshort));
new_ioffsets[0] = newlen;
while (len < newlen)
new_ioffsets[len++] = -1;
ifaces[j]->idt->iface.ioffsets = new_ioffsets;
}
ifaces[j]->idt->iface.ioffsets[i] = offsets[j];
}
_Jv_MutexUnlock (&iindex_mutex);
return i;
}
static bool debug_link = false;
void
_Jv_Linker::link_symbol_table (jclass klass)
{
int index = 0;
_Jv_MethodSymbol sym;
if (klass->otable == NULL
|| klass->otable->state != 0)
goto atable;
klass->otable->state = 1;
if (debug_link)
fprintf (stderr, "Fixing up otable in %s:\n", klass->name->chars());
for (index = 0;
(sym = klass->otable_syms[index]).class_name != NULL;
++index)
{
jclass target_class = _Jv_FindClass (sym.class_name, klass->loader);
_Jv_Method *meth = NULL;
_Jv_Utf8Const *signature = sym.signature;
{
static char *bounce = (char *)_Jv_ThrowNoSuchMethodError;
ptrdiff_t offset = (char *)(klass->vtable) - bounce;
klass->otable->offsets[index] = offset;
}
if (target_class == NULL)
throw new java::lang::NoClassDefFoundError
(_Jv_NewStringUTF (sym.class_name->chars()));
if (signature->first() == '(' && signature->len() >= 2)
{
if (target_class->isInterface())
{
using namespace java::lang;
StringBuffer *sb = new StringBuffer();
sb->append(JvNewStringLatin1("found interface "));
sb->append(target_class->getName());
sb->append(JvNewStringLatin1(" when searching for a class"));
throw new VerifyError(sb->toString());
}
wait_for_state(target_class, JV_STATE_PREPARED);
meth = _Jv_LookupDeclaredMethod(target_class, sym.name,
sym.signature);
if (meth != NULL)
{
int offset = _Jv_VTable::idx_to_offset (meth->index);
if (offset == -1)
JvFail ("Bad method index");
JvAssert (meth->index < target_class->vtable_method_count);
klass->otable->offsets[index] = offset;
}
if (debug_link)
fprintf (stderr, " offsets[%d] = %d (class %s@%p : %s(%s))\n",
(int)index,
(int)klass->otable->offsets[index],
(const char*)target_class->name->chars(),
target_class,
(const char*)sym.name->chars(),
(const char*)signature->chars());
continue;
}
{
wait_for_state(target_class, JV_STATE_PREPARED);
_Jv_Field *the_field = find_field (klass, target_class,
sym.name, sym.signature);
if ((the_field->flags & java::lang::reflect::Modifier::STATIC))
throw new java::lang::IncompatibleClassChangeError;
else
klass->otable->offsets[index] = the_field->u.boffset;
}
}
atable:
if (klass->atable == NULL || klass->atable->state != 0)
goto itable;
klass->atable->state = 1;
for (index = 0;
(sym = klass->atable_syms[index]).class_name != NULL;
++index)
{
jclass target_class = _Jv_FindClass (sym.class_name, klass->loader);
_Jv_Method *meth = NULL;
_Jv_Utf8Const *signature = sym.signature;
klass->atable->addresses[index] = NULL;
if (target_class == NULL)
throw new java::lang::NoClassDefFoundError
(_Jv_NewStringUTF (sym.class_name->chars()));
if (signature->first() == '(' && signature->len() >= 2)
{
wait_for_state (target_class, JV_STATE_PREPARED);
if (target_class->isInterface())
{
using namespace java::lang;
StringBuffer *sb = new StringBuffer();
sb->append(JvNewStringLatin1("class "));
sb->append(target_class->getName());
sb->append(JvNewStringLatin1(" is an interface: "
"class expected"));
throw new VerifyError(sb->toString());
}
meth = _Jv_LookupDeclaredMethod(target_class, sym.name,
sym.signature);
if (meth != NULL)
{
if (meth->ncode) {
klass->atable->addresses[index] = meth->ncode;
if (debug_link)
fprintf (stderr, " addresses[%d] = %p (class %s@%p : %s(%s))\n",
index,
&klass->atable->addresses[index],
(const char*)target_class->name->chars(),
klass,
(const char*)sym.name->chars(),
(const char*)signature->chars());
}
}
else
klass->atable->addresses[index]
= (void *)_Jv_ThrowNoSuchMethodError;
continue;
}
{
wait_for_state(target_class, JV_STATE_PREPARED);
_Jv_Field *the_field = find_field (klass, target_class,
sym.name, sym.signature);
if ((the_field->flags & java::lang::reflect::Modifier::STATIC))
klass->atable->addresses[index] = the_field->u.addr;
else
throw new java::lang::IncompatibleClassChangeError;
}
}
itable:
if (klass->itable == NULL
|| klass->itable->state != 0)
return;
klass->itable->state = 1;
for (index = 0;
(sym = klass->itable_syms[index]).class_name != NULL;
++index)
{
jclass target_class = _Jv_FindClass (sym.class_name, klass->loader);
_Jv_Utf8Const *signature = sym.signature;
jclass cls;
int i;
wait_for_state(target_class, JV_STATE_LOADED);
bool found = _Jv_getInterfaceMethod (target_class, cls, i,
sym.name, sym.signature);
if (found)
{
klass->itable->addresses[index * 2] = cls;
klass->itable->addresses[index * 2 + 1] = (void *)(unsigned long) i;
if (debug_link)
{
fprintf (stderr, " interfaces[%d] = %p (interface %s@%p : %s(%s))\n",
index,
klass->itable->addresses[index * 2],
(const char*)cls->name->chars(),
cls,
(const char*)sym.name->chars(),
(const char*)signature->chars());
fprintf (stderr, " [%d] = offset %d\n",
index + 1,
(int)(unsigned long)klass->itable->addresses[index * 2 + 1]);
}
}
else
throw new java::lang::IncompatibleClassChangeError;
}
}
void
_Jv_Linker::link_exception_table (jclass self)
{
struct _Jv_CatchClass *catch_record = self->catch_classes;
if (!catch_record || catch_record->classname)
return;
catch_record++;
while (catch_record->classname)
{
try
{
jclass target_class
= _Jv_FindClass (catch_record->classname,
self->getClassLoaderInternal ());
*catch_record->address = target_class;
}
catch (::java::lang::Throwable *t)
{
*catch_record->address = 0;
}
catch_record++;
}
self->catch_classes->classname = (_Jv_Utf8Const *)-1;
}
void
_Jv_Linker::layout_interface_methods (jclass iface)
{
if (! iface->isInterface())
return;
for (int i = 0; i < iface->method_count; i++)
iface->methods[i].index = i + 1;
}
void
_Jv_Linker::layout_vtable_methods (jclass klass)
{
if (klass->vtable != NULL || klass->isInterface()
|| klass->vtable_method_count != -1)
return;
jclass superclass = klass->getSuperclass();
if (superclass != NULL && superclass->vtable_method_count == -1)
{
JvSynchronize sync (superclass);
layout_vtable_methods (superclass);
}
int index = (superclass == NULL ? 0 : superclass->vtable_method_count);
for (int i = 0; i < klass->method_count; ++i)
{
_Jv_Method *meth = &klass->methods[i];
_Jv_Method *super_meth = NULL;
if (! _Jv_isVirtualMethod (meth))
continue;
if (superclass != NULL)
{
jclass declarer;
super_meth = _Jv_LookupDeclaredMethod (superclass, meth->name,
meth->signature, &declarer);
if (super_meth)
{
if (! _Jv_isVirtualMethod (super_meth)
|| ! _Jv_CheckAccess (klass, declarer,
super_meth->accflags))
super_meth = NULL;
else if ((super_meth->accflags
& java::lang::reflect::Modifier::FINAL) != 0)
{
using namespace java::lang;
StringBuffer *sb = new StringBuffer();
sb->append(JvNewStringLatin1("method "));
sb->append(_Jv_GetMethodString(klass, meth));
sb->append(JvNewStringLatin1(" overrides final method "));
sb->append(_Jv_GetMethodString(declarer, super_meth));
throw new VerifyError(sb->toString());
}
}
}
if (super_meth)
meth->index = super_meth->index;
else
meth->index = index++;
}
klass->vtable_method_count = index;
}
void
_Jv_Linker::set_vtable_entries (jclass klass, _Jv_VTable *vtable)
{
for (int i = klass->method_count - 1; i >= 0; i--)
{
using namespace java::lang::reflect;
_Jv_Method *meth = &klass->methods[i];
if (meth->index == (_Jv_ushort) -1)
continue;
if ((meth->accflags & Modifier::ABSTRACT))
vtable->set_method(meth->index, (void *) &_Jv_abstractMethodError);
else
vtable->set_method(meth->index, meth->ncode);
}
}
void
_Jv_Linker::make_vtable (jclass klass)
{
using namespace java::lang::reflect;
if (klass->vtable != NULL || klass->isInterface())
return;
klass->engine->create_ncode(klass);
if (klass->vtable_method_count == -1)
layout_vtable_methods (klass);
_Jv_VTable *vtable = _Jv_VTable::new_vtable (klass->vtable_method_count);
klass->vtable = vtable;
jclass superclass = klass->superclass;
{
JvSynchronize sync (superclass);
make_vtable (superclass);
}
for (int i = 0; i < superclass->vtable_method_count; ++i)
vtable->set_method (i, superclass->vtable->get_method (i));
vtable->clas = klass;
vtable->gc_descr = _Jv_BuildGCDescr (klass);
set_vtable_entries (klass, vtable);
}
void
_Jv_Linker::ensure_fields_laid_out (jclass klass)
{
if (klass->size_in_bytes != -1)
return;
int max_align = __alignof__ (java::lang::Object);
jclass super = klass->getSuperclass();
while (super != NULL)
{
wait_for_state(super, JV_STATE_LOADING);
ensure_fields_laid_out(super);
int num = JvNumInstanceFields (super);
_Jv_Field *field = JvGetFirstInstanceField (super);
while (num > 0)
{
int field_align = get_alignment_from_class (field->type);
if (field_align > max_align)
max_align = field_align;
++field;
--num;
}
super = super->getSuperclass();
}
int instance_size;
int static_size = 0;
if (klass->superclass)
instance_size = klass->superclass->size();
else
instance_size = java::lang::Object::class$.size();
for (int i = 0; i < klass->field_count; i++)
{
int field_size;
int field_align;
_Jv_Field *field = &klass->fields[i];
if (! field->isRef ())
{
resolve_field (field, klass->loader);
field_size = field->type->size ();
field_align = get_alignment_from_class (field->type);
}
else
{
field_size = sizeof (jobject);
field_align = __alignof__ (jobject);
}
field->bsize = field_size;
if ((field->flags & java::lang::reflect::Modifier::STATIC))
{
if (field->u.addr == NULL)
{
static_size = ROUND (static_size, field_align);
field->u.boffset = static_size;
static_size += field_size;
}
}
else
{
instance_size = ROUND (instance_size, field_align);
field->u.boffset = instance_size;
instance_size += field_size;
if (field_align > max_align)
max_align = field_align;
}
}
if (static_size != 0)
klass->engine->allocate_static_fields (klass, static_size);
instance_size = ROUND (instance_size, max_align);
klass->size_in_bytes = instance_size;
}
void
_Jv_Linker::ensure_class_linked (jclass klass)
{
if (klass->state >= JV_STATE_LINKED)
return;
int state = klass->state;
try
{
klass->state = JV_STATE_LINKED;
_Jv_Constants *pool = &klass->constants;
if (! _Jv_IsInterpretedClass (klass))
{
for (int index = 1; index < pool->size; ++index)
{
if (pool->tags[index] == JV_CONSTANT_Class)
resolve_pool_entry (klass, index);
}
}
#if 0 // Should be redundant now
if ((uaddr) klass->superclass < (uaddr) pool->size)
klass->superclass = pool->data[(uaddr) klass->superclass].clazz;
for (int i = 0; i < klass->interface_count; i++)
{
if ((uaddr) klass->interfaces[i] < (uaddr) pool->size)
klass->interfaces[i]
= pool->data[(uaddr) klass->interfaces[i]].clazz;
}
#endif
for (int index = 1; index < pool->size; ++index)
{
if (pool->tags[index] == JV_CONSTANT_String)
{
jstring str;
str = _Jv_NewStringUtf8Const (pool->data[index].utf8);
pool->data[index].o = str;
pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
}
}
if (klass->engine->need_resolve_string_fields())
{
jfieldID f = JvGetFirstStaticField (klass);
for (int n = JvNumStaticFields (klass); n > 0; --n)
{
int mod = f->getModifiers ();
resolve_field(f, klass->loader);
if (f->getClass () == &java::lang::String::class$
&& (mod & java::lang::reflect::Modifier::STATIC) != 0)
{
jstring *strp = (jstring *) f->u.addr;
if (*strp)
*strp = _Jv_NewStringUtf8Const ((_Jv_Utf8Const *) *strp);
}
f = f->getNextField ();
}
}
klass->notifyAll ();
_Jv_PushClass (klass);
}
catch (java::lang::Throwable *t)
{
klass->state = state;
throw t;
}
}
void
_Jv_Linker::ensure_supers_installed (jclass klass)
{
resolve_class_ref (klass, &klass->superclass);
if (klass->superclass)
wait_for_state (klass->superclass, JV_STATE_LOADING);
for (int i = 0; i < klass->interface_count; ++i)
{
resolve_class_ref (klass, &klass->interfaces[i]);
wait_for_state (klass->interfaces[i], JV_STATE_LOADING);
}
}
void
_Jv_Linker::add_miranda_methods (jclass base, jclass iface_class)
{
for (int i = 0; i < iface_class->interface_count; ++i)
{
jclass interface = iface_class->interfaces[i];
for (int j = 0; j < interface->method_count; ++j)
{
_Jv_Method *meth = &interface->methods[j];
if (meth->name->first() == '<')
continue;
_Jv_Method *new_meth = _Jv_LookupDeclaredMethod (base, meth->name,
meth->signature);
if (! new_meth)
{
int new_count = base->method_count + 1;
_Jv_Method *new_m
= (_Jv_Method *) _Jv_AllocBytes (sizeof (_Jv_Method)
* new_count);
memcpy (new_m, base->methods,
sizeof (_Jv_Method) * base->method_count);
new_m[base->method_count] = *meth;
new_m[base->method_count].index = (_Jv_ushort) -1;
new_m[base->method_count].accflags
|= java::lang::reflect::Modifier::INVISIBLE;
base->methods = new_m;
base->method_count = new_count;
}
}
wait_for_state (interface, JV_STATE_LOADED);
add_miranda_methods (base, interface);
}
}
void
_Jv_Linker::ensure_method_table_complete (jclass klass)
{
if (klass->vtable != NULL || klass->isInterface())
return;
wait_for_state (klass->getSuperclass (), JV_STATE_LOADED);
int pre_count = klass->method_count;
add_miranda_methods (klass, klass);
if (klass->method_count != pre_count)
klass->engine->post_miranda_hook(klass);
}
void
_Jv_Linker::verify_class (jclass klass)
{
klass->engine->verify(klass);
}
void
_Jv_Linker::verify_type_assertions (jclass klass)
{
if (debug_link)
fprintf (stderr, "Evaluating type assertions for %s:\n",
klass->name->chars());
if (klass->assertion_table == NULL)
return;
for (int i = 0;; i++)
{
int assertion_code = klass->assertion_table[i].assertion_code;
_Jv_Utf8Const *op1 = klass->assertion_table[i].op1;
_Jv_Utf8Const *op2 = klass->assertion_table[i].op2;
if (assertion_code == JV_ASSERT_END_OF_TABLE)
return;
else if (assertion_code == JV_ASSERT_TYPES_COMPATIBLE)
{
if (debug_link)
{
fprintf (stderr, " code=%i, operand A=%s B=%s\n",
assertion_code, op1->chars(), op2->chars());
}
jclass cl1 = _Jv_FindClassFromSignature (op1->chars(),
klass->getClassLoaderInternal());
jclass cl2 = _Jv_FindClassFromSignature (op2->chars(),
klass->getClassLoaderInternal());
if (cl1 == NULL || cl2 == NULL)
continue;
if (! _Jv_IsAssignableFromSlow (cl2, cl1))
{
jstring s = JvNewStringUTF ("Incompatible types: In class ");
s = s->concat (klass->getName());
s = s->concat (JvNewStringUTF (": "));
s = s->concat (cl1->getName());
s = s->concat (JvNewStringUTF (" is not assignable to "));
s = s->concat (cl2->getName());
throw new java::lang::VerifyError (s);
}
}
else if (assertion_code == JV_ASSERT_IS_INSTANTIABLE)
{
}
}
}
void
_Jv_Linker::print_class_loaded (jclass klass)
{
char *codesource = NULL;
if (klass->protectionDomain != NULL)
{
java::security::CodeSource *cs
= klass->protectionDomain->getCodeSource();
if (cs != NULL)
{
jstring css = cs->toString();
int len = JvGetStringUTFLength(css);
codesource = (char *) _Jv_AllocBytes(len + 1);
JvGetStringUTFRegion(css, 0, css->length(), codesource);
codesource[len] = '\0';
}
}
if (codesource == NULL)
codesource = "<no code source>";
char *abi;
if (_Jv_IsInterpretedClass (klass))
abi = "bytecode";
else if (klass->state == JV_STATE_PRELOADING)
abi = "BC-compiled";
else
abi = "pre-compiled";
fprintf (stderr, "[Loaded (%s) %s from %s]\n", abi, klass->name->chars(),
codesource);
}
void
_Jv_Linker::wait_for_state (jclass klass, int state)
{
if (klass->state >= state)
return;
JvSynchronize sync (klass);
java::lang::Thread *self = java::lang::Thread::currentThread();
while (klass->state <= state
&& klass->thread
&& klass->thread != self)
klass->wait ();
java::lang::Thread *save = klass->thread;
klass->thread = self;
if (gcj::verbose_class_flag
&& (klass->state == JV_STATE_COMPILED
|| klass->state == JV_STATE_PRELOADING)
&& ! _Jv_IsInterpretedClass (klass))
print_class_loaded (klass);
try
{
if (state >= JV_STATE_LOADING && klass->state < JV_STATE_LOADING)
{
ensure_supers_installed (klass);
klass->set_state(JV_STATE_LOADING);
}
if (state >= JV_STATE_LOADED && klass->state < JV_STATE_LOADED)
{
ensure_method_table_complete (klass);
klass->set_state(JV_STATE_LOADED);
}
if (state >= JV_STATE_PREPARED && klass->state < JV_STATE_PREPARED)
{
ensure_fields_laid_out (klass);
make_vtable (klass);
layout_interface_methods (klass);
prepare_constant_time_tables (klass);
klass->set_state(JV_STATE_PREPARED);
}
if (state >= JV_STATE_LINKED && klass->state < JV_STATE_LINKED)
{
verify_class (klass);
ensure_class_linked (klass);
link_exception_table (klass);
link_symbol_table (klass);
klass->set_state(JV_STATE_LINKED);
}
}
catch (java::lang::Throwable *exc)
{
klass->thread = save;
klass->set_state(JV_STATE_ERROR);
throw exc;
}
klass->thread = save;
if (klass->state == JV_STATE_ERROR)
throw new java::lang::LinkageError;
}