OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

For PR libgcj/7073: 

* resolve.cc (_Jv_PrepareClass): Only resolve superclass if it
	exists.
	* defineclass.cc (handleClassBegin): Superclass for interface is
	`null'.

From-SVN: r54835
This commit is contained in:
Tom Tromey 2002-06-20 15:10:49 +00:00 committed by Tom Tromey
parent aa16c0facc
commit 04a704a4aa
3 changed files with 40 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libjava/ChangeLog
View File

@ -1,3 +1,11 @@
2002-06-20 Tom Tromey <tromey@redhat.com>
For PR libgcj/7073:
* resolve.cc (_Jv_PrepareClass): Only resolve superclass if it
exists.
* defineclass.cc (handleClassBegin): Superclass for interface is
`null'.
2002-06-18 Tom Tromey <tromey@redhat.com>
* gcj/javaprims.h: Updated class declaration list.

34
libjava/defineclass.cc
View File

@ -1,6 +1,6 @@
// defineclass.cc - defining a class from .class format.
/* Copyright (C) 1999, 2000, 2001 Free Software Foundation
/* Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation
This file is part of libgcj.
@ -895,20 +895,11 @@ _Jv_ClassReader::handleClassBegin
pool_data[this_class].clazz = def;
pool_tags[this_class] = JV_CONSTANT_ResolvedClass;
if (super_class == 0)
if (super_class == 0 && ! (access_flags & Modifier::INTERFACE))
{
// interfaces have java.lang.Object as super.
if (access_flags & Modifier::INTERFACE)
{
def->superclass = (jclass)&java::lang::Object::class$;
}
// FIXME: Consider this carefully!
else if (!_Jv_equalUtf8Consts (def->name,
java::lang::Object::class$.name))
{
throw_no_class_def_found_error ("loading java.lang.Object");
}
if (! _Jv_equalUtf8Consts (def->name, java::lang::Object::class$.name))
throw_no_class_def_found_error ("loading java.lang.Object");
}
// In the pre-loading state, it can be looked up in the
@ -924,25 +915,30 @@ _Jv_ClassReader::handleClassBegin
if (super_class != 0)
{
// load the super class
// Load the superclass.
check_tag (super_class, JV_CONSTANT_Class);
_Jv_Utf8Const* super_name = pool_data[super_class].utf8;
// load the super class using our defining loader
// Load the superclass using our defining loader.
jclass the_super = _Jv_FindClass (super_name,
def->loader);
// This will establish that we are allowed to be a subclass,
// and check for class circularity error
// and check for class circularity error.
checkExtends (def, the_super);
def->superclass = the_super;
// Note: for an interface we will find Object as the
// superclass. We still check it above to ensure class file
// validity, but we simply assign `null' to the actual field in
// this case.
def->superclass = (((access_flags & Modifier::INTERFACE))
? NULL : the_super);
pool_data[super_class].clazz = the_super;
pool_tags[super_class] = JV_CONSTANT_ResolvedClass;
}
// now we've come past the circularity problem, we can
// now say that we're loading...
// Now we've come past the circularity problem, we can
// now say that we're loading.
def->state = JV_STATE_LOADING;
def->notifyAll ();

26
libjava/resolve.cc
View File

@ -516,11 +516,14 @@ _Jv_PrepareClass(jclass klass)
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::ClassLoader::resolveClass0 (klass->superclass);
_Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
@ -529,8 +532,12 @@ _Jv_PrepareClass(jclass klass)
int instance_size;
int static_size;
// java.lang.Object is never interpreted!
instance_size = clz->superclass->size ();
// Although java.lang.Object is never interpreted, an interface can
// have a null superclass.
if (clz->superclass)
instance_size = clz->superclass->size();
else
instance_size = java::lang::Object::class$.size();
static_size = 0;
for (int i = 0; i < clz->field_count; i++)
@ -646,9 +653,6 @@ _Jv_PrepareClass(jclass klass)
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];
@ -708,6 +712,10 @@ _Jv_PrepareClass(jclass klass)
while (effective_superclass && effective_superclass->vtable == NULL)
effective_superclass = effective_superclass->superclass;
/* If we ended up without a superclass, use Object. */
if (! effective_superclass)
effective_superclass = &java::lang::Object::class$;
/* copy super class' vtable entries. */
if (effective_superclass && effective_superclass->vtable)
for (int i = 0; i < effective_superclass->vtable_method_count; ++i)