mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-11 03:50:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

class.c (make_class_data): Add new field aux_info.

Browse Source 
2004-04-19  Bryce McKinlay  <mckinlay@redhat.com>

	* class.c (make_class_data): Add new field aux_info.
	* decl.c (java_init_decl_processing): Push type and decl for
	`aux_info'.

2004-04-19  Bryce McKinlay  <mckinlay@redhat.com>

	* gcj/cni.h (JvAllocObject): Remove these obsolete,
	undocumented CNI calls.
	* include/java-interp.h (_Jv_InterpClass): No longer
	extends java.lang.Class.
	* java/lang/Class.h (Class): Add new field `aux_info'.
	* boehm.cc (_Jv_MarkObj): Update java.lang.Class marking.
	* defineclass.cc: Remove Class<->_Jv_InterpClass casts.
	Use Class->aux_info instead.
	* jni.cc (_Jv_JNI_AllocObject): Use _Jv_AllocObject.
	* resolve.cc: Remove Class<->_Jv_InterpClass casts.
	Use Class->aux_info instead.
	* java/io/natObjectInputStream.cc (allocateObject): Use
	_Jv_AllocObject.
	* java/lang/natClass.cc (newInstance): Likewise.
	* java/lang/natClassLoader.cc (_Jv_NewClass): Likewise.
	* java/lang/natObject.cc (clone): Likewise.
	* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Likewise.
	* java/lang/natVMClassLoader.cc (defineClass): Don't use
	JvAllocObject. Allocate klass->aux_info here for interpreted
	class.

From-SVN: r80875
This commit is contained in:
Bryce McKinlay 2004-04-20 01:38:46 +00:00 committed by Bryce McKinlay
parent 712faa50dd
commit f531010820
17 changed files with 113 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gcc/java/ChangeLog
View File

@ -1,3 +1,9 @@
2004-04-19 Bryce McKinlay <mckinlay@redhat.com>
* class.c (make_class_data): Add new field aux_info.
* decl.c (java_init_decl_processing): Push type and decl for
`aux_info'.
2004-04-15 Bryce McKinlay <mckinlay@redhat.com>
* expr.c (expand_java_NEW): Don't use size argument for

1
gcc/java/class.c
View File

@ -1723,6 +1723,7 @@ make_class_data (tree type)
PUSH_FIELD_VALUE (cons, "protectionDomain", null_pointer_node);
PUSH_FIELD_VALUE (cons, "hack_signers", null_pointer_node);
PUSH_FIELD_VALUE (cons, "chain", null_pointer_node);
PUSH_FIELD_VALUE (cons, "aux_info", null_pointer_node);
FINISH_RECORD_CONSTRUCTOR (cons);

1
gcc/java/decl.c
View File

@ -690,6 +690,7 @@ java_init_decl_processing (void)
PUSH_FIELD (class_type_node, field, "protectionDomain", ptr_type_node);
PUSH_FIELD (class_type_node, field, "hack_signers", ptr_type_node);
PUSH_FIELD (class_type_node, field, "chain", ptr_type_node);
PUSH_FIELD (class_type_node, field, "aux_info", ptr_type_node);
for (t = TYPE_FIELDS (class_type_node); t != NULL_TREE; t = TREE_CHAIN (t))
FIELD_PRIVATE (t) = 1;
push_super_field (class_type_node, object_type_node);

23
libjava/ChangeLog
View File

@ -1,3 +1,26 @@
2004-04-19 Bryce McKinlay <mckinlay@redhat.com>
* gcj/cni.h (JvAllocObject): Remove these obsolete,
undocumented CNI calls.
* include/java-interp.h (_Jv_InterpClass): No longer
extends java.lang.Class.
* java/lang/Class.h (Class): Add new field `aux_info'.
* boehm.cc (_Jv_MarkObj): Update java.lang.Class marking.
* defineclass.cc: Remove Class<->_Jv_InterpClass casts.
Use Class->aux_info instead.
* jni.cc (_Jv_JNI_AllocObject): Use _Jv_AllocObject.
* resolve.cc: Remove Class<->_Jv_InterpClass casts.
Use Class->aux_info instead.
* java/io/natObjectInputStream.cc (allocateObject): Use
_Jv_AllocObject.
* java/lang/natClass.cc (newInstance): Likewise.
* java/lang/natClassLoader.cc (_Jv_NewClass): Likewise.
* java/lang/natObject.cc (clone): Likewise.
* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Likewise.
* java/lang/natVMClassLoader.cc (defineClass): Don't use
JvAllocObject. Allocate klass->aux_info here for interpreted
class.
2004-04-17 Mark Wielaard <mark@klomp.org>
* javax/swing/JToggleButton.java (ToggleButtonModel):

