resolve.cc (_Jv_SearchMethodInClass): New function.
2000-03-07 Bryce McKinlay <bryce@albatross.co.nz>
* resolve.cc (_Jv_SearchMethodInClass): New function.
(_Jv_ResolvePoolEntry): Search superinterfaces for interface
methods.
* java/lang/Class.h (_Jv_SearchMethodInClass): New prototype.
2000-03-07 Bryce McKinlay <bryce@albatross.co.nz>
* java/lang/Class.h (union _Jv_IDispatchTable): New declaration.
(struct _Jv_ifaces): New declaration.
JV_CLASS: New macro definition.
(getComponentType): Relocate below isArray() for inlining.
(getModifiers): Declare `inline'.
(getSuperclass): Ditto.
(isArray): Ditto.
(isPrimitive): Ditto.
(_Jv_IsAssignableFrom): New prototype.
(_Jv_LookupInterfaceMethodIdx): New prototype. Predeclare with "C"
linkage.
(_Jv_InitClass): Move from natClass.cc. Declare `inline'.
Check for JV_STATE_DONE before invoking initializeClass().
(_Jv_PrepareConstantTimeTables): New prototype.
(_Jv_GetInterfaces): Ditto.
(_Jv_GenerateITable): Ditto.
(_Jv_GetMethodString): Ditto.
(_Jv_AppendPartialITable): Ditto.
(_Jv_FindIIndex): Ditto.
depth, ancestors, idt: New class fields.
* java/lang/natClass.cc (isAssignableFrom): Move functionality to
inline function `_Jv_IsAssignableFrom'. Use that function.
(isInstance): Declare `inline'.
(initializeClass): Get lock on class before checking `state'. Unlock
before calling resolveClass0. Call _Jv_PrepareConstantTimeTables
with the lock held.
(_Jv_LookupInterfaceMethod): Use _Jv_GetMessageString.
(_Jv_IsAssignableFrom): New inline function. Test assignability
using class->depth and ancestor table.
(_Jv_IsInstanceOf): Use _Jv_IsAssignableFrom.
(_Jv_CheckCast): Move from prims.cc. Use JV_CLASS and
_Jv_IsAssignableFrom.
(_Jv_CheckArrayStore): Ditto.
(_Jv_LookupInterfaceMethodIdx): New function.
INITIAL_IOFFSETS_LEN, INITIAL_IFACES_LEN: New #defines.
(_Jv_PrepareConstantTimeTables): New function.
(_Jv_IndexOf): Ditto.
(_Jv_GetInterfaces): Ditto.
(_Jv_GenerateITable): Ditto.
(_Jv_GetMethodString): Ditto.
(_Jv_AppendPartialITable): Ditto.
iindex_mutex, iindex_mutex_initialized: New static fields.
(_Jv_FindIIndex): New function.
* java/lang/natClassLoader.cc (_Jv_NewClass): Set new jclass fields.
* prims.cc (_Jv_CheckCast): Moved to natClass.cc.
(_Jv_CheckArrayStore): Ditto.
(JvNewCharArray, JvNewBooleanArray, JvNewByteArray, JvNewShortArray,
JvNewIntArray, JvNewLongArray, JvNewFloatArray, JvNewDoubleArray):
Moved to gcj/array.h.
(_Jv_Realloc): New function.
* gcj/cni.h: Move _Jv_PrimClass definitions to gcj/array.h.
* gcj/array.h: _Jv_PrimClass definitions moved from gcj/cni.h.
(JvNewCharArray, JvNewBooleanArray, JvNewByteArray,
JvNewShortArray, JvNewIntArray, JvNewLongArray, JvNewFloatArray,
JvNewDoubleArray): Implementations moved from prims.cc and
declared `inline'.
* gcj/javaprims.h (_Jv_Realloc): Prototype.
* include/jvm.h (_Jv_LookupInterfaceMethodIdx): Prototype.
From-SVN: r32382
This commit is contained in:
Bryce McKinlay
Bryce McKinlay
parent
173f556ccc
commit
ddf0fc6c9f
10 changed files with 776 additions and 228 deletions
|
|
@ -22,6 +22,10 @@ details. */
|
|||
extern "C" void _Jv_InitClass (jclass klass);
|
||||
extern "C" void _Jv_RegisterClasses (jclass *classes);
|
||||
|
||||
// This must be predefined with "C" linkage.
|
||||
extern "C" void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface,
|
||||
int meth_idx);
|
||||
|
||||
// These are the possible values for the `state' field of the class
|
||||
// structure. Note that ordering is important here. Whenever the
|
||||
// state changes, one should notify all waiters of this class.
|
||||
|
|
@ -60,13 +64,41 @@ struct _Jv_Method
|
|||
_Jv_Utf8Const *signature;
|
||||
_Jv_ushort accflags;
|
||||
void *ncode;
|
||||
|
||||
_Jv_Method *getNextMethod ()
|
||||
{ return this + 1; }
|
||||
};
|
||||
|
||||
// Interface Dispatch Tables
|
||||
union _Jv_IDispatchTable
|
||||
{
|
||||
struct
|
||||
{
|
||||
// Index into interface's ioffsets.
|
||||
jshort iindex;
|
||||
jshort itable_length;
|
||||
// Class Interface dispatch table.
|
||||
void **itable;
|
||||
} cls;
|
||||
|
||||
struct
|
||||
{
|
||||
// Offsets into implementation class itables.
|
||||
jshort *ioffsets;
|
||||
} iface;
|
||||
};
|
||||
|
||||
// Used by _Jv_GetInterfaces ()
|
||||
struct _Jv_ifaces
|
||||
{
|
||||
jclass *list;
|
||||
jshort len;
|
||||
jshort count;
|
||||
};
|
||||
|
||||
#define JV_PRIMITIVE_VTABLE ((_Jv_VTable *) -1)
|
||||
|
||||
#define JV_CLASS(Obj) ((jclass) (*(_Jv_VTable **) Obj)->clas)
|
||||
|
||||
class java::lang::Class : public java::lang::Object
|
||||
{
|
||||
public:
|
||||
|
|
@ -78,11 +110,6 @@ public:
|
|||
return loader;
|
||||
}
|
||||
|
||||
jclass getComponentType (void)
|
||||
{
|
||||
return isArray () ? (* (jclass *) &methods) : 0;
|
||||
}
|
||||
|
||||
java::lang::reflect::Constructor *getConstructor (JArray<jclass> *);
|
||||
JArray<java::lang::reflect::Constructor *> *getConstructors (void);
|
||||
java::lang::reflect::Constructor *getDeclaredConstructor (JArray<jclass> *);
|
||||
|
|
@ -112,7 +139,7 @@ public:
|
|||
java::lang::reflect::Method *getMethod (jstring, JArray<jclass> *);
|
||||
JArray<java::lang::reflect::Method *> *getMethods (void);
|
||||
|
||||
jint getModifiers (void)
|
||||
inline jint getModifiers (void)
|
||||
{
|
||||
return accflags;
|
||||
}
|
||||
|
|
@ -123,21 +150,26 @@ public:
|
|||
java::io::InputStream *getResourceAsStream (jstring resourceName);
|
||||
JArray<jobject> *getSigners (void);
|
||||
|
||||
jclass getSuperclass (void)
|
||||
inline jclass getSuperclass (void)
|
||||
{
|
||||
return superclass;
|
||||
}
|
||||
|
||||
jboolean isArray (void)
|
||||
inline jboolean isArray (void)
|
||||
{
|
||||
return name->data[0] == '[';
|
||||
}
|
||||
|
||||
inline jclass getComponentType (void)
|
||||
{
|
||||
return isArray () ? (* (jclass *) &methods) : 0;
|
||||
}
|
||||
|
||||
jboolean isAssignableFrom (jclass cls);
|
||||
jboolean isInstance (jobject obj);
|
||||
jboolean isInterface (void);
|
||||
|
||||
jboolean isPrimitive (void)
|
||||
|
||||
inline jboolean isPrimitive (void)
|
||||
{
|
||||
return vtable == JV_PRIMITIVE_VTABLE;
|
||||
}
|
||||
|
|
@ -150,11 +182,12 @@ public:
|
|||
{
|
||||
return size_in_bytes;
|
||||
}
|
||||
|
||||
|
||||
// finalization
|
||||
void finalize ();
|
||||
|
||||
private:
|
||||
private:
|
||||
|
||||
void checkMemberAccess (jint flags);
|
||||
|
||||
void initializeClass (void);
|
||||
|
|
@ -162,10 +195,19 @@ private:
|
|||
// Friend functions implemented in natClass.cc.
|
||||
friend _Jv_Method *_Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name,
|
||||
_Jv_Utf8Const *signature);
|
||||
friend jboolean _Jv_IsAssignableFrom(jclass, jclass);
|
||||
friend void *_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface,
|
||||
int method_idx);
|
||||
|
||||
inline friend void
|
||||
_Jv_InitClass (jclass klass)
|
||||
{
|
||||
if (klass->state != JV_STATE_DONE)
|
||||
klass->initializeClass ();
|
||||
}
|
||||
|
||||
friend _Jv_Method* _Jv_LookupDeclaredMethod (jclass, _Jv_Utf8Const *,
|
||||
_Jv_Utf8Const*);
|
||||
friend void _Jv_InitClass (jclass klass);
|
||||
|
||||
friend jfieldID JvGetFirstInstanceField (jclass);
|
||||
friend jint JvNumInstanceFields (jclass);
|
||||
friend jfieldID JvGetFirstStaticField (jclass);
|
||||
|
|
@ -205,6 +247,12 @@ private:
|
|||
java::lang::ClassLoader *loader);
|
||||
|
||||
friend void _Jv_PrepareCompiledClass (jclass);
|
||||
friend void _Jv_PrepareConstantTimeTables (jclass);
|
||||
friend jshort _Jv_GetInterfaces (jclass, _Jv_ifaces *);
|
||||
friend void _Jv_GenerateITable (jclass, _Jv_ifaces *, jshort *);
|
||||
friend jstring _Jv_GetMethodString(jclass, _Jv_Utf8Const *);
|
||||
friend jshort _Jv_AppendPartialITable (jclass, jclass, void **, jshort);
|
||||
friend jshort _Jv_FindIIndex (jclass *, jshort *, jshort);
|
||||
|
||||
#ifdef INTERPRETER
|
||||
friend jboolean _Jv_IsInterpretedClass (jclass);
|
||||
|
|
@ -213,6 +261,10 @@ private:
|
|||
_Jv_Utf8Const*);
|
||||
friend void _Jv_InitField (jobject, jclass, int);
|
||||
friend _Jv_word _Jv_ResolvePoolEntry (jclass, int);
|
||||
friend _Jv_Method *_Jv_SearchMethodInClass (jclass cls, jclass klass,
|
||||
_Jv_Utf8Const *method_name,
|
||||
_Jv_Utf8Const *method_signature);
|
||||
|
||||
friend void _Jv_PrepareClass (jclass);
|
||||
|
||||
friend class _Jv_ClassReader;
|
||||
|
|
@ -265,6 +317,12 @@ private:
|
|||
// The thread which has locked this class. Used during class
|
||||
// initialization.
|
||||
java::lang::Thread *thread;
|
||||
// How many levels of "extends" this class is removed from Object.
|
||||
jshort depth;
|
||||
// Vector of this class's superclasses, ordered by decreasing depth.
|
||||
jclass *ancestors;
|
||||
// Interface Dispatch Table.
|
||||
_Jv_IDispatchTable *idt;
|
||||
};
|
||||
|
||||
#endif /* __JAVA_LANG_CLASS_H__ */
|
||||
|
|
|
|||
|
|
@ -10,13 +10,15 @@ details. */
|
|||
|
||||
#include <config.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
#include <string.h>
|
||||
|
||||
#pragma implementation "Class.h"
|
||||
|
||||
#include <gcj/cni.h>
|
||||
#include <jvm.h>
|
||||
#include <java-threads.h>
|
||||
|
||||
#include <java/lang/Class.h>
|
||||
#include <java/lang/ClassLoader.h>
|
||||
#include <java/lang/String.h>
|
||||
|
|
@ -26,6 +28,8 @@ details. */
|
|||
#include <java/lang/reflect/Field.h>
|
||||
#include <java/lang/reflect/Constructor.h>
|
||||
#include <java/lang/AbstractMethodError.h>
|
||||
#include <java/lang/ArrayStoreException.h>
|
||||
#include <java/lang/ClassCastException.h>
|
||||
#include <java/lang/ClassNotFoundException.h>
|
||||
#include <java/lang/ExceptionInInitializerError.h>
|
||||
#include <java/lang/IllegalAccessException.h>
|
||||
|
|
@ -34,6 +38,7 @@ details. */
|
|||
#include <java/lang/InstantiationException.h>
|
||||
#include <java/lang/NoClassDefFoundError.h>
|
||||
#include <java/lang/NoSuchFieldException.h>
|
||||
#include <java/lang/NoSuchMethodError.h>
|
||||
#include <java/lang/NoSuchMethodException.h>
|
||||
#include <java/lang/Thread.h>
|
||||
#include <java/lang/NullPointerException.h>
|
||||
|
|
@ -608,40 +613,10 @@ java::lang::Class::getMethods (void)
|
|||
jboolean
|
||||
java::lang::Class::isAssignableFrom (jclass klass)
|
||||
{
|
||||
if (this == klass)
|
||||
return true;
|
||||
// Primitive types must be equal, which we just tested for.
|
||||
if (isPrimitive () || ! klass || klass->isPrimitive())
|
||||
return false;
|
||||
|
||||
// If target is array, so must source be.
|
||||
if (isArray ())
|
||||
{
|
||||
if (! klass->isArray())
|
||||
return false;
|
||||
return getComponentType()->isAssignableFrom(klass->getComponentType());
|
||||
}
|
||||
|
||||
if (isAssignableFrom (klass->getSuperclass()))
|
||||
return true;
|
||||
|
||||
if (isInterface())
|
||||
{
|
||||
// See if source implements this interface.
|
||||
for (int i = 0; i < klass->interface_count; ++i)
|
||||
{
|
||||
jclass interface = klass->interfaces[i];
|
||||
// FIXME: ensure that class is prepared here.
|
||||
// See Spec 12.3.2.
|
||||
if (isAssignableFrom (interface))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
return _Jv_IsAssignableFrom (this, klass);
|
||||
}
|
||||
|
||||
jboolean
|
||||
inline jboolean
|
||||
java::lang::Class::isInstance (jobject obj)
|
||||
{
|
||||
if (! obj || isPrimitive ())
|
||||
|
|
@ -649,7 +624,7 @@ java::lang::Class::isInstance (jobject obj)
|
|||
return isAssignableFrom (obj->getClass());
|
||||
}
|
||||
|
||||
jboolean
|
||||
inline jboolean
|
||||
java::lang::Class::isInterface (void)
|
||||
{
|
||||
return (accflags & java::lang::reflect::Modifier::INTERFACE) != 0;
|
||||
|
|
@ -696,36 +671,32 @@ java::lang::Class::finalize (void)
|
|||
void
|
||||
java::lang::Class::initializeClass (void)
|
||||
{
|
||||
// Short-circuit to avoid needless locking.
|
||||
// jshort-circuit to avoid needless locking.
|
||||
if (state == JV_STATE_DONE)
|
||||
return;
|
||||
|
||||
// do this before we enter the monitor below, since this can cause
|
||||
// exceptions. Here we assume, that reading "state" is an atomic
|
||||
// operation, I pressume that is true? --Kresten
|
||||
// Step 1.
|
||||
_Jv_MonitorEnter (this);
|
||||
|
||||
if (state < JV_STATE_LINKED)
|
||||
{
|
||||
{
|
||||
#ifdef INTERPRETER
|
||||
if (_Jv_IsInterpretedClass (this))
|
||||
{
|
||||
// this can throw exceptions, so exit the monitor as a precaution.
|
||||
_Jv_MonitorExit (this);
|
||||
java::lang::ClassLoader::resolveClass0 (this);
|
||||
|
||||
// Step 1.
|
||||
_Jv_MonitorEnter (this);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
// Step 1.
|
||||
_Jv_MonitorEnter (this);
|
||||
_Jv_PrepareCompiledClass (this);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Step 1.
|
||||
_Jv_MonitorEnter (this);
|
||||
}
|
||||
|
||||
if (state <= JV_STATE_LINKED)
|
||||
_Jv_PrepareConstantTimeTables (this);
|
||||
|
||||
// Step 2.
|
||||
java::lang::Thread *self = java::lang::Thread::currentThread();
|
||||
|
|
@ -828,14 +799,14 @@ _Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name,
|
|||
|
||||
_Jv_Method *
|
||||
_Jv_LookupDeclaredMethod (jclass klass, _Jv_Utf8Const *name,
|
||||
_Jv_Utf8Const *signature)
|
||||
_Jv_Utf8Const *signature)
|
||||
{
|
||||
for (; klass; klass = klass->getSuperclass())
|
||||
{
|
||||
_Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature);
|
||||
|
||||
if (meth)
|
||||
return meth;
|
||||
return meth;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
|
@ -854,15 +825,15 @@ static _Jv_mcache method_cache[MCACHE_SIZE + 1];
|
|||
|
||||
static void *
|
||||
_Jv_FindMethodInCache (jclass klass,
|
||||
_Jv_Utf8Const *name,
|
||||
_Jv_Utf8Const *signature)
|
||||
_Jv_Utf8Const *name,
|
||||
_Jv_Utf8Const *signature)
|
||||
{
|
||||
int index = name->hash & MCACHE_SIZE;
|
||||
_Jv_mcache *mc = method_cache + index;
|
||||
_Jv_Method *m = mc->method;
|
||||
|
||||
if (mc->klass == klass
|
||||
&& m != NULL // thread safe check
|
||||
&& m != NULL // thread safe check
|
||||
&& _Jv_equalUtf8Consts (m->name, name)
|
||||
&& _Jv_equalUtf8Consts (m->signature, signature))
|
||||
return mc->method->ncode;
|
||||
|
|
@ -871,7 +842,7 @@ _Jv_FindMethodInCache (jclass klass,
|
|||
|
||||
static void
|
||||
_Jv_AddMethodToCache (jclass klass,
|
||||
_Jv_Method *method)
|
||||
_Jv_Method *method)
|
||||
{
|
||||
_Jv_MonitorEnter (&ClassClass);
|
||||
|
||||
|
|
@ -885,8 +856,10 @@ _Jv_AddMethodToCache (jclass klass,
|
|||
|
||||
void *
|
||||
_Jv_LookupInterfaceMethod (jclass klass, _Jv_Utf8Const *name,
|
||||
_Jv_Utf8Const *signature)
|
||||
_Jv_Utf8Const *signature)
|
||||
{
|
||||
using namespace java::lang::reflect;
|
||||
|
||||
void *ncode = _Jv_FindMethodInCache (klass, name, signature);
|
||||
if (ncode != 0)
|
||||
return ncode;
|
||||
|
|
@ -895,31 +868,432 @@ _Jv_LookupInterfaceMethod (jclass klass, _Jv_Utf8Const *name,
|
|||
{
|
||||
_Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature);
|
||||
if (! meth)
|
||||
continue;
|
||||
continue;
|
||||
|
||||
if (java::lang::reflect::Modifier::isStatic(meth->accflags))
|
||||
JvThrow (new java::lang::IncompatibleClassChangeError);
|
||||
if (java::lang::reflect::Modifier::isAbstract(meth->accflags))
|
||||
JvThrow (new java::lang::AbstractMethodError);
|
||||
if (! java::lang::reflect::Modifier::isPublic(meth->accflags))
|
||||
JvThrow (new java::lang::IllegalAccessError);
|
||||
if (Modifier::isStatic(meth->accflags))
|
||||
JvThrow (new java::lang::IncompatibleClassChangeError
|
||||
(_Jv_GetMethodString (klass, meth->name)));
|
||||
if (Modifier::isAbstract(meth->accflags))
|
||||
JvThrow (new java::lang::AbstractMethodError
|
||||
(_Jv_GetMethodString (klass, meth->name)));
|
||||
if (! Modifier::isPublic(meth->accflags))
|
||||
JvThrow (new java::lang::IllegalAccessError
|
||||
(_Jv_GetMethodString (klass, meth->name)));
|
||||
|
||||
_Jv_AddMethodToCache (klass, meth);
|
||||
|
||||
return meth->ncode;
|
||||
}
|
||||
JvThrow (new java::lang::IncompatibleClassChangeError);
|
||||
return NULL; // Placate compiler.
|
||||
return NULL; // Placate compiler.
|
||||
}
|
||||
|
||||
void
|
||||
_Jv_InitClass (jclass klass)
|
||||
// Fast interface method lookup by index.
|
||||
void *
|
||||
_Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface, int method_idx)
|
||||
{
|
||||
klass->initializeClass();
|
||||
_Jv_IDispatchTable *cldt = klass->idt;
|
||||
int idx = iface->idt->iface.ioffsets[cldt->cls.iindex] + method_idx;
|
||||
return cldt->cls.itable[idx];
|
||||
}
|
||||
|
||||
inline jboolean
|
||||
_Jv_IsAssignableFrom (jclass target, jclass source)
|
||||
{
|
||||
if (target == &ObjectClass
|
||||
|| source == target
|
||||
|| (source->ancestors != NULL
|
||||
&& source->ancestors[source->depth - target->depth] == target))
|
||||
return true;
|
||||
|
||||
// If target is array, so must source be.
|
||||
if (target->isArray ())
|
||||
{
|
||||
if (! source->isArray())
|
||||
return false;
|
||||
return _Jv_IsAssignableFrom(target->getComponentType(),
|
||||
source->getComponentType());
|
||||
}
|
||||
|
||||
if (target->isInterface())
|
||||
{
|
||||
_Jv_IDispatchTable *cl_idt = source->idt;
|
||||
_Jv_IDispatchTable *if_idt = target->idt;
|
||||
jshort cl_iindex = cl_idt->cls.iindex;
|
||||
if (cl_iindex <= if_idt->iface.ioffsets[0])
|
||||
{
|
||||
jshort offset = if_idt->iface.ioffsets[cl_iindex];
|
||||
if (offset < cl_idt->cls.itable_length
|
||||
&& cl_idt->cls.itable[offset] == target)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
jboolean
|
||||
_Jv_IsInstanceOf(jobject obj, jclass cl)
|
||||
{
|
||||
return cl->isInstance(obj);
|
||||
return (obj ? _Jv_IsAssignableFrom (cl, JV_CLASS (obj)) : false);
|
||||
}
|
||||
|
||||
void *
|
||||
_Jv_CheckCast (jclass c, jobject obj)
|
||||
{
|
||||
if (obj != NULL && ! _Jv_IsAssignableFrom(c, JV_CLASS (obj)))
|
||||
JvThrow (new java::lang::ClassCastException);
|
||||
return obj;
|
||||
}
|
||||
|
||||
void
|
||||
_Jv_CheckArrayStore (jobject arr, jobject obj)
|
||||
{
|
||||
if (obj)
|
||||
{
|
||||
JvAssert (arr != NULL);
|
||||
jclass elt_class = (JV_CLASS (arr))->getComponentType();
|
||||
jclass obj_class = JV_CLASS (obj);
|
||||
if (! _Jv_IsAssignableFrom (elt_class, obj_class))
|
||||
JvThrow (new java::lang::ArrayStoreException);
|
||||
}
|
||||
}
|
||||
|
||||
#define INITIAL_IOFFSETS_LEN 4
|
||||
#define INITIAL_IFACES_LEN 4
|
||||
|
||||
// Generate tables for constant-time assignment testing and interface
|
||||
// method lookup. This implements the technique described by Per Bothner
|
||||
// <per@bothner.com> on the java-discuss mailing list on 1999-09-02:
|
||||
// http://sourceware.cygnus.com/ml/java-discuss/1999-q3/msg00377.html
|
||||
void
|
||||
_Jv_PrepareConstantTimeTables (jclass klass)
|
||||
{
|
||||
if (klass->isPrimitive () || klass->isInterface ())
|
||||
return;
|
||||
|
||||
// Short-circuit in case we've been called already.
|
||||
if ((klass->idt != NULL) || klass->depth != 0)
|
||||
return;
|
||||
|
||||
// Calculate the class depth and ancestor table. The depth of a class
|
||||
// is how many "extends" it is removed from Object. Thus the depth of
|
||||
// java.lang.Object is 0, but the depth of java.io.FilterOutputStream
|
||||
// is 2. Depth is defined for all regular and array classes, but not
|
||||
// interfaces or primitive types.
|
||||
|
||||
jclass klass0 = klass;
|
||||
while (klass0 != &ObjectClass)
|
||||
{
|
||||
klass0 = klass0->superclass;
|
||||
klass->depth++;
|
||||
}
|
||||
|
||||
// We do class member testing in constant time by using a small table
|
||||
// of all the ancestor classes within each class. The first element is
|
||||
// a pointer to the current class, and the rest are pointers to the
|
||||
// classes ancestors, ordered from the current class down by decreasing
|
||||
// depth. We do not include java.lang.Object in the table of ancestors,
|
||||
// since it is redundant.
|
||||
|
||||
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->isArray ()
|
||||
|| java::lang::reflect::Modifier::isAbstract (klass->accflags))
|
||||
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 = _Jv_GetInterfaces (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));
|
||||
|
||||
_Jv_GenerateITable (klass, &ifaces, itable_offsets);
|
||||
|
||||
jshort cls_iindex =
|
||||
_Jv_FindIIndex (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;
|
||||
}
|
||||
}
|
||||
|
||||
// Return index of item in list, or -1 if item is not present.
|
||||
jshort
|
||||
_Jv_IndexOf (void *item, void **list, jshort list_len)
|
||||
{
|
||||
for (int i=0; i < list_len; i++)
|
||||
{
|
||||
if (list[i] == item)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Find all unique interfaces directly or indirectly implemented by klass.
|
||||
// Returns the size of the interface dispatch table (itable) for klass, which
|
||||
// is the number of unique interfaces plus the total number of methods that
|
||||
// those interfaces declare. May extend ifaces if required.
|
||||
jshort
|
||||
_Jv_GetInterfaces (jclass klass, _Jv_ifaces *ifaces)
|
||||
{
|
||||
jshort result = 0;
|
||||
|
||||
for (int i=0; i < klass->interface_count; i++)
|
||||
{
|
||||
jclass iface = klass->interfaces[i];
|
||||
if (_Jv_IndexOf (iface, (void **) ifaces->list, ifaces->count) == -1)
|
||||
{
|
||||
if (ifaces->count + 1 >= ifaces->len)
|
||||
{
|
||||
/* Resize ifaces list */
|
||||
ifaces->len = ifaces->len * 2;
|
||||
ifaces->list = (jclass *) _Jv_Realloc (ifaces->list,
|
||||
ifaces->len * sizeof(jclass));
|
||||
}
|
||||
ifaces->list[ifaces->count] = iface;
|
||||
ifaces->count++;
|
||||
|
||||
result += _Jv_GetInterfaces (klass->interfaces[i], ifaces);
|
||||
}
|
||||
}
|
||||
|
||||
if (klass->isInterface())
|
||||
{
|
||||
result += klass->method_count + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (klass->superclass)
|
||||
{
|
||||
result += _Jv_GetInterfaces (klass->superclass, ifaces);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Fill out itable in klass, resolving method declarations in each ifaces.
|
||||
// itable_offsets is filled out with the position of each iface in itable,
|
||||
// such that itable[itable_offsets[n]] == ifaces.list[n].
|
||||
void
|
||||
_Jv_GenerateITable (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 = _Jv_AppendPartialITable (klass, iface, itable,
|
||||
itable_pos);
|
||||
|
||||
/* Create interface dispatch table for iface */
|
||||
if (iface->idt == NULL)
|
||||
{
|
||||
iface->idt =
|
||||
(_Jv_IDispatchTable *) _Jv_Malloc (sizeof (_Jv_IDispatchTable));
|
||||
|
||||
// The first element of ioffsets is its length (itself included).
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Format method name for use in error messages.
|
||||
jstring
|
||||
_Jv_GetMethodString (jclass klass, _Jv_Utf8Const *name)
|
||||
{
|
||||
jstring r = JvNewStringUTF (klass->name->data);
|
||||
r = r->concat (JvNewStringUTF ("."));
|
||||
r = r->concat (JvNewStringUTF (name->data));
|
||||
return r;
|
||||
}
|
||||
|
||||
void
|
||||
_Jv_ThrowNoSuchMethodError ()
|
||||
{
|
||||
JvThrow (new java::lang::NoSuchMethodError ());
|
||||
}
|
||||
|
||||
// Each superinterface of a class (i.e. each interface that the class
|
||||
// directly or indirectly implements) has a corresponding "Partial
|
||||
// Interface Dispatch Table" whose size is (number of methods + 1) words.
|
||||
// The first word is a pointer to the interface (i.e. the java.lang.Class
|
||||
// instance for that interface). The remaining words are pointers to the
|
||||
// actual methods that implement the methods declared in the interface,
|
||||
// in order of declaration.
|
||||
//
|
||||
// Append partial interface dispatch table for "iface" to "itable", at
|
||||
// position itable_pos.
|
||||
// Returns the offset at which the next partial ITable should be appended.
|
||||
jshort
|
||||
_Jv_AppendPartialITable (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->data[0] == '<'))
|
||||
{
|
||||
// leave a placeholder in the itable for hidden init methods.
|
||||
itable[pos] = NULL;
|
||||
}
|
||||
else if (meth)
|
||||
{
|
||||
if (Modifier::isStatic(meth->accflags))
|
||||
JvThrow (new java::lang::IncompatibleClassChangeError
|
||||
(_Jv_GetMethodString (klass, meth->name)));
|
||||
if (Modifier::isAbstract(meth->accflags))
|
||||
JvThrow (new java::lang::AbstractMethodError
|
||||
(_Jv_GetMethodString (klass, meth->name)));
|
||||
if (! Modifier::isPublic(meth->accflags))
|
||||
JvThrow (new java::lang::IllegalAccessError
|
||||
(_Jv_GetMethodString (klass, meth->name)));
|
||||
|
||||
itable[pos] = meth->ncode;
|
||||
}
|
||||
else
|
||||
{
|
||||
// The method doesn't exist in klass. Binary compatibility rules
|
||||
// permit this, so we delay the error until runtime using a pointer
|
||||
// to a method which throws an exception.
|
||||
itable[pos] = (void *) _Jv_ThrowNoSuchMethodError;
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
|
||||
return pos;
|
||||
}
|
||||
|
||||
static _Jv_Mutex_t iindex_mutex;
|
||||
bool iindex_mutex_initialized = false;
|
||||
|
||||
// We need to find the correct offset in the Class Interface Dispatch
|
||||
// Table for a given interface. Once we have that, invoking an interface
|
||||
// method just requires combining the Method's index in the interface
|
||||
// (known at compile time) to get the correct method. Doing a type test
|
||||
// (cast or instanceof) is the same problem: Once we have a possible Partial
|
||||
// Interface Dispatch Table, we just compare the first element to see if it
|
||||
// matches the desired interface. So how can we find the correct offset?
|
||||
// Our solution is to keep a vector of candiate offsets in each interface
|
||||
// (idt->iface.ioffsets), and in each class we have an index
|
||||
// (idt->cls.iindex) used to select the correct offset from ioffsets.
|
||||
//
|
||||
// Calculate and return iindex for a new class.
|
||||
// ifaces is a vector of num interfaces that the class implements.
|
||||
// offsets[j] is the offset in the interface dispatch table for the
|
||||
// interface corresponding to ifaces[j].
|
||||
// May extend the interface ioffsets if required.
|
||||
jshort
|
||||
_Jv_FindIIndex (jclass *ifaces, jshort *offsets, jshort num)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
|
||||
// Acquire a global lock to prevent itable corruption in case of multiple
|
||||
// classes that implement an intersecting set of interfaces being linked
|
||||
// simultaneously. We can assume that the mutex will be initialized
|
||||
// single-threaded.
|
||||
if (! iindex_mutex_initialized)
|
||||
{
|
||||
_Jv_MutexInit (&iindex_mutex);
|
||||
iindex_mutex_initialized = true;
|
||||
}
|
||||
|
||||
_Jv_MutexLock (&iindex_mutex);
|
||||
|
||||
for (i=1;; i++) /* each potential position in ioffsets */
|
||||
{
|
||||
for (j=0;; j++) /* each iface */
|
||||
{
|
||||
if (j >= num)
|
||||
goto found;
|
||||
if (i > ifaces[j]->idt->iface.ioffsets[0])
|
||||
continue;
|
||||
int ioffset = ifaces[j]->idt->iface.ioffsets[i];
|
||||
/* We can potentially share this position with another class. */
|
||||
if (ioffset >= 0 && ioffset != offsets[j])
|
||||
break; /* Nope. Try next i. */
|
||||
}
|
||||
}
|
||||
found:
|
||||
for (j = 0; j < num; j++)
|
||||
{
|
||||
int len = ifaces[j]->idt->iface.ioffsets[0];
|
||||
if (i >= len)
|
||||
{
|
||||
/* Resize ioffsets. */
|
||||
int newlen = 2 * len;
|
||||
if (i >= newlen)
|
||||
newlen = i + 3;
|
||||
jshort *old_ioffsets = ifaces[j]->idt->iface.ioffsets;
|
||||
jshort *new_ioffsets = (jshort *) _Jv_Realloc (old_ioffsets,
|
||||
newlen * 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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -503,6 +503,9 @@ _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
|
|||
ret->interface_count = 0;
|
||||
ret->state = JV_STATE_NOTHING;
|
||||
ret->thread = NULL;
|
||||
ret->depth = 0;
|
||||
ret->ancestors = NULL;
|
||||
ret->idt = NULL;
|
||||
|
||||
_Jv_RegisterClass (ret);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue