/* src/vm/linker.c - class linker functions
- Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
- R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
- C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
- Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
+ E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
+ J. Wenninger, Institut f. Computersprachen - TU Wien
This file is part of CACAO.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA.
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
- Contact: cacao@complang.tuwien.ac.at
+ Contact: cacao@cacaojvm.org
Authors: Reinhard Grafl
Edwin Steiner
Christian Thalinger
- $Id: linker.c 2195 2005-04-03 16:53:16Z edwin $
+ $Id: linker.c 5444 2006-09-09 19:25:24Z edwin $
*/
+#include "config.h"
+
#include <assert.h>
+
+#include "vm/types.h"
+
#include "mm/memory.h"
#include "native/native.h"
-#include "vm/builtin.h"
+
+#if defined(ENABLE_THREADS)
+# include "threads/native/lock.h"
+#else
+# include "threads/none/lock.h"
+#endif
+
#include "vm/class.h"
+#include "vm/classcache.h"
#include "vm/exceptions.h"
#include "vm/loader.h"
#include "vm/options.h"
#include "vm/resolve.h"
#include "vm/statistics.h"
-#include "vm/jit/codegen.inc.h"
+#include "vm/stringlocal.h"
+#include "vm/access.h"
+#include "vm/rt-timing.h"
+#include "vm/vm.h"
+#include "vm/jit/asmpart.h"
/* global variables ***********************************************************/
primitive class.
CAUTION: Don't change the order of the types. This table is indexed
- by the ARRAYTYPE_ constants (expcept ARRAYTYPE_OBJECT).
+ by the ARRAYTYPE_ constants (except ARRAYTYPE_OBJECT).
*******************************************************************************/
static arraydescriptor *link_array(classinfo *c);
static void linker_compute_class_values(classinfo *c);
static void linker_compute_subclasses(classinfo *c);
-static void linker_addinterface(classinfo *c, classinfo *ic);
+static bool linker_addinterface(classinfo *c, classinfo *ic);
static s4 class_highestinterface(classinfo *c);
interfaceindex = 0;
+ /* link java.lang.Class as first class of the system, because we
+ need it's vftbl for all other classes so we can use a class as
+ object */
+
+ if (!link_class(class_java_lang_Class))
+ return false;
+
+ /* now set the header.vftbl of all classes which were created
+ before java.lang.Class was linked */
+
+ class_postset_header_vftbl();
+
+
/* link important system classes */
if (!link_class(class_java_lang_Object))
return false;
+ /* load some other important classes */
+
+ if (!link_class(class_java_lang_ClassLoader))
+ return false;
+
+ if (!link_class(class_java_lang_SecurityManager))
+ return false;
+
+ if (!link_class(class_java_lang_System))
+ return false;
+
+ if (!link_class(class_java_lang_Thread))
+ return false;
+
+ if (!link_class(class_java_lang_ThreadGroup))
+ return false;
+
+ if (!link_class(class_java_lang_VMSystem))
+ return false;
+
+ if (!link_class(class_java_lang_VMThread))
+ return false;
+
+
+ /* some classes which may be used more often */
+
+ if (!link_class(class_java_lang_StackTraceElement))
+ return false;
+
+ if (!link_class(class_java_lang_reflect_Constructor))
+ return false;
+
+ if (!link_class(class_java_lang_reflect_Field))
+ return false;
+
+ if (!link_class(class_java_lang_reflect_Method))
+ return false;
+
+ if (!link_class(class_java_security_PrivilegedAction))
+ return false;
+
+ if (!link_class(class_java_util_Vector))
+ return false;
+
+ if (!link_class(arrayclass_java_lang_Object))
+ return false;
+
+
/* create pseudo classes used by the typechecker */
/* pseudo class for Arraystubs (extends java.lang.Object) */
- pseudo_class_Arraystub = create_classinfo(utf_new_char("$ARRAYSTUB$"));
- pseudo_class_Arraystub->loaded = true;
- pseudo_class_Arraystub->super.cls = class_java_lang_Object;
- pseudo_class_Arraystub->interfacescount = 2;
- pseudo_class_Arraystub->interfaces = MNEW(classref_or_classinfo, 2);
- pseudo_class_Arraystub->interfaces[0].cls = class_java_lang_Cloneable;
- pseudo_class_Arraystub->interfaces[1].cls = class_java_io_Serializable;
- if (!classcache_store(NULL,pseudo_class_Arraystub))
- panic("could not cache pseudo_class_Arraystub");
-
- if (!link_class(pseudo_class_Arraystub))
+ pseudo_class_Arraystub =
+ class_create_classinfo(utf_new_char("$ARRAYSTUB$"));
+ pseudo_class_Arraystub->state |= CLASS_LOADED;
+ pseudo_class_Arraystub->super.cls = class_java_lang_Object;
+ pseudo_class_Arraystub->interfacescount = 2;
+ pseudo_class_Arraystub->interfaces = MNEW(classref_or_classinfo, 2);
+ pseudo_class_Arraystub->interfaces[0].cls = class_java_lang_Cloneable;
+ pseudo_class_Arraystub->interfaces[1].cls = class_java_io_Serializable;
+
+ if (!classcache_store_unique(pseudo_class_Arraystub)) {
+ log_text("could not cache pseudo_class_Arraystub");
+ assert(0);
+ }
+
+ if (!link_class(pseudo_class_Arraystub))
return false;
- /* pseudo class representing the null type */
-
- pseudo_class_Null = create_classinfo(utf_new_char("$NULL$"));
- pseudo_class_Null->loaded = true;
- pseudo_class_Null->super.cls = class_java_lang_Object;
- if (!classcache_store(NULL,pseudo_class_Null))
- panic("could not cache pseudo_class_Null");
+ /* pseudo class representing the null type */
+
+ pseudo_class_Null = class_create_classinfo(utf_new_char("$NULL$"));
+ pseudo_class_Null->state |= CLASS_LOADED;
+ pseudo_class_Null->super.cls = class_java_lang_Object;
+
+ if (!classcache_store_unique(pseudo_class_Null)) {
+ log_text("could not cache pseudo_class_Null");
+ assert(0);
+ }
if (!link_class(pseudo_class_Null))
return false;
- /* pseudo class representing new uninitialized objects */
+ /* pseudo class representing new uninitialized objects */
- pseudo_class_New = create_classinfo(utf_new_char("$NEW$"));
- pseudo_class_New->loaded = true;
- pseudo_class_New->linked = true; /* XXX is this allright? */
+ pseudo_class_New = class_create_classinfo(utf_new_char("$NEW$"));
+ pseudo_class_New->state |= CLASS_LOADED;
+ pseudo_class_New->state |= CLASS_LINKED; /* XXX is this allright? */
pseudo_class_New->super.cls = class_java_lang_Object;
- if (!classcache_store(NULL,pseudo_class_New))
- panic("could not cache pseudo_class_New");
+
+ if (!classcache_store_unique(pseudo_class_New)) {
+ log_text("could not cache pseudo_class_New");
+ assert(0);
+ }
/* create classes representing primitive types */
static bool link_primitivetype_table(void)
{
classinfo *c;
- s4 i;
+ utf *u;
+ s4 i;
for (i = 0; i < PRIMITIVETYPE_COUNT; i++) {
/* skip dummies */
+
if (!primitivetype_table[i].name)
continue;
/* create primitive class */
- c = create_classinfo(utf_new_char(primitivetype_table[i].name));
- c->classUsed = NOTUSED; /* not used initially CO-RT */
- c->impldBy = NULL;
+
+ c = class_create_classinfo(utf_new_char(primitivetype_table[i].name));
+
+ c->flags = ACC_PUBLIC | ACC_FINAL | ACC_ABSTRACT;
/* prevent loader from loading primitive class */
- c->loaded = true;
- if (!classcache_store(NULL,c)) {
- log_text("Could not cache primitive class");
- return false;
- }
+
+ c->state |= CLASS_LOADED;
+
+ /* INFO: don't put primitive classes into the classcache */
+
if (!link_class(c))
return false;
primitivetype_table[i].class_primitive = c;
/* create class for wrapping the primitive type */
- if (!load_class_bootstrap(utf_new_char(primitivetype_table[i].wrapname),&c))
+
+ u = utf_new_char(primitivetype_table[i].wrapname);
+
+ if (!(c = load_class_bootstrap(u)))
return false;
+
primitivetype_table[i].class_wrap = c;
- primitivetype_table[i].class_wrap->classUsed = NOTUSED; /* not used initially CO-RT */
- primitivetype_table[i].class_wrap->impldBy = NULL;
/* create the primitive array class */
+
if (primitivetype_table[i].arrayname) {
- c = create_classinfo(utf_new_char(primitivetype_table[i].arrayname));
- if (!load_newly_created_array(c,NULL))
+ u = utf_new_char(primitivetype_table[i].arrayname);
+ c = class_create_classinfo(u);
+ c = load_newly_created_array(c, NULL);
+ if (c == NULL)
return false;
+
primitivetype_table[i].arrayclass = c;
- assert(c->loaded);
- if (!c->linked)
+
+ assert(c->state & CLASS_LOADED);
+
+ if (!(c->state & CLASS_LINKED))
if (!link_class(c))
return false;
+
primitivetype_table[i].arrayvftbl = c->vftbl;
}
}
classinfo *link_class(classinfo *c)
{
classinfo *r;
+#if defined(ENABLE_RT_TIMING)
+ struct timespec time_start, time_end;
+#endif
- if (!c) {
- *exceptionptr = new_nullpointerexception();
+ RT_TIMING_GET_TIME(time_start);
+
+ if (c == NULL) {
+ exceptions_throw_nullpointerexception();
return NULL;
}
-#if defined(USE_THREADS)
- /* enter a monitor on the class */
-
- builtin_monitorenter((java_objectheader *) c);
-#endif
+ LOCK_MONITOR_ENTER(c);
/* maybe the class is already linked */
- if (c->linked) {
-#if defined(USE_THREADS)
- builtin_monitorexit((java_objectheader *) c);
-#endif
+
+ if (c->state & CLASS_LINKED) {
+ LOCK_MONITOR_EXIT(c);
return c;
}
-#if defined(STATISTICS)
+#if defined(ENABLE_STATISTICS)
/* measure time */
- if (getcompilingtime)
+ if (opt_getcompilingtime)
compilingtime_stop();
- if (getloadingtime)
+ if (opt_getloadingtime)
loadingtime_start();
#endif
/* call the internal function */
+
r = link_class_intern(c);
/* if return value is NULL, we had a problem and the class is not linked */
+
if (!r)
- c->linked = false;
+ c->state &= ~CLASS_LINKING;
-#if defined(STATISTICS)
+#if defined(ENABLE_STATISTICS)
/* measure time */
- if (getloadingtime)
+ if (opt_getloadingtime)
loadingtime_stop();
- if (getcompilingtime)
+ if (opt_getcompilingtime)
compilingtime_start();
#endif
-#if defined(USE_THREADS)
- /* leave the monitor */
+ LOCK_MONITOR_EXIT(c);
- builtin_monitorexit((java_objectheader *) c);
-#endif
+ RT_TIMING_GET_TIME(time_end);
+
+ RT_TIMING_TIME_DIFF(time_start,time_end,RT_TIMING_LINK_TOTAL);
return r;
}
vftbl_t *v; /* vftbl of current class */
s4 i,j; /* interface/method/field counter */
arraydescriptor *arraydesc; /* descriptor for array classes */
+#if defined(ENABLE_RT_TIMING)
+ struct timespec time_start, time_resolving, time_compute_vftbl,
+ time_abstract, time_compute_iftbl, time_fill_vftbl,
+ time_offsets, time_fill_iftbl, time_finalizer,
+ time_exceptions, time_subclasses;
+#endif
- /* maybe the class is already linked */
- if (c->linked)
+ RT_TIMING_GET_TIME(time_start);
+
+ /* the class is already linked */
+
+ if (c->state & CLASS_LINKED)
return c;
+#if !defined(NDEBUG)
if (linkverbose)
log_message_class("Linking class: ", c);
+#endif
/* the class must be loaded */
- if (!c->loaded)
- throw_cacao_exception_exit(string_java_lang_InternalError,
- "Trying to link unloaded class");
- /* ok, this class is somewhat linked */
- c->linked = true;
+ /* XXX should this be a specific exception? */
+ assert(c->state & CLASS_LOADED);
+
+ /* cache the self-reference of this class */
+ /* we do this for cases where the defining loader of the class */
+ /* has not yet been recorded as an initiating loader for the class */
+ /* this is needed so subsequent code can assume that self-refs */
+ /* will always resolve lazily */
+ /* No need to do it for the bootloader - it is always registered */
+ /* as initiating loader for the classes it loads. */
+ if (c->classloader)
+ classcache_store(c->classloader,c,false);
+
+ /* this class is currently linking */
+
+ c->state |= CLASS_LINKING;
arraydesc = NULL;
for (i = 0; i < c->interfacescount; i++) {
/* resolve this super interface */
- if (!resolve_classref_or_classinfo(NULL,c->interfaces[i],resolveEager,false,&tc))
+
+ if (!resolve_classref_or_classinfo(NULL, c->interfaces[i], resolveEager,
+ true, false, &tc))
return NULL;
+
c->interfaces[i].cls = tc;
/* detect circularity */
return NULL;
}
- assert(tc->loaded);
+ assert(tc->state & CLASS_LOADED);
if (!(tc->flags & ACC_INTERFACE)) {
*exceptionptr =
return NULL;
}
- if (!tc->linked)
+ if (!(tc->state & CLASS_LINKED))
if (!link_class(tc))
return NULL;
}
/* check super class */
super = NULL;
- if (c->super.any == NULL) { /* class java.lang.Object */
+
+ if (c->super.any == NULL) { /* class java.lang.Object */
c->index = 0;
- c->classUsed = USED; /* Object class is always used CO-RT*/
- c->impldBy = NULL;
c->instancesize = sizeof(java_objectheader);
vftbllength = supervftbllength = 0;
} else {
/* resolve super class */
- if (!resolve_classref_or_classinfo(NULL,c->super,resolveEager,false,&super))
+
+ if (!resolve_classref_or_classinfo(NULL, c->super, resolveEager, true, false,
+ &super))
return NULL;
c->super.cls = super;
/* detect circularity */
+
if (super == c) {
*exceptionptr =
new_exception_utfmessage(string_java_lang_ClassCircularityError,
return NULL;
}
- assert(super->loaded);
+ assert(super->state & CLASS_LOADED);
if (super->flags & ACC_INTERFACE) {
/* java.lang.IncompatibleClassChangeError: class a has interface java.lang.Cloneable as super class */
- panic("Interface specified as super class");
+ log_text("Interface specified as super class");
+ assert(0);
}
/* Don't allow extending final classes */
+
if (super->flags & ACC_FINAL) {
*exceptionptr =
new_exception_message(string_java_lang_VerifyError,
"Cannot inherit from final class");
return NULL;
}
+
+ /* link the superclass if necessary */
- if (!super->linked)
+ if (!(super->state & CLASS_LINKED))
if (!link_class(super))
return NULL;
+ /* OR the ACC_CLASS_HAS_POINTERS flag */
+
+ c->flags |= (super->flags & ACC_CLASS_HAS_POINTERS);
+
/* handle array classes */
+
if (c->name->text[0] == '[')
if (!(arraydesc = link_array(c)))
return NULL;
c->index = super->index + 1;
c->instancesize = super->instancesize;
-
+
vftbllength = supervftbllength = super->vftbl->vftbllength;
c->finalizer = super->finalizer;
}
+ RT_TIMING_GET_TIME(time_resolving);
/* compute vftbl length */
if (tc->methods[j].flags & ACC_PRIVATE)
goto notfoundvftblindex;
+ /* package-private methods in other packages */
+ /* must not be overridden */
+ /* (see Java Language Specification 8.4.8.1) */
+ if ( !(tc->methods[j].flags & (ACC_PUBLIC | ACC_PROTECTED))
+ && !SAME_PACKAGE(c,tc) )
+ {
+ goto notfoundvftblindex;
+ }
+
if (tc->methods[j].flags & ACC_FINAL) {
/* class a overrides final method . */
*exceptionptr =
return NULL;
}
+ /* method m overwrites method j of class tc */
+
+#if defined(ENABLE_VERIFIER)
+ /* Add loading constraints (for the more general */
+ /* types of method tc->methods[j]). -- */
+ /* Not for <init>, as it is not invoked virtually. */
+ if ((m->name != utf_init)
+ && !classcache_add_constraints_for_params(
+ c->classloader, tc->classloader,
+ &(tc->methods[j])))
+ {
+ return NULL;
+ }
+#endif
+
m->vftblindex = tc->methods[j].vftblindex;
goto foundvftblindex;
}
foundvftblindex:
;
}
- }
+ }
+ RT_TIMING_GET_TIME(time_compute_vftbl);
- /* check interfaces of ABSTRACT class for unimplemented methods */
+ /* Check all interfaces of an abstract class (maybe be an
+ interface too) for unimplemented methods. Such methods are
+ called miranda-methods and are marked with the ACC_MIRANDA
+ flag. VMClass.getDeclaredMethods does not return such
+ methods. */
if (c->flags & ACC_ABSTRACT) {
classinfo *ic;
abstractmethodscount = 0;
+ /* check all interfaces of the abstract class */
+
for (i = 0; i < c->interfacescount; i++) {
ic = c->interfaces[i].cls;
/* skip `<clinit>' and `<init>' */
- if (im->name == utf_clinit || im->name == utf_init)
+ if ((im->name == utf_clinit) || (im->name == utf_init))
continue;
- tc = c;
-
- while (tc) {
+ for (tc = c; tc != NULL; tc = tc->super.cls) {
for (k = 0; k < tc->methodscount; k++) {
if (method_canoverwrite(im, &(tc->methods[k])))
goto noabstractmethod;
}
-
- tc = tc->super.cls;
}
abstractmethodscount++;
/* skip `<clinit>' and `<init>' */
- if (im->name == utf_clinit || im->name == utf_init)
+ if ((im->name == utf_clinit) || (im->name == utf_init))
continue;
- tc = c;
-
- while (tc) {
+ for (tc = c; tc != NULL; tc = tc->super.cls) {
for (k = 0; k < tc->methodscount; k++) {
if (method_canoverwrite(im, &(tc->methods[k])))
goto noabstractmethod2;
}
-
- tc = tc->super.cls;
}
+ /* Copy the method found into the new c->methods
+ array and tag it as miranda-method. */
+
am = &(c->methods[c->methodscount]);
c->methodscount++;
MCOPY(am, im, methodinfo, 1);
- am->vftblindex = (vftbllength++);
- am->class = c;
+ am->vftblindex = (vftbllength++);
+ am->class = c;
+ am->flags |= ACC_MIRANDA;
noabstractmethod2:
;
}
}
}
+ RT_TIMING_GET_TIME(time_abstract);
-#if defined(STATISTICS)
+#if defined(ENABLE_STATISTICS)
if (opt_stat)
count_vftbl_len +=
sizeof(vftbl_t) + (sizeof(methodptr) * (vftbllength - 1));
/* compute interfacetable length */
interfacetablelength = 0;
- tc = c;
- while (tc) {
+
+ for (tc = c; tc != NULL; tc = tc->super.cls) {
for (i = 0; i < tc->interfacescount; i++) {
s4 h = class_highestinterface(tc->interfaces[i].cls) + 1;
+
if (h > interfacetablelength)
interfacetablelength = h;
}
- tc = tc->super.cls;
}
+ RT_TIMING_GET_TIME(time_compute_iftbl);
/* allocate virtual function table */
sizeof(methodptr*) * (interfacetablelength - (interfacetablelength > 0)));
v = (vftbl_t *) (((methodptr *) v) +
(interfacetablelength - 1) * (interfacetablelength > 1));
- c->header.vftbl = c->vftbl = v;
- v->class = c;
- v->vftbllength = vftbllength;
+
+ c->vftbl = v;
+ v->class = c;
+ v->vftbllength = vftbllength;
v->interfacetablelength = interfacetablelength;
- v->arraydesc = arraydesc;
+ v->arraydesc = arraydesc;
/* store interface index in vftbl */
for (i = 0; i < supervftbllength; i++)
v->table[i] = super->vftbl->table[i];
-
+
+ /* Fill the remaining vftbl slots with the AbstractMethodError
+ stub (all after the super class slots, because they are already
+ initialized). */
+
+ for (; i < vftbllength; i++)
+ v->table[i] = (methodptr) (ptrint) &asm_abstractmethoderror;
+
/* add method stubs into virtual function table */
for (i = 0; i < c->methodscount; i++) {
methodinfo *m = &(c->methods[i]);
- /* Methods in ABSTRACT classes from interfaces maybe already have a */
- /* stubroutine. */
+ assert(m->stubroutine == NULL);
+
+ /* Don't create a compiler stub for abstract methods as they
+ throw an AbstractMethodError with the default stub in the
+ vftbl. This entry is simply copied by sub-classes. */
- if (!m->stubroutine) {
- if (!(m->flags & ACC_NATIVE)) {
- m->stubroutine = createcompilerstub(m);
+ if (m->flags & ACC_ABSTRACT)
+ continue;
- } else {
- functionptr f = native_findfunction(c->name,
- m->name,
- m->descriptor,
- (m->flags & ACC_STATIC));
-#if defined(STATIC_CLASSPATH)
- if (f)
+#if defined(ENABLE_JIT)
+# if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ m->stubroutine = intrp_createcompilerstub(m);
+ else
#endif
- m->stubroutine = createnativestub(f, m);
- }
- }
+ m->stubroutine = createcompilerstub(m);
+#else
+ m->stubroutine = intrp_createcompilerstub(m);
+#endif
+
+ /* static methods are not in the vftbl */
- if (!(m->flags & ACC_STATIC))
- v->table[m->vftblindex] = m->stubroutine;
+ if (m->flags & ACC_STATIC)
+ continue;
+
+ /* insert the stubroutine into the vftbl */
+
+ v->table[m->vftblindex] = (methodptr) (ptrint) m->stubroutine;
}
+ RT_TIMING_GET_TIME(time_fill_vftbl);
/* compute instance size and offset of each field */
fieldinfo *f = &(c->fields[i]);
if (!(f->flags & ACC_STATIC)) {
- dsize = desc_typesize(f->descriptor);
+ dsize = descriptor_typesize(f->parseddesc);
+
+ /* On i386 we only align to 4 bytes even for double and s8. */
+ /* This matches what gcc does for struct members. We must */
+ /* do the same as gcc here because the offsets in native */
+ /* header structs like java_lang_Double must match the offsets */
+ /* of the Java fields (eg. java.lang.Double.value). */
+#if defined(__I386__)
+ c->instancesize = ALIGN(c->instancesize, 4);
+#else
c->instancesize = ALIGN(c->instancesize, dsize);
+#endif
+
f->offset = c->instancesize;
c->instancesize += dsize;
}
}
+ RT_TIMING_GET_TIME(time_offsets);
/* initialize interfacetable and interfacevftbllength */
-
+
v->interfacevftbllength = MNEW(s4, interfacetablelength);
-#if defined(STATISTICS)
+#if defined(ENABLE_STATISTICS)
if (opt_stat)
count_vftbl_len += (4 + sizeof(s4)) * v->interfacetablelength;
#endif
v->interfacevftbllength[i] = 0;
v->interfacetable[-i] = NULL;
}
-
+
/* add interfaces */
-
+
for (tc = c; tc != NULL; tc = tc->super.cls)
for (i = 0; i < tc->interfacescount; i++)
- linker_addinterface(c, tc->interfaces[i].cls);
+ if (!linker_addinterface(c, tc->interfaces[i].cls))
+ return NULL;
+
+ RT_TIMING_GET_TIME(time_fill_iftbl);
/* add finalizer method (not for java.lang.Object) */
if (!(fi->flags & ACC_STATIC))
c->finalizer = fi;
}
+ RT_TIMING_GET_TIME(time_finalizer);
/* resolve exception class references */
for (i = 0; i < c->methodscount; i++) {
- methodinfo *m = c->methods + i;
- for (j=0; j<m->exceptiontablelength; ++j) {
+ methodinfo *m = &(c->methods[i]);
+ classinfo *exclass;
+
+ for (j = 0; j < m->exceptiontablelength; j++) {
+ /* skip NULL (catch all) entries */
if (!m->exceptiontable[j].catchtype.any)
continue;
- if (!resolve_classref_or_classinfo(NULL,m->exceptiontable[j].catchtype,
- resolveEager,false,&(m->exceptiontable[j].catchtype.cls)))
+
+ /* try to resolve the class reference lazily */
+ if (!resolve_classref_or_classinfo(m,
+ m->exceptiontable[j].catchtype,
+ resolveLazy, true, false,
+ &exclass))
return NULL;
+
+ /* if resolved, enter the result of resolution in the table */
+ if (exclass != NULL)
+ m->exceptiontable[j].catchtype.cls = exclass;
}
- for (j=0; j<m->thrownexceptionscount; ++j)
- if (!resolve_classref_or_classinfo(NULL,m->thrownexceptions[j],
- resolveEager,false,&(m->thrownexceptions[j].cls)))
- return NULL;
}
+ RT_TIMING_GET_TIME(time_exceptions);
/* final tasks */
linker_compute_subclasses(c);
+ RT_TIMING_GET_TIME(time_subclasses);
+
+ /* revert the linking state and class is linked */
+
+ c->state = (c->state & ~CLASS_LINKING) | CLASS_LINKED;
+
+#if !defined(NDEBUG)
if (linkverbose)
log_message_class("Linking done class: ", c);
+#endif
+
+ RT_TIMING_TIME_DIFF(time_start ,time_resolving ,RT_TIMING_LINK_RESOLVE);
+ RT_TIMING_TIME_DIFF(time_resolving ,time_compute_vftbl,RT_TIMING_LINK_C_VFTBL);
+ RT_TIMING_TIME_DIFF(time_compute_vftbl,time_abstract ,RT_TIMING_LINK_ABSTRACT);
+ RT_TIMING_TIME_DIFF(time_abstract ,time_compute_iftbl,RT_TIMING_LINK_C_IFTBL);
+ RT_TIMING_TIME_DIFF(time_compute_iftbl,time_fill_vftbl ,RT_TIMING_LINK_F_VFTBL);
+ RT_TIMING_TIME_DIFF(time_fill_vftbl ,time_offsets ,RT_TIMING_LINK_OFFSETS);
+ RT_TIMING_TIME_DIFF(time_offsets ,time_fill_iftbl ,RT_TIMING_LINK_F_IFTBL);
+ RT_TIMING_TIME_DIFF(time_fill_iftbl ,time_finalizer ,RT_TIMING_LINK_FINALIZER);
+ RT_TIMING_TIME_DIFF(time_finalizer ,time_exceptions ,RT_TIMING_LINK_EXCEPTS);
+ RT_TIMING_TIME_DIFF(time_exceptions ,time_subclasses ,RT_TIMING_LINK_SUBCLASS);
/* just return c to show that we didn't had a problem */
static arraydescriptor *link_array(classinfo *c)
{
- classinfo *comp = NULL;
- s4 namelen = c->name->blength;
+ classinfo *comp;
+ s4 namelen;
arraydescriptor *desc;
- vftbl_t *compvftbl;
+ vftbl_t *compvftbl;
+ utf *u;
+
+ comp = NULL;
+ namelen = c->name->blength;
/* Check the component type */
+
switch (c->name->text[1]) {
case '[':
/* c is an array of arrays. */
- if (!load_class_from_classloader(utf_new_intern(c->name->text + 1, namelen - 1),
- c->classloader,&comp))
+ u = utf_new(c->name->text + 1, namelen - 1);
+ if (!(comp = load_class_from_classloader(u, c->classloader)))
return NULL;
break;
case 'L':
/* c is an array of objects. */
- if (!load_class_from_classloader(utf_new_intern(c->name->text + 2, namelen - 3),
- c->classloader,&comp))
+ u = utf_new(c->name->text + 2, namelen - 3);
+ if (!(comp = load_class_from_classloader(u, c->classloader)))
return NULL;
break;
}
/* If the component type has not been linked, link it now */
- assert(!comp || comp->loaded);
- if (comp && !comp->linked) {
+ assert(!comp || (comp->state & CLASS_LOADED));
+
+ if (comp && !(comp->state & CLASS_LINKED))
if (!link_class(comp))
return NULL;
- }
/* Allocate the arraydescriptor */
+
desc = NEW(arraydescriptor);
if (comp) {
desc->dataoffset = OFFSET(java_objectarray, data);
compvftbl = comp->vftbl;
- if (!compvftbl)
- panic("Component class has no vftbl");
+
+ if (!compvftbl) {
+ log_text("Component class has no vftbl");
+ assert(0);
+ }
+
desc->componentvftbl = compvftbl;
if (compvftbl->arraydesc) {
desc->elementvftbl = compvftbl->arraydesc->elementvftbl;
- if (compvftbl->arraydesc->dimension >= 255)
- panic("Creating array of dimension >255");
+
+ if (compvftbl->arraydesc->dimension >= 255) {
+ log_text("Creating array of dimension >255");
+ assert(0);
+ }
+
desc->dimension = compvftbl->arraydesc->dimension + 1;
desc->elementtype = compvftbl->arraydesc->elementtype;
break;
default:
- panic("Invalid array class name");
+ *exceptionptr = new_noclassdeffounderror(c->name);
+ return NULL;
}
desc->componentvftbl = NULL;
static void linker_compute_subclasses(classinfo *c)
{
-#if defined(USE_THREADS)
-#if defined(NATIVE_THREADS)
+#if defined(ENABLE_THREADS)
compiler_lock();
-#else
- intsDisable();
-#endif
#endif
if (!(c->flags & ACC_INTERFACE)) {
classvalue = 0;
- /* this is the java.lang.Object special case */
+ /* compute class values */
- if (!class_java_lang_Object) {
- linker_compute_class_values(c);
+ linker_compute_class_values(class_java_lang_Object);
- } else {
- linker_compute_class_values(class_java_lang_Object);
- }
-
-#if defined(USE_THREADS)
-#if defined(NATIVE_THREADS)
+#if defined(ENABLE_THREADS)
compiler_unlock();
-#else
- intsRestore();
-#endif
#endif
}
Is needed by link_class for adding a VTBL to a class. All
interfaces implemented by ic are added as well.
+ RETURN VALUE:
+ true.........everything ok
+ false........an exception has been thrown
+
*******************************************************************************/
-static void linker_addinterface(classinfo *c, classinfo *ic)
+static bool linker_addinterface(classinfo *c, classinfo *ic)
{
- s4 j, m;
- s4 i = ic->index;
- vftbl_t *v = c->vftbl;
+ s4 j, k;
+ vftbl_t *v;
+ s4 i;
+ classinfo *sc;
+ methodinfo *m;
+
+ v = c->vftbl;
+ i = ic->index;
if (i >= v->interfacetablelength)
- panic ("Inernal error: interfacetable overflow");
+ vm_abort("Internal error: interfacetable overflow");
- if (v->interfacetable[-i])
- return;
+ /* if this interface has already been added, return immediately */
+
+ if (v->interfacetable[-i] != NULL)
+ return true;
if (ic->methodscount == 0) { /* fake entry needed for subtype test */
v->interfacevftbllength[i] = 1;
- v->interfacetable[-i] = MNEW(methodptr, 1);
- v->interfacetable[-i][0] = NULL;
-
- } else {
+ v->interfacetable[-i] = MNEW(methodptr, 1);
+ v->interfacetable[-i][0] = NULL;
+ }
+ else {
v->interfacevftbllength[i] = ic->methodscount;
- v->interfacetable[-i] = MNEW(methodptr, ic->methodscount);
+ v->interfacetable[-i] = MNEW(methodptr, ic->methodscount);
-#if defined(STATISTICS)
+#if defined(ENABLE_STATISTICS)
if (opt_stat)
count_vftbl_len += sizeof(methodptr) *
(ic->methodscount + (ic->methodscount == 0));
#endif
for (j = 0; j < ic->methodscount; j++) {
- classinfo *sc = c;
+ for (sc = c; sc != NULL; sc = sc->super.cls) {
+ for (k = 0; k < sc->methodscount; k++) {
+ m = &(sc->methods[k]);
+
+ if (method_canoverwrite(m, &(ic->methods[j]))) {
+ /* method m overwrites the (abstract) method */
+#if defined(ENABLE_VERIFIER)
+ /* Add loading constraints (for the more
+ general types of the method
+ ic->methods[j]). */
+ if (!classcache_add_constraints_for_params(
+ c->classloader, ic->classloader,
+ &(ic->methods[j])))
+ {
+ return false;
+ }
+#endif
- while (sc) {
- for (m = 0; m < sc->methodscount; m++) {
- methodinfo *mi = &(sc->methods[m]);
+ /* XXX taken from gcj */
+ /* check for ACC_STATIC: IncompatibleClassChangeError */
- if (method_canoverwrite(mi, &(ic->methods[j]))) {
- v->interfacetable[-i][j] = v->table[mi->vftblindex];
+ /* check for !ACC_PUBLIC: IllegalAccessError */
+
+ /* check for ACC_ABSTRACT: AbstracMethodError,
+ not sure about that one */
+
+ v->interfacetable[-i][j] = v->table[m->vftblindex];
goto foundmethod;
}
}
- sc = sc->super.cls;
}
+
+ /* If no method was found, insert the AbstractMethodError
+ stub. */
+
+ v->interfacetable[-i][j] =
+ (methodptr) (ptrint) &asm_abstractmethoderror;
+
foundmethod:
;
}
}
- for (j = 0; j < ic->interfacescount; j++)
- linker_addinterface(c, ic->interfaces[j].cls);
+ /* add superinterfaces of this interface */
+
+ for (j = 0; j < ic->interfacescount; j++)
+ if (!linker_addinterface(c, ic->interfaces[j].cls))
+ return false;
+
+ /* everything ok */
+
+ return true;
}
}
-/***************** Function: print_arraydescriptor ****************************
-
- Debug helper for displaying an arraydescriptor
-
-*******************************************************************************/
-
-void print_arraydescriptor(FILE *file, arraydescriptor *desc)
-{
- if (!desc) {
- fprintf(file, "<NULL>");
- return;
- }
-
- fprintf(file, "{");
- if (desc->componentvftbl) {
- if (desc->componentvftbl->class)
- utf_fprint(file, desc->componentvftbl->class->name);
- else
- fprintf(file, "<no classinfo>");
- }
- else
- fprintf(file, "0");
-
- fprintf(file, ",");
- if (desc->elementvftbl) {
- if (desc->elementvftbl->class)
- utf_fprint(file, desc->elementvftbl->class->name);
- else
- fprintf(file, "<no classinfo>");
- }
- else
- fprintf(file, "0");
- fprintf(file, ",%d,%d,%d,%d}", desc->arraytype, desc->dimension,
- desc->dataoffset, desc->componentsize);
-}
-
-
/*
* These are local overrides for various environment variables in Emacs.
* Please do not remove this and leave it at the end of the file, where
* c-basic-offset: 4
* tab-width: 4
* End:
+ * vim:noexpandtab:sw=4:ts=4:
*/
projects / cacao.git / blobdiff