4
libjava/boehm.cc
View File

@ -208,11 +208,13 @@ _Jv_MarkObj (void *addr, void *msp, void *msl, void * /* env */)
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cPlabel);
p = (ptr_t) c->hack_signers;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cSlabel);
p = (ptr_t) c->aux_info;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, c, cTlabel);
#ifdef INTERPRETER
if (_Jv_IsInterpretedClass (c))
{
_Jv_InterpClass* ic = (_Jv_InterpClass*) c;
_Jv_InterpClass* ic = (_Jv_InterpClass*) c->aux_info;
p = (ptr_t) ic->interpreted_methods;
MAYBE_MARK (p, mark_stack_ptr, mark_stack_limit, ic, cElabel);

32
libjava/defineclass.cc
View File

@ -96,7 +96,10 @@ struct _Jv_ClassReader {
unsigned int *offsets;
// the class to define (see java-interp.h)
_Jv_InterpClass *def;
jclass def;
// the classes associated interpreter data.
_Jv_InterpClass *def_interp;
/* check that the given number of input bytes are available */
inline void check (int num)
@ -221,7 +224,8 @@ struct _Jv_ClassReader {
bytes = (unsigned char*) (elements (data)+offset);
len = length;
pos = 0;
def = (_Jv_InterpClass*) klass;
def = klass;
def_interp = (_Jv_InterpClass *) def->aux_info;
}
/** and here goes the parser members defined out-of-line */
@ -1047,10 +1051,10 @@ void _Jv_ClassReader::handleFieldsBegin (int count)
def->fields = (_Jv_Field*)
_Jv_AllocBytes (count * sizeof (_Jv_Field));
def->field_count = count;
def->field_initializers = (_Jv_ushort*)
def_interp->field_initializers = (_Jv_ushort*)
_Jv_AllocBytes (count * sizeof (_Jv_ushort));
for (int i = 0; i < count; i++)
def->field_initializers[i] = (_Jv_ushort) 0;
def_interp->field_initializers[i] = (_Jv_ushort) 0;
}
void _Jv_ClassReader::handleField (int field_no,
@ -1133,7 +1137,7 @@ void _Jv_ClassReader::handleConstantValueAttribute (int field_index,
throw_class_format_error ("field has multiple ConstantValue attributes");
field->flags |= _Jv_FIELD_CONSTANT_VALUE;
def->field_initializers[field_index] = value;
def_interp->field_initializers[field_index] = value;
/* type check the initializer */
@ -1153,7 +1157,7 @@ void _Jv_ClassReader::handleFieldsEnd ()
int low = 0;
int high = def->field_count-1;
_Jv_Field *fields = def->fields;
_Jv_ushort *inits = def->field_initializers;
_Jv_ushort *inits = def_interp->field_initializers;
// this is kind of a raw version of quicksort.
while (low < high)
@ -1195,13 +1199,13 @@ _Jv_ClassReader::handleMethodsBegin (int count)
{
def->methods = (_Jv_Method *) _Jv_AllocBytes (sizeof (_Jv_Method) * count);
def->interpreted_methods
def_interp->interpreted_methods
= (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
* count);
for (int i = 0; i < count; i++)
{
def->interpreted_methods[i] = 0;
def_interp->interpreted_methods[i] = 0;
def->methods[i].index = (_Jv_ushort) -1;
}
@ -1284,7 +1288,7 @@ void _Jv_ClassReader::handleCodeAttribute
(void*) (bytes+code_start),
code_length);
def->interpreted_methods[method_index] = method;
def_interp->interpreted_methods[method_index] = method;
if ((method->self->accflags & java::lang::reflect::Modifier::STATIC))
{
@ -1301,7 +1305,7 @@ void _Jv_ClassReader::handleExceptionTableEntry
int start_pc, int end_pc, int handler_pc, int catch_type)
{
_Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
(def->interpreted_methods[method_index]);
(def_interp->interpreted_methods[method_index]);
_Jv_InterpException *exc = method->exceptions ();
exc[exc_index].start_pc.i = start_pc;
@ -1319,7 +1323,7 @@ void _Jv_ClassReader::handleMethodsEnd ()
_Jv_Method *method = &def->methods[i];
if ((method->accflags & Modifier::NATIVE) != 0)
{
if (def->interpreted_methods[i] != 0)
if (def_interp->interpreted_methods[i] != 0)
throw_class_format_error ("code provided for native method");
else
{
@ -1328,7 +1332,7 @@ void _Jv_ClassReader::handleMethodsEnd ()
m->defining_class = def;
m->self = method;
m->function = NULL;
def->interpreted_methods[i] = m;
def_interp->interpreted_methods[i] = m;
m->deferred = NULL;
if ((method->accflags & Modifier::STATIC))
@ -1344,12 +1348,12 @@ void _Jv_ClassReader::handleMethodsEnd ()
}
else if ((method->accflags & Modifier::ABSTRACT) != 0)
{
if (def->interpreted_methods[i] != 0)
if (def_interp->interpreted_methods[i] != 0)
throw_class_format_error ("code provided for abstract method");
}
else
{
if (def->interpreted_methods[i] == 0)
if (def_interp->interpreted_methods[i] == 0)
throw_class_format_error ("method with no code");
}
}

12
libjava/gcj/cni.h
View File

@ -20,18 +20,6 @@ details. */
#include <string.h>
extern inline jobject
JvAllocObject (jclass cls)
{
return _Jv_AllocObject (cls);
}
extern inline jobject
JvAllocObject (jclass cls, jsize sz)
{
return _Jv_AllocObject (cls);
}
extern "C" jstring _Jv_NewStringUTF (const char *bytes);
extern "C" void _Jv_InitClass (jclass);

12
libjava/include/java-interp.h
View File

@ -22,7 +22,6 @@ details. */
#include <java/lang/Class.h>
#include <java/lang/ClassLoader.h>
#include <java/lang/reflect/Modifier.h>
#include <gnu/gcj/runtime/StackTrace.h>
extern "C" {
#include <ffi.h>
@ -80,7 +79,7 @@ class _Jv_MethodBase
{
protected:
// The class which defined this method.
_Jv_InterpClass *defining_class;
jclass defining_class;
// The method description.
_Jv_Method *self;
@ -150,6 +149,7 @@ class _Jv_InterpMethod : public _Jv_MethodBase
friend class _Jv_BytecodeVerifier;
friend class gnu::gcj::runtime::NameFinder;
friend class gnu::gcj::runtime::StackTrace;
friend void _Jv_PrepareClass(jclass);
@ -158,7 +158,7 @@ class _Jv_InterpMethod : public _Jv_MethodBase
#endif
};
class _Jv_InterpClass : public java::lang::Class
class _Jv_InterpClass
{
_Jv_MethodBase **interpreted_methods;
_Jv_ushort *field_initializers;
@ -185,13 +185,15 @@ extern inline void
_Jv_Defer_Resolution (void *cl, _Jv_Method *meth, void **address)
{
int i;
_Jv_InterpClass *self = (_Jv_InterpClass *)cl;
jclass self = (jclass) cl;
_Jv_InterpClass *interp_cl = (_Jv_InterpClass*) self->aux_info;
for (i = 0; i < self->method_count; i++)
{
_Jv_Method *m = &self->methods[i];
if (m == meth)
{
_Jv_MethodBase *imeth = self->interpreted_methods[i];
_Jv_MethodBase *imeth = interp_cl->interpreted_methods[i];
*address = imeth->deferred;
imeth->deferred = address;
return;

2
libjava/java/io/natObjectInputStream.cc
View File

@ -38,7 +38,7 @@ java::io::ObjectInputStream::allocateObject (jclass klass)
obj = NULL;
else
{
obj = JvAllocObject (klass);
obj = _Jv_AllocObject (klass);
}
}
catch (jthrowable t)

4
libjava/java/lang/Class.h
View File

@ -384,6 +384,7 @@ private:
#endif
friend class _Jv_BytecodeVerifier;
friend class _Jv_StackTrace;
friend class gnu::gcj::runtime::StackTrace;
friend class java::io::VMObjectStreamClass;
@ -449,6 +450,9 @@ private:
JArray<jobject> *hack_signers;
// Used by Jv_PopClass and _Jv_PushClass to communicate with StackTrace.
jclass chain;
// Additional data, specific to the generator (JIT, native, interpreter) of this
// class.
void *aux_info;
};
#endif /* __JAVA_LANG_CLASS_H__ */

4
libjava/java/lang/natClass.cc
View File

@ -691,7 +691,7 @@ java::lang::Class::newInstance (void)
if (! meth)
throw new java::lang::InstantiationException (getName());
jobject r = JvAllocObject (this);
jobject r = _Jv_AllocObject (this);
((void (*) (jobject)) meth->ncode) (r);
return r;
}
@ -1901,7 +1901,7 @@ _Jv_MakeVTable (jclass klass)
|| (klass->accflags & Modifier::ABSTRACT))
return;
// out before we can create a vtable.
// Class must be laid out before we can create a vtable.
if (klass->vtable_method_count == -1)
_Jv_LayoutVTableMethods (klass);

2
libjava/java/lang/natClassLoader.cc
View File

@ -419,7 +419,7 @@ jclass
_Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
java::lang::ClassLoader *loader)
{
jclass ret = (jclass) JvAllocObject (&java::lang::Class::class$);
jclass ret = (jclass) _Jv_AllocObject (&java::lang::Class::class$);
ret->name = name;
ret->superclass = superclass;
ret->loader = loader;

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

@ -98,7 +98,7 @@ java::lang::Object::clone (void)
throw new CloneNotSupportedException;
size = klass->size();
r = JvAllocObject (klass, size);
r = _Jv_AllocObject (klass);
}
memcpy ((void *) r, (void *) this, size);

4
libjava/java/lang/natVMClassLoader.cc
View File

@ -39,8 +39,8 @@ java::lang::VMClassLoader::defineClass (java::lang::ClassLoader *loader,
{
#ifdef INTERPRETER
jclass klass;
klass = (jclass) JvAllocObject (&java::lang::Class::class$,
sizeof (_Jv_InterpClass));
klass = new java::lang::Class ();
klass->aux_info = (void *) _Jv_AllocBytes (sizeof (_Jv_InterpClass));
// Synchronize on the class, so that it is not attempted initialized
// until we're done loading.

2
libjava/java/lang/reflect/natMethod.cc
View File

@ -379,7 +379,7 @@ _Jv_CallAnyMethodA (jobject obj,
// the JDK 1.2 docs specify that the new object must be allocated
// before argument conversions are done.
if (is_constructor)
obj = JvAllocObject (return_type);
obj = _Jv_AllocObject (return_type);
const int size_per_arg = sizeof(jvalue);
ffi_cif cif;

2
libjava/jni.cc
View File

@ -633,7 +633,7 @@ static jobject
if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers()))
env->ex = new java::lang::InstantiationException ();
else
obj = JvAllocObject (clazz);
obj = _Jv_AllocObject (clazz);
}
catch (jthrowable t)
{

82
libjava/resolve.cc
View File

@ -367,9 +367,9 @@ _Jv_SearchMethodInClass (jclass cls, jclass klass,
// A helper for _Jv_PrepareClass. This adds missing `Miranda methods'
// to a class.
void
_Jv_PrepareMissingMethods (jclass base2, jclass iface_class)
_Jv_PrepareMissingMethods (jclass base, jclass iface_class)
{
_Jv_InterpClass *base = reinterpret_cast<_Jv_InterpClass *> (base2);
_Jv_InterpClass *interp_base = (_Jv_InterpClass *) base->aux_info;
for (int i = 0; i < iface_class->interface_count; ++i)
{
for (int j = 0; j < iface_class->interfaces[i]->method_count; ++j)
@ -403,11 +403,11 @@ _Jv_PrepareMissingMethods (jclass base2, jclass iface_class)
_Jv_MethodBase **new_im
= (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
* new_count);
memcpy (new_im, base->interpreted_methods,
memcpy (new_im, interp_base->interpreted_methods,
sizeof (_Jv_MethodBase *) * base->method_count);
base->methods = new_m;
base->interpreted_methods = new_im;
interp_base->interpreted_methods = new_im;
base->method_count = new_count;
}
}
@ -454,7 +454,7 @@ _Jv_PrepareClass(jclass klass)
if (klass->superclass)
java::lang::VMClassLoader::resolveClass (klass->superclass);
_Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
_Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info;
/************ PART ONE: OBJECT LAYOUT ***************/
@ -462,7 +462,7 @@ _Jv_PrepareClass(jclass klass)
// 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;
jclass super = klass->superclass;
while (super != NULL)
{
int num = JvNumInstanceFields (super);
@ -484,23 +484,23 @@ _Jv_PrepareClass(jclass klass)
// 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();
if (klass->superclass)
instance_size = klass->superclass->size();
else
instance_size = java::lang::Object::class$.size();
for (int i = 0; i < clz->field_count; i++)
for (int i = 0; i < klass->field_count; i++)
{
int field_size;
int field_align;
_Jv_Field *field = &clz->fields[i];
_Jv_Field *field = &klass->fields[i];
if (! field->isRef ())
{
// it's safe to resolve the field here, since it's
// a primitive class, which does not cause loading to happen.
_Jv_ResolveField (field, clz->loader);
_Jv_ResolveField (field, klass->loader);
field_size = field->type->size ();
field_align = get_alignment_from_class (field->type);
@ -538,7 +538,7 @@ _Jv_PrepareClass(jclass klass)
// 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;
klass->size_in_bytes = instance_size;
// allocate static memory
if (static_size != 0)
@ -547,18 +547,18 @@ _Jv_PrepareClass(jclass klass)
memset (static_data, 0, static_size);
for (int i = 0; i < clz->field_count; i++)
for (int i = 0; i < klass->field_count; i++)
{
_Jv_Field *field = &clz->fields[i];
_Jv_Field *field = &klass->fields[i];
if ((field->flags & Modifier::STATIC) != 0)
{
field->u.addr = static_data + field->u.boffset;
if (clz->field_initializers[i] != 0)
if (iclass->field_initializers[i] != 0)
{
_Jv_ResolveField (field, clz->loader);
_Jv_InitField (0, clz, i);
_Jv_ResolveField (field, klass->loader);
_Jv_InitField (0, klass, i);
}
}
}
@ -566,31 +566,31 @@ _Jv_PrepareClass(jclass klass)
// now we don't need the field_initializers anymore, so let the
// collector get rid of it!
clz->field_initializers = 0;
iclass->field_initializers = 0;
}
/************ PART TWO: VTABLE LAYOUT ***************/
/* preparation: build the vtable stubs (even interfaces can)
have code -- for static constructors. */
for (int i = 0; i < clz->method_count; i++)
for (int i = 0; i < klass->method_count; i++)
{
_Jv_MethodBase *imeth = clz->interpreted_methods[i];
_Jv_MethodBase *imeth = iclass->interpreted_methods[i];
if ((clz->methods[i].accflags & Modifier::NATIVE) != 0)
if ((klass->methods[i].accflags & Modifier::NATIVE) != 0)
{
// 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 ();
klass->methods[i].ncode = jnim->ncode ();
}
else if (imeth != 0) // it could be abstract
{
_Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
_Jv_VerifyMethod (im);
clz->methods[i].ncode = im->ncode ();
klass->methods[i].ncode = im->ncode ();
// Resolve ctable entries pointing to this method. See
// _Jv_Defer_Resolution.
@ -598,16 +598,16 @@ _Jv_PrepareClass(jclass klass)
while (code)
{
void **target = (void **)*code;
*code = clz->methods[i].ncode;
*code = klass->methods[i].ncode;
code = target;
}
}
}
if ((clz->accflags & Modifier::INTERFACE))
if ((klass->accflags & Modifier::INTERFACE))
{
clz->state = JV_STATE_PREPARED;
clz->notifyAll ();
klass->state = JV_STATE_PREPARED;
klass->notifyAll ();
return;
}
@ -619,15 +619,15 @@ _Jv_PrepareClass(jclass klass)
// 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 ((klass->accflags & Modifier::ABSTRACT))
_Jv_PrepareMissingMethods (klass, klass);
clz->vtable_method_count = -1;
_Jv_MakeVTable (clz);
klass->vtable_method_count = -1;
_Jv_MakeVTable (klass);
/* wooha! we're done. */
clz->state = JV_STATE_PREPARED;
clz->notifyAll ();
klass->state = JV_STATE_PREPARED;
klass->notifyAll ();
}
/** Do static initialization for fields with a constant initializer */
@ -642,18 +642,18 @@ _Jv_InitField (jobject obj, jclass klass, int index)
if (!_Jv_IsInterpretedClass (klass))
return;
_Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
_Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info;
_Jv_Field * field = (&clz->fields[0]) + index;
_Jv_Field * field = (&klass->fields[0]) + index;
if (index > clz->field_count)
if (index > klass->field_count)
throw_internal_error ("field out of range");
int init = clz->field_initializers[index];
int init = iclass->field_initializers[index];
if (init == 0)
return;
_Jv_Constants *pool = &clz->constants;
_Jv_Constants *pool = &klass->constants;
int tag = pool->tags[init];
if (! field->isResolved ())
@ -673,12 +673,12 @@ _Jv_InitField (jobject obj, jclass klass, int index)
{
case JV_CONSTANT_String:
{
_Jv_MonitorEnter (clz);
_Jv_MonitorEnter (klass);
jstring str;
str = _Jv_NewStringUtf8Const (pool->data[init].utf8);
pool->data[init].string = str;
pool->tags[init] = JV_CONSTANT_ResolvedString;
_Jv_MonitorExit (clz);
_Jv_MonitorExit (klass);
}
/* fall through */