Edwin Steiner
Christian Thalinger
- $Id: linker.c 4803 2006-04-21 00:00:22Z edwin $
+ $Id: linker.c 5058 2006-06-28 21:46:41Z twisti $
*/
#include "vm/stringlocal.h"
#include "vm/access.h"
#include "vm/rt-timing.h"
+#include "vm/vm.h"
+#include "vm/jit/asmpart.h"
/* global variables ***********************************************************/
return NULL;
}
-#if defined(USE_THREADS)
+#if defined(ENABLE_THREADS)
/* enter a monitor on the class */
builtin_monitorenter((java_objectheader *) c);
/* maybe the class is already linked */
if (c->state & CLASS_LINKED) {
-#if defined(USE_THREADS)
+#if defined(ENABLE_THREADS)
builtin_monitorexit((java_objectheader *) c);
#endif
#if defined(ENABLE_STATISTICS)
/* measure time */
- if (getcompilingtime)
+ if (opt_getcompilingtime)
compilingtime_stop();
- if (getloadingtime)
+ if (opt_getloadingtime)
loadingtime_start();
#endif
#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)
+#if defined(ENABLE_THREADS)
/* leave the monitor */
builtin_monitorexit((java_objectheader *) c);
"Cannot inherit from final class");
return NULL;
}
+
+ /* link the superclass if necessary */
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] == '[')
c->index = super->index + 1;
c->instancesize = super->instancesize;
-
+
vftbllength = supervftbllength = super->vftbl->vftbllength;
c->finalizer = super->finalizer;
RT_TIMING_GET_TIME(time_compute_vftbl);
- /* Check all interfaces of an abtract 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. */
+ /* 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 abtract class */
+ /* check all interfaces of the abstract class */
for (i = 0; i < c->interfacescount; i++) {
ic = c->interfaces[i].cls;
/* 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);
sizeof(methodptr*) * (interfacetablelength - (interfacetablelength > 0)));
v = (vftbl_t *) (((methodptr *) v) +
(interfacetablelength - 1) * (interfacetablelength > 1));
- 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->flags & ACC_ABSTRACT)
+ continue;
- if (!m->stubroutine) {
#if defined(ENABLE_JIT)
# if defined(ENABLE_INTRP)
- if (opt_intrp)
- m->stubroutine = intrp_createcompilerstub(m);
- else
+ if (opt_intrp)
+ m->stubroutine = intrp_createcompilerstub(m);
+ else
#endif
- m->stubroutine = createcompilerstub(m);
+ m->stubroutine = createcompilerstub(m);
#else
- m->stubroutine = intrp_createcompilerstub(m);
+ m->stubroutine = intrp_createcompilerstub(m);
#endif
- }
- if (!(m->flags & ACC_STATIC))
- v->table[m->vftblindex] = (methodptr) (ptrint) m->stubroutine;
+ /* static methods are not in the vftbl */
+
+ 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);
if (!(f->flags & ACC_STATIC)) {
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;
}
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)) {
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
}
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;
- if (i >= v->interfacetablelength) {
- log_text("Inernal error: interfacetable overflow");
- assert(0);
- }
+ v = c->vftbl;
+ i = ic->index;
+
+ if (i >= v->interfacetablelength)
+ vm_abort("Internal error: interfacetable overflow");
/* if this interface has already been added, return immediately */
- if (v->interfacetable[-i])
+ 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;
-
+ 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(ENABLE_STATISTICS)
if (opt_stat)
#endif
for (j = 0; j < ic->methodscount; j++) {
- classinfo *sc = c;
-
- while (sc) {
- for (m = 0; m < sc->methodscount; m++) {
- methodinfo *mi = &(sc->methods[m]);
+ for (sc = c; sc != NULL; sc = sc->super.cls) {
+ for (k = 0; k < sc->methodscount; k++) {
+ m = &(sc->methods[k]);
- if (method_canoverwrite(mi, &(ic->methods[j]))) {
- /* method mi overwrites the (abstract) method */
+ 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]). */
+ /* 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
- v->interfacetable[-i][j] = v->table[mi->vftblindex];
+
+ /* XXX taken from gcj */
+ /* check for ACC_STATIC: IncompatibleClassChangeError */
+
+ /* 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:
;
}
return false;
/* everything ok */
+
return true;
}
projects / cacao.git / blobdiff