// resolve.cc - Code for linking and resolving classes and pool entries.
-/* Copyright (C) 1999 Cygnus Solutions
+/* Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation
This file is part of libgcj.
/* Author: Kresten Krab Thorup <krab@gnu.org> */
+#include <config.h>
+#include <platform.h>
+
#include <java-interp.h>
-#include <cni.h>
#include <jvm.h>
+#include <gcj/cni.h>
#include <string.h>
#include <java-cpool.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/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/ClassNotFoundException.h>
+#include <java/lang/NoClassDefFoundError.h>
#include <java/lang/IncompatibleClassChangeError.h>
+#include <java/lang/VMClassLoader.h>
+#include <java/lang/reflect/Modifier.h>
+
+using namespace gcj;
+
+void
+_Jv_ResolveField (_Jv_Field *field, java::lang::ClassLoader *loader)
+{
+ if (! field->isResolved ())
+ {
+ _Jv_Utf8Const *sig = (_Jv_Utf8Const*)field->type;
+ field->type = _Jv_FindClassFromSignature (sig->data, loader);
+ field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
+ }
+}
#ifdef INTERPRETER
static void throw_class_format_error (char *msg)
__attribute__ ((__noreturn__));
-#define StringClass _CL_Q34java4lang6String
-extern java::lang::Class StringClass;
-#define ClassObject _CL_Q34java4lang6Object
-extern java::lang::Class ClassObject;
-#define ObjectClass _CL_Q34java4lang6Object
-extern java::lang::Class ObjectClass;
-
-
static int get_alignment_from_class (jclass);
static _Jv_ResolvedMethod*
jint);
-static const int PUBLIC = 0x001;
-static const int PRIVATE = 0x002;
-static const int PROTECTED = 0x004;
-static const int STATIC = 0x008;
-static const int FINAL = 0x010;
-static const int SYNCHRONIZED = 0x020;
-static const int VOLATILE = 0x040;
-static const int TRANSIENT = 0x080;
-static const int NATIVE = 0x100;
-static const int INTERFACE = 0x200;
-static const int ABSTRACT = 0x400;
-static const int ALL_FLAGS = 0x7FF;
-
-// We need to know the name of a constructor.
-static _Jv_Utf8Const *init_name = _Jv_makeUtf8Const ("<init>", 6);
-
static void throw_incompatible_class_change_error (jstring msg)
{
- JvThrow (new java::lang::IncompatibleClassChangeError (msg));
+ throw new java::lang::IncompatibleClassChangeError (msg);
}
_Jv_word
_Jv_ResolvePoolEntry (jclass klass, int index)
{
+ using namespace java::lang::reflect;
+
_Jv_Constants *pool = &klass->constants;
if ((pool->tags[index] & JV_CONSTANT_ResolvedFlag) != 0)
if (! found)
{
jstring str = _Jv_NewStringUTF (name->data);
- JvThrow (new java::lang::ClassNotFoundException (str));
+ // This exception is specified in JLS 2nd Ed, section 5.1.
+ throw new java::lang::NoClassDefFoundError (str);
}
- if ((found->accflags & PUBLIC) == PUBLIC
+ if ((found->accflags & Modifier::PUBLIC) == Modifier::PUBLIC
|| (_Jv_ClassNameSamePackage (found->name,
klass->name)))
{
}
else
{
- JvThrow (new java::lang::IllegalAccessError (found->getName()));
+ throw new java::lang::IllegalAccessError (found->getName());
}
}
break;
if (! _Jv_equalUtf8Consts (field->name, field_name))
continue;
- // now, check field access.
-
- if ( (cls == klass)
- || ((field->flags & PUBLIC) != 0)
- || (((field->flags & PROTECTED) != 0)
- && cls->isAssignableFrom (klass))
- || (((field->flags & PRIVATE) == 0)
- && _Jv_ClassNameSamePackage (cls->name,
- klass->name)))
+ if (_Jv_CheckAccess (klass, cls, field->flags))
{
/* resove the field using the class' own loader
if necessary */
_Jv_ResolveField (field, cls->loader);
if (field_type != 0 && field->type != field_type)
- JvThrow
- (new java::lang::LinkageError
- (JvNewStringLatin1
- ("field type mismatch with different loaders")));
+ throw new java::lang::LinkageError
+ (JvNewStringLatin1
+ ("field type mismatch with different loaders"));
the_field = field;
goto end_of_field_search;
}
else
{
- JvThrow (new java::lang::IllegalAccessError);
+ throw new java::lang::IllegalAccessError;
}
}
}
end_of_field_search:
if (the_field == 0)
{
- jstring msg = JvNewStringLatin1 ("field ");
- msg = msg->concat (owner->getName ());
- msg = msg->concat (JvNewStringLatin1("."));
- msg = msg->concat (_Jv_NewStringUTF (field_name->data));
- msg = msg->concat (JvNewStringLatin1(" was not found."));
- throw_incompatible_class_change_error (msg);
+ 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->data));
+ sb->append(JvNewStringLatin1(" was not found."));
+ throw_incompatible_class_change_error(sb->toString());
}
pool->data[index].field = the_field;
_Jv_Utf8Const *method_name = pool->data[name_index].utf8;
_Jv_Utf8Const *method_signature = pool->data[type_index].utf8;
- int vtable_index = -1;
_Jv_Method *the_method = 0;
jclass found_class = 0;
- // we make a loop here, because methods are allowed to be moved to
- // a super class, and still be visible.. (binary compatibility).
+ // First search the class itself.
+ the_method = _Jv_SearchMethodInClass (owner, klass,
+ method_name, method_signature);
- for (jclass cls = owner; cls != 0; cls = cls->getSuperclass ())
- {
- 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 (the_method != 0)
+ {
+ found_class = owner;
+ goto end_of_method_search;
+ }
- if (cls == klass
- || ((method->accflags & PUBLIC) != 0)
- || (((method->accflags & PROTECTED) != 0)
- && cls->isAssignableFrom (klass))
- || (((method->accflags & PRIVATE) == 0)
- && _Jv_ClassNameSamePackage (cls->name,
- klass->name)))
- {
- // FIXME: if (cls->loader != klass->loader), then we
- // must actually check that the types of arguments
- // correspond. That is, for each argument type, and
- // the return type, doing _Jv_FindClassFromSignature
- // with either loader should produce the same result,
- // i.e., exactly the same jclass object. JVMS 5.4.3.3
-
- the_method = method;
+ // If we are resolving an interface method, search the
+ // interface's superinterfaces (A superinterface is not an
+ // interface's superclass - a superinterface is implemented by
+ // the interface).
+ 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 *));
+
+ _Jv_GetInterfaces (owner, &ifaces);
+
+ for (int i = 0; i < ifaces.count; i++)
+ {
+ jclass cls = ifaces.list[i];
+ the_method = _Jv_SearchMethodInClass (cls, klass, method_name,
+ method_signature);
+ if (the_method != 0)
+ {
found_class = cls;
+ break;
+ }
+ }
-
- if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref)
- vtable_index = -1;
- else
- vtable_index = _Jv_DetermineVTableIndex
- (cls, method_name, method_signature);
+ _Jv_Free (ifaces.list);
- if (vtable_index == 0)
- throw_incompatible_class_change_error
- (JvNewStringLatin1 ("method not found"));
+ if (the_method != 0)
+ goto end_of_method_search;
+ }
- goto end_of_method_search;
- }
- else
- {
- JvThrow (new java::lang::IllegalAccessError);
- }
+ // Finally, search superclasses.
+ for (jclass cls = owner->getSuperclass (); cls != 0;
+ cls = cls->getSuperclass ())
+ {
+ the_method = _Jv_SearchMethodInClass (cls, klass,
+ method_name, method_signature);
+ if (the_method != 0)
+ {
+ found_class = cls;
+ break;
}
}
end_of_method_search:
+
+ // FIXME: if (cls->loader != klass->loader), then we
+ // must actually check that the types of arguments
+ // correspond. That is, for each argument type, and
+ // the return type, doing _Jv_FindClassFromSignature
+ // with either loader should produce the same result,
+ // i.e., exactly the same jclass object. JVMS 5.4.3.3
+
if (the_method == 0)
{
- jstring msg = JvNewStringLatin1 ("method ");
- msg = msg->concat (owner->getName ());
- msg = msg->concat (JvNewStringLatin1("."));
- msg = msg->concat (_Jv_NewStringUTF (method_name->data));
- msg = msg->concat (JvNewStringLatin1(" was not found."));
- JvThrow(new java::lang::NoSuchFieldError (msg));
+ 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->data));
+ 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 =
_Jv_BuildResolvedMethod(the_method,
found_class,
- ((the_method->accflags & STATIC) != 0),
+ (the_method->accflags & Modifier::STATIC) != 0,
vtable_index);
pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
}
return pool->data[index];
}
-
-void
-_Jv_ResolveField (_Jv_Field *field, java::lang::ClassLoader *loader)
+// Find a method declared in the cls that is referenced from klass and
+// perform access checks.
+_Jv_Method *
+_Jv_SearchMethodInClass (jclass cls, jclass klass,
+ _Jv_Utf8Const *method_name,
+ _Jv_Utf8Const *method_signature)
{
- if (! field->isResolved ())
- {
- _Jv_Utf8Const *sig = (_Jv_Utf8Const*)field->type;
- field->type = _Jv_FindClassFromSignature (sig->data, loader);
- field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
- }
-}
+ using namespace java::lang::reflect;
-_Jv_Method*
-_Jv_LookupDeclaredMethod (jclass klass, _Jv_Utf8Const *name,
- _Jv_Utf8Const *signature)
-{
- for (; klass; klass = klass->getSuperclass())
+ for (int i = 0; i < cls->method_count; i++)
{
- _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature);
+ _Jv_Method *method = &cls->methods[i];
+ if ( (!_Jv_equalUtf8Consts (method->name,
+ method_name))
+ || (!_Jv_equalUtf8Consts (method->signature,
+ method_signature)))
+ continue;
- if (meth)
- return meth;
+ if (_Jv_CheckAccess (klass, cls, method->accflags))
+ return method;
+ else
+ throw new java::lang::IllegalAccessError;
}
-
- return NULL;
+ return 0;
}
-/** FIXME: this is a terribly inefficient algorithm! It would improve
- things if compiled classes to know vtable offset, and _Jv_Method had
- a field for this.
-
- Returns 0 if this class does not declare the given method.
- Returns -1 if the given method does not appear in the vtable.
- i.e., it is static, private, final or a constructor.
- Otherwise, returns the vtable index. */
-int
-_Jv_DetermineVTableIndex (jclass klass,
- _Jv_Utf8Const *name,
- _Jv_Utf8Const *signature)
+// A helper for _Jv_PrepareClass. This adds missing `Miranda methods'
+// to a class.
+void
+_Jv_PrepareMissingMethods (jclass base2, jclass iface_class)
{
- jclass super_class = klass->getSuperclass ();
-
- if (super_class != NULL)
+ _Jv_InterpClass *base = reinterpret_cast<_Jv_InterpClass *> (base2);
+ for (int i = 0; i < iface_class->interface_count; ++i)
{
- int prev = _Jv_DetermineVTableIndex (super_class,
- name,
- signature);
- if (prev != 0)
- return prev;
- }
-
- /* at this point, we know that the super-class does not declare
- * the method. Otherwise, the above call would have found it, and
- * determined the result of this function (-1 or some positive
- * number).
- */
-
- _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature);
-
- /* now, if we do not declare this method, return zero */
- if (meth == NULL)
- return 0;
-
- /* so now, we know not only that the super class does not declare the
- * method, but we do! So, this is a first declaration of the method. */
-
- /* now, the checks for things that are declared in this class, but do
- * not go into the vtable. There are three cases.
- * 1) the method is static, private or final
- * 2) the class itself is final, or
- * 3) it is the method <init>
- */
-
- if ( (meth->accflags & (STATIC|PRIVATE|FINAL)) != 0
- || (klass->accflags & FINAL) != 0
- || _Jv_equalUtf8Consts (name, init_name))
- return -1;
-
- /* reaching this point, we know for sure, that the method in question
- * will be in the vtable. The question is where. */
-
- /* the base offset, is where we will start assigning vtable
- * indexes for this class. It is 1 for base classes
- * (vtable->method[0] is unused), and for non-base classes it is the
- * number of entries in the super class' vtable plus 1. */
-
- int base_offset;
- if (super_class == 0)
- base_offset = 1;
- else
- base_offset = super_class->vtable_method_count+1;
-
- /* we will consider methods 0..this_method_index-1. And for each one,
- * determine if it is new (i.e., if it appears in the super class),
- * and if it should go in the vtable. If so, increment base_offset */
-
- int this_method_index = meth - (&klass->methods[0]);
-
- for (int i = 0; i < this_method_index; i++)
- {
- _Jv_Method *m = &klass->methods[i];
-
- /* fist some checks for things that surely do not go in the
- * vtable */
-
- if ((m->accflags & (STATIC|PRIVATE)) != 0)
- continue;
- if (_Jv_equalUtf8Consts (m->name, init_name))
- continue;
-
- /* Then, we need to know if this method appears in the
- superclass. (This is where this function gets expensive) */
- _Jv_Method *sm = _Jv_LookupDeclaredMethod (super_class,
- m->name,
- m->signature);
-
- /* if it was somehow declared in the superclass, skip this */
- if (sm != NULL)
- continue;
-
- /* but if it is final, and not declared in the super class,
- * then we also skip it */
- if ((m->accflags & FINAL) != 0)
- continue;
+ for (int j = 0; j < iface_class->interfaces[i]->method_count; ++j)
+ {
+ _Jv_Method *meth = &iface_class->interfaces[i]->methods[j];
+ // Don't bother with <clinit>.
+ if (meth->name->data[0] == '<')
+ continue;
+ _Jv_Method *new_meth = _Jv_LookupDeclaredMethod (base, meth->name,
+ meth->signature);
+ if (! new_meth)
+ {
+ // We assume that such methods are very unlikely, so we
+ // just reallocate the method array each time one is
+ // found. This greatly simplifies the searching --
+ // otherwise we have to make sure that each such method
+ // found is really unique among all superinterfaces.
+ 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);
+
+ // Add new method.
+ 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;
+
+ _Jv_MethodBase **new_im
+ = (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
+ * new_count);
+ memcpy (new_im, base->interpreted_methods,
+ sizeof (_Jv_MethodBase *) * base->method_count);
+
+ base->methods = new_m;
+ base->interpreted_methods = new_im;
+ base->method_count = new_count;
+ }
+ }
- /* finally, we can assign the index of this method */
- /* m->vtable_index = base_offset */
- base_offset += 1;
+ _Jv_PrepareMissingMethods (base, iface_class->interfaces[i]);
}
-
- return base_offset;
-}
-
-/* this is installed in place of abstract methods */
-static void
-_Jv_abstractMethodError ()
-{
- JvThrow (new java::lang::AbstractMethodError);
}
void
_Jv_PrepareClass(jclass klass)
{
+ using namespace java::lang::reflect;
+
/*
* The job of this function is to: 1) assign storage to fields, and 2)
* build the vtable. static fields are assigned real memory, instance
if (klass->state >= JV_STATE_PREPARED)
return;
- // make sure super-class is linked. This involves taking a lock on
- // the super class, so we use the Java method resolveClass, which will
- // unlock it properly, should an exception happen.
+ // Make sure super-class is linked. This involves taking a lock on
+ // the super class, so we use the Java method resolveClass, which
+ // will unlock it properly, should an exception happen. If there's
+ // no superclass, do nothing -- Object will already have been
+ // resolved.
- java::lang::ClassLoader::resolveClass0 (klass->superclass);
+ if (klass->superclass)
+ java::lang::VMClassLoader::resolveClass (klass->superclass);
_Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
/************ PART ONE: OBJECT LAYOUT ***************/
+ // Compute the alignment for this type by searching through the
+ // superclasses and finding the maximum required alignment. We
+ // could consider caching this in the Class.
+ int max_align = __alignof__ (java::lang::Object);
+ jclass super = clz->superclass;
+ while (super != NULL)
+ {
+ 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->superclass;
+ }
+
int instance_size;
- int static_size;
+ int static_size = 0;
- // java.lang.Object is never interpreted!
- instance_size = clz->superclass->size ();
- static_size = 0;
+ // Although java.lang.Object is never interpreted, an interface can
+ // have a null superclass. Note that we have to lay out an
+ // interface because it might have static fields.
+ if (clz->superclass)
+ instance_size = clz->superclass->size();
+ else
+ instance_size = java::lang::Object::class$.size();
for (int i = 0; i < clz->field_count; i++)
{
field->bsize = field_size;
#endif
- if (field->flags & STATIC)
+ if (field->flags & Modifier::STATIC)
{
/* this computes an offset into a region we'll allocate
shortly, and then add this offset to the start address */
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;
}
}
- // set the instance size for the class
+ // Set the instance size for the class. Note that first we round it
+ // to the alignment required for this object; this keeps us in sync
+ // with our current ABI.
+ instance_size = ROUND (instance_size, max_align);
clz->size_in_bytes = instance_size;
-
+
// allocate static memory
if (static_size != 0)
{
- char *static_data = (char*)_Jv_AllocBytesChecked (static_size);
+ char *static_data = (char*)_Jv_AllocBytes (static_size);
memset (static_data, 0, static_size);
{
_Jv_Field *field = &clz->fields[i];
- if ((field->flags & STATIC) != 0)
+ if ((field->flags & Modifier::STATIC) != 0)
{
field->u.addr = static_data + field->u.boffset;
have code -- for static constructors. */
for (int i = 0; i < clz->method_count; i++)
{
- _Jv_InterpMethod *imeth = clz->interpreted_methods[i];
+ _Jv_MethodBase *imeth = clz->interpreted_methods[i];
- if (imeth != 0) // it could be abstract or native
+ if ((clz->methods[i].accflags & Modifier::NATIVE) != 0)
{
- clz->methods[i].ncode = imeth->ncode ();
+ // You might think we could use a virtual `ncode' method in
+ // the _Jv_MethodBase and unify the native and non-native
+ // cases. Well, we can't, because we don't allocate these
+ // objects using `new', and thus they don't get a vtable.
+ _Jv_JNIMethod *jnim = reinterpret_cast<_Jv_JNIMethod *> (imeth);
+ clz->methods[i].ncode = jnim->ncode ();
}
- else
+ else if (imeth != 0) // it could be abstract
{
- if ((clz->methods[i].accflags & NATIVE) != 0)
+ _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
+ _Jv_VerifyMethod (im);
+ clz->methods[i].ncode = im->ncode ();
+
+ // Resolve ctable entries pointing to this method. See
+ // _Jv_Defer_Resolution.
+ void **code = (void **)imeth->deferred;
+ while (code)
{
- JvThrow
- (new java::lang::VirtualMachineError
- (JvNewStringLatin1
- ("the interpreter does not support native methods")));
+ void **target = (void **)*code;
+ *code = clz->methods[i].ncode;
+ code = target;
}
}
}
- if (clz->accflags & INTERFACE)
+ if ((clz->accflags & Modifier::INTERFACE))
{
clz->state = JV_STATE_PREPARED;
clz->notifyAll ();
return;
}
- /* FIXME: native methods for interpreted classes should be handled, I
- * dunno exactly how, but it seems that we should try to find them at
- * this point, and if we fail, try again after <clinit>, since it
- * could have caused additional code to be loaded. Interfaces cannot
- * have native methods (not even for static initialization). */
-
-
- /* Now onto the actual job: vtable layout. First, count how many new
- methods we have */
- int new_method_count = 0;
-
- jclass super_class = clz->getSuperclass ();
-
- if (super_class == 0)
- throw_internal_error ("cannot handle interpreted base classes");
-
- for (int i = 0; i < clz->method_count; i++)
- {
- _Jv_Method *this_meth = &clz->methods[i];
-
- if ((this_meth->accflags & (STATIC|PRIVATE)) != 0
- || _Jv_equalUtf8Consts (this_meth->name, init_name))
- {
- /* skip this, it doesn't go in the vtable */
- continue;
- }
-
- _Jv_Method *orig_meth = _Jv_LookupDeclaredMethod (super_class,
- this_meth->name,
- this_meth->signature);
-
- if (orig_meth == 0)
- {
- // new methods that are final, also don't go in the vtable
- if ((this_meth->accflags & FINAL) != 0)
- continue;
-
- new_method_count += 1;
- continue;
- }
-
- if ((orig_meth->accflags & (STATIC|PRIVATE|FINAL)) != 0
- || ((orig_meth->accflags & ABSTRACT) == 0
- && (this_meth->accflags & ABSTRACT) != 0
- && (klass->accflags & ABSTRACT) == 0))
- {
- clz->state = JV_STATE_ERROR;
- clz->notifyAll ();
- JvThrow (new java::lang::IncompatibleClassChangeError
- (clz->getName ()));
- }
-
- /* FIXME: At this point, if (loader != super_class->loader), we
- * need to "impose class loader constraints" for the types
- * involved in the signature of this method */
- }
-
- /* determine size */
- int vtable_count = (super_class->vtable_method_count) + new_method_count;
- clz->vtable_method_count = vtable_count;
-
- /* allocate vtable structure */
- _Jv_VTable *vtable = (_Jv_VTable*)
- _Jv_AllocBytesChecked (sizeof (_Jv_VTable)
- + (sizeof (void*) * (vtable_count)));
- vtable->clas = clz;
-
- /* copy super class' vtable entries (index 0 goes unused). */
- memcpy ((void*)&vtable->method[1],
- (void*)&super_class->vtable->method[1],
- sizeof (void*) * super_class->vtable_method_count);
-
- /* now, install our own vtable entries, reprise... */
- for (int i = 0; i < clz->method_count; i++)
- {
- _Jv_Method *this_meth = &clz->methods[i];
-
- int index = _Jv_DetermineVTableIndex (clz,
- this_meth->name,
- this_meth->signature);
+ // A class might have so-called "Miranda methods". This is a method
+ // that is declared in an interface and not re-declared in an
+ // abstract class. Some compilers don't emit declarations for such
+ // methods in the class; this will give us problems since we expect
+ // a declaration for any method requiring a vtable entry. We handle
+ // this here by searching for such methods and constructing new
+ // internal declarations for them. We only need to do this for
+ // abstract classes.
+ if ((clz->accflags & Modifier::ABSTRACT))
+ _Jv_PrepareMissingMethods (clz, clz);
- if (index == 0)
- throw_internal_error ("method now found in own class");
-
- if (index != -1)
- {
- if (index > clz->vtable_method_count+1)
- throw_internal_error ("vtable problem...");
-
- if (clz->interpreted_methods[i] == 0)
- vtable->method[index] = (void*)&_Jv_abstractMethodError;
- else
- vtable->method[index] = this_meth->ncode;
- }
- }
-
- /* finally, assign the vtable! */
- clz->vtable = vtable;
+ clz->vtable_method_count = -1;
+ _Jv_MakeVTable (clz);
/* wooha! we're done. */
clz->state = JV_STATE_PREPARED;
void
_Jv_InitField (jobject obj, jclass klass, int index)
{
+ using namespace java::lang::reflect;
+
if (obj != 0 && klass == 0)
klass = obj->getClass ();
if (! field->isResolved ())
throw_internal_error ("initializing unresolved field");
- if (obj==0 && ((field->flags & STATIC) == 0))
+ if (obj==0 && ((field->flags & Modifier::STATIC) == 0))
throw_internal_error ("initializing non-static field with no object");
void *addr = 0;
- if ((field->flags & STATIC) != 0)
+ if ((field->flags & Modifier::STATIC) != 0)
addr = (void*) field->u.addr;
else
addr = (void*) (((char*)obj) + field->u.boffset);
/* fall through */
case JV_CONSTANT_ResolvedString:
- if (! (field->type == &StringClass || field->type == &ObjectClass))
+ if (! (field->type == &StringClass
+ || field->type == &java::lang::Class::class$))
throw_class_format_error ("string initialiser to non-string field");
*(jstring*)addr = pool->data[init].string;
}
}
+template<typename T>
+struct aligner
+{
+ T field;
+};
+
+#define ALIGNOF(TYPE) (__alignof__ (((aligner<TYPE> *) 0)->field))
+
+// This returns the alignment of a type as it would appear in a
+// structure. This can be different from the alignment of the type
+// itself. For instance on x86 double is 8-aligned but struct{double}
+// is 4-aligned.
static int
get_alignment_from_class (jclass klass)
{
if (klass == JvPrimClass (byte))
- return __alignof__ (jbyte);
+ return ALIGNOF (jbyte);
else if (klass == JvPrimClass (short))
- return __alignof__ (jshort);
+ return ALIGNOF (jshort);
else if (klass == JvPrimClass (int))
- return __alignof__ (jint);
+ return ALIGNOF (jint);
else if (klass == JvPrimClass (long))
- return __alignof__ (jlong);
+ return ALIGNOF (jlong);
else if (klass == JvPrimClass (boolean))
- return __alignof__ (jboolean);
+ return ALIGNOF (jboolean);
else if (klass == JvPrimClass (char))
- return __alignof__ (jchar);
+ return ALIGNOF (jchar);
else if (klass == JvPrimClass (float))
- return __alignof__ (jfloat);
+ return ALIGNOF (jfloat);
else if (klass == JvPrimClass (double))
- return __alignof__ (jdouble);
+ return ALIGNOF (jdouble);
else
- return __alignof__ (jobject);
+ return ALIGNOF (jobject);
}
break;
case 'Z':
+ // On some platforms a bool is a byte, on others an int.
+ if (sizeof (jboolean) == sizeof (jbyte))
+ return &ffi_type_sint8;
+ else
+ {
+ JvAssert (sizeof (jbyte) == sizeof (jint));
+ return &ffi_type_sint32;
+ }
+ break;
+
case 'B':
return &ffi_type_sint8;
break;
* function is non-static, then one is added to the number of elements
* found in the signature */
-static int
-count_arguments (_Jv_Utf8Const *signature,
- jboolean staticp)
+int
+_Jv_count_arguments (_Jv_Utf8Const *signature,
+ jboolean staticp)
{
unsigned char *ptr = (unsigned char*) signature->data;
int arg_count = staticp ? 0 : 1;
int arg_count,
jboolean staticp,
ffi_cif *cif,
- ffi_type **arg_types)
+ ffi_type **arg_types,
+ ffi_type **rtype_p)
{
unsigned char *ptr = (unsigned char*) signature->data;
arg_count, rtype, arg_types) != FFI_OK)
throw_internal_error ("ffi_prep_cif failed");
+ if (rtype_p != NULL)
+ *rtype_p = rtype;
+
return item_count;
}
+#if FFI_NATIVE_RAW_API
+# define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure
+# define FFI_RAW_SIZE ffi_raw_size
+#else
+# define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure
+# define FFI_RAW_SIZE ffi_java_raw_size
+#endif
/* we put this one here, and not in interpret.cc because it
- * calls the utility routines count_arguments
+ * calls the utility routines _Jv_count_arguments
* which are static to this module. The following struct defines the
* layout we use for the stubs, it's only used in the ncode method. */
typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_raw*,void*);
-void* _Jv_InterpMethod::ncode ()
+void *
+_Jv_InterpMethod::ncode ()
{
+ using namespace java::lang::reflect;
+
if (self->ncode != 0)
return self->ncode;
- jboolean staticp = (self->accflags & STATIC) != 0;
- int arg_count = count_arguments (self->signature, staticp);
+ jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
+ int arg_count = _Jv_count_arguments (self->signature, staticp);
ncode_closure *closure =
- (ncode_closure*)_Jv_AllocBytesChecked (sizeof (ncode_closure)
+ (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
+ arg_count * sizeof (ffi_type*));
init_cif (self->signature,
arg_count,
staticp,
&closure->cif,
- &closure->arg_types[0]);
+ &closure->arg_types[0],
+ NULL);
ffi_closure_fun fun;
- args_raw_size = ffi_raw_size (&closure->cif);
+ args_raw_size = FFI_RAW_SIZE (&closure->cif);
- if ((self->accflags & SYNCHRONIZED) != 0)
+ JvAssert ((self->accflags & Modifier::NATIVE) == 0);
+
+ if ((self->accflags & Modifier::SYNCHRONIZED) != 0)
{
if (staticp)
fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class;
}
else
{
- fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal;
+ if (staticp)
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class;
+ else
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal;
}
- ffi_prep_raw_closure (&closure->closure,
- &closure->cif,
- fun,
- (void*)this);
+ FFI_PREP_RAW_CLOSURE (&closure->closure,
+ &closure->cif,
+ fun,
+ (void*)this);
self->ncode = (void*)closure;
return self->ncode;
}
+void *
+_Jv_JNIMethod::ncode ()
+{
+ using namespace java::lang::reflect;
+
+ if (self->ncode != 0)
+ return self->ncode;
+
+ jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
+ int arg_count = _Jv_count_arguments (self->signature, staticp);
+
+ ncode_closure *closure =
+ (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
+ + arg_count * sizeof (ffi_type*));
+
+ ffi_type *rtype;
+ init_cif (self->signature,
+ arg_count,
+ staticp,
+ &closure->cif,
+ &closure->arg_types[0],
+ &rtype);
+
+ ffi_closure_fun fun;
+
+ args_raw_size = FFI_RAW_SIZE (&closure->cif);
+
+ // Initialize the argument types and CIF that represent the actual
+ // underlying JNI function.
+ int extra_args = 1;
+ if ((self->accflags & Modifier::STATIC))
+ ++extra_args;
+ jni_arg_types = (ffi_type **) _Jv_Malloc ((extra_args + arg_count)
+ * sizeof (ffi_type *));
+ int offset = 0;
+ jni_arg_types[offset++] = &ffi_type_pointer;
+ if ((self->accflags & Modifier::STATIC))
+ jni_arg_types[offset++] = &ffi_type_pointer;
+ memcpy (&jni_arg_types[offset], &closure->arg_types[0],
+ arg_count * sizeof (ffi_type *));
+
+ if (ffi_prep_cif (&jni_cif, _Jv_platform_ffi_abi,
+ extra_args + arg_count, rtype,
+ jni_arg_types) != FFI_OK)
+ throw_internal_error ("ffi_prep_cif failed for JNI function");
+
+ JvAssert ((self->accflags & Modifier::NATIVE) != 0);
+
+ // FIXME: for now we assume that all native methods for
+ // interpreted code use JNI.
+ fun = (ffi_closure_fun) &_Jv_JNIMethod::call;
+
+ FFI_PREP_RAW_CLOSURE (&closure->closure,
+ &closure->cif,
+ fun,
+ (void*) this);
+
+ self->ncode = (void *) closure;
+ return self->ncode;
+}
+
/* A _Jv_ResolvedMethod is what is put in the constant pool for a
* MethodRef or InterfacemethodRef. */
jboolean staticp,
jint vtable_index)
{
- int arg_count = count_arguments (method->signature, staticp);
+ int arg_count = _Jv_count_arguments (method->signature, staticp);
_Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*)
- _Jv_AllocBytesChecked (sizeof (_Jv_ResolvedMethod)
- + arg_count*sizeof (ffi_type*));
+ _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod)
+ + arg_count*sizeof (ffi_type*));
result->stack_item_count
= init_cif (method->signature,
arg_count,
staticp,
&result->cif,
- &result->arg_types[0]);
+ &result->arg_types[0],
+ NULL);
result->vtable_index = vtable_index;
result->method = method;
static void
throw_class_format_error (jstring msg)
{
- if (msg == 0)
- JvThrow (new java::lang::ClassFormatError);
- else
- JvThrow (new java::lang::ClassFormatError (msg));
+ throw (msg
+ ? new java::lang::ClassFormatError (msg)
+ : new java::lang::ClassFormatError);
}
static void
static void
throw_internal_error (char *msg)
{
- JvThrow
- (new java::lang::InternalError (JvNewStringLatin1 (msg)));
+ throw new java::lang::InternalError (JvNewStringLatin1 (msg));
}
-#endif
+#endif /* INTERPRETER */
OSDN Git Service
