/* src/vm/linker.c - class linker functions
- 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
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
This file is part of CACAO.
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Reinhard Grafl
-
- Changes: Andreas Krall
- Roman Obermaiser
- Mark Probst
- Edwin Steiner
- Christian Thalinger
-
- $Id: linker.c 4388 2006-01-30 15:44:52Z twisti $
-
*/
#include "config.h"
#include <assert.h>
+#include <stdint.h>
#include "vm/types.h"
#include "mm/memory.h"
+
#include "native/native.h"
-#include "vm/builtin.h"
+
+#include "threads/lock-common.h"
+#include "threads/mutex.hpp"
+
+#include "toolbox/logging.h"
+
+#include "vm/access.h"
+#include "vm/array.h"
#include "vm/class.h"
#include "vm/classcache.h"
-#include "vm/exceptions.h"
+#include "vm/exceptions.hpp"
+#include "vm/globals.hpp"
#include "vm/loader.h"
#include "vm/options.h"
-#include "vm/resolve.h"
-#include "vm/statistics.h"
-#include "vm/stringlocal.h"
+#include "vm/primitive.hpp"
+#include "vm/rt-timing.h"
+#include "vm/string.hpp"
+#include "vm/vm.hpp"
+
+#include "vm/jit/asmpart.h"
+#include "vm/jit/stubs.hpp"
+
+
+/* debugging macros ***********************************************************/
+
+#if !defined(NDEBUG)
+# define TRACELINKCLASS(c) \
+ do { \
+ if (opt_TraceLinkClass) { \
+ log_start(); \
+ log_print("[Linking "); \
+ class_print((c)); \
+ log_print("]"); \
+ log_finish(); \
+ } \
+ } while (0)
+#else
+# define TRACELINKCLASS(c)
+#endif
-/* global variables ***********************************************************/
+/* #include "vm/resolve.h" */
+/* copied prototype to avoid bootstrapping problem: */
+classinfo *resolve_classref_or_classinfo_eager(classref_or_classinfo cls, bool checkaccess);
-static s4 interfaceindex; /* sequential numbering of interfaces */
-static s4 classvalue;
+#if defined(ENABLE_STATISTICS)
+# include "vm/statistics.h"
+#endif
+#if !defined(NDEBUG) && defined(ENABLE_INLINING)
+#define INLINELOG(code) do { if (opt_TraceInlining) { code } } while (0)
+#else
+#define INLINELOG(code)
+#endif
-/* primitivetype_table *********************************************************
- Structure for primitive classes: contains the class for wrapping
- the primitive type, the primitive class, the name of the class for
- wrapping, the one character type signature and the name of the
- primitive class.
-
- CAUTION: Don't change the order of the types. This table is indexed
- by the ARRAYTYPE_ constants (except ARRAYTYPE_OBJECT).
+/* global variables ***********************************************************/
-*******************************************************************************/
+static s4 interfaceindex; /* sequential numbering of interfaces */
+static s4 classvalue;
-primitivetypeinfo primitivetype_table[PRIMITIVETYPE_COUNT] = {
- { NULL, NULL, "java/lang/Integer", 'I', "int" , "[I", NULL, NULL },
- { NULL, NULL, "java/lang/Long", 'J', "long" , "[J", NULL, NULL },
- { NULL, NULL, "java/lang/Float", 'F', "float" , "[F", NULL, NULL },
- { NULL, NULL, "java/lang/Double", 'D', "double" , "[D", NULL, NULL },
- { NULL, NULL, NULL, 0 , NULL , NULL, NULL, NULL },
- { NULL, NULL, "java/lang/Byte", 'B', "byte" , "[B", NULL, NULL },
- { NULL, NULL, "java/lang/Character", 'C', "char" , "[C", NULL, NULL },
- { NULL, NULL, "java/lang/Short", 'S', "short" , "[S", NULL, NULL },
- { NULL, NULL, "java/lang/Boolean", 'Z', "boolean" , "[Z", NULL, NULL },
- { NULL, NULL, NULL, 0 , NULL , NULL, NULL, NULL },
- { NULL, NULL, "java/lang/Void", 'V', "void" , NULL, NULL, NULL }
-};
+Mutex *linker_classrenumber_mutex;
/* private functions **********************************************************/
-static bool link_primitivetype_table(void);
static classinfo *link_class_intern(classinfo *c);
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);
/* linker_init *****************************************************************
- Initializes the linker subsystem.
+ Initializes the linker subsystem and links classes required for the
+ primitive table.
*******************************************************************************/
-bool linker_init(void)
+void linker_preinit(void)
{
- /* reset interface index */
+ TRACESUBSYSTEMINITIALIZATION("linker_preinit");
+
+ /* Reset interface index. */
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 defined(ENABLE_THREADS)
+ /* create the global mutex */
- if (!link_class(class_java_lang_Class))
- return false;
+ linker_classrenumber_mutex = Mutex_new();
+#endif
- /* now set the header.vftbl of all classes which were created
- before java.lang.Class was linked */
+ /* Link the most basic classes. */
- class_postset_header_vftbl();
+ if (!link_class(class_java_lang_Object))
+ vm_abort("linker_preinit: linking java/lang/Object failed");
+#if defined(ENABLE_JAVASE)
+ if (!link_class(class_java_lang_Cloneable))
+ vm_abort("linker_preinit: linking java/lang/Cloneable failed");
- /* link important system classes */
+ if (!link_class(class_java_io_Serializable))
+ vm_abort("linker_preinit: linking java/io/Serializable failed");
+#endif
+}
- if (!link_class(class_java_lang_Object))
- return false;
- if (!link_class(class_java_lang_String))
- return false;
+/* linker_init *****************************************************************
- if (!link_class(class_java_lang_Cloneable))
- return false;
+ Links all classes required in the VM.
- if (!link_class(class_java_io_Serializable))
- return false;
+*******************************************************************************/
+
+void linker_init(void)
+{
+ TRACESUBSYSTEMINITIALIZATION("linker_init");
+
+ /* 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))
+ vm_abort("linker_init: linking java/lang/Class failed");
+
+ /* Now set the header.vftbl of all classes which were created
+ before java.lang.Class was linked. */
+ class_postset_header_vftbl();
- /* link classes for wrapping primitive types */
+ /* Link primitive-type wrapping classes. */
+#if defined(ENABLE_JAVASE)
if (!link_class(class_java_lang_Void))
- return false;
+ vm_abort("linker_init: linking failed");
+#endif
if (!link_class(class_java_lang_Boolean))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_Byte))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_Character))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_Short))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_Integer))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_Long))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_Float))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_Double))
- return false;
+ vm_abort("linker_init: linking failed");
+ /* Link important system classes. */
- /* load some other important classes */
+ if (!link_class(class_java_lang_String))
+ vm_abort("linker_init: linking java/lang/String failed");
+#if defined(ENABLE_JAVASE)
if (!link_class(class_java_lang_ClassLoader))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_SecurityManager))
- return false;
+ vm_abort("linker_init: linking failed");
+#endif
if (!link_class(class_java_lang_System))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_Thread))
- return false;
+ vm_abort("linker_init: linking failed");
+#if defined(ENABLE_JAVASE)
if (!link_class(class_java_lang_ThreadGroup))
- return false;
+ vm_abort("linker_init: linking failed");
+#endif
+
+ if (!link_class(class_java_lang_Throwable))
+ vm_abort("linker_init: linking failed");
+
+#if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
+ if (!link_class(class_java_lang_VMSystem))
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_VMThread))
- return false;
+ vm_abort("linker_init: linking failed");
+
+ if (!link_class(class_java_lang_VMThrowable))
+ vm_abort("linker_init: linking failed");
+#endif
+
+ /* Important system exceptions. */
+ if (!link_class(class_java_lang_Exception))
+ vm_abort("linker_init: linking failed");
+
+ if (!link_class(class_java_lang_ClassNotFoundException))
+ vm_abort("linker_init: linking failed");
+
+ if (!link_class(class_java_lang_RuntimeException))
+ vm_abort("linker_init: linking failed");
/* some classes which may be used more often */
+#if defined(ENABLE_JAVASE)
if (!link_class(class_java_lang_StackTraceElement))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_reflect_Constructor))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_reflect_Field))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_lang_reflect_Method))
- return false;
+ vm_abort("linker_init: linking failed");
+
+# if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
+ if (!link_class(class_java_lang_reflect_VMConstructor))
+ vm_abort("linker_init: linking failed");
+
+ if (!link_class(class_java_lang_reflect_VMField))
+ vm_abort("linker_init: linking failed");
+
+ if (!link_class(class_java_lang_reflect_VMMethod))
+ vm_abort("linker_init: linking failed");
+# endif
if (!link_class(class_java_security_PrivilegedAction))
- return false;
+ vm_abort("linker_init: linking failed");
if (!link_class(class_java_util_Vector))
- return false;
+ vm_abort("linker_init: linking failed");
+
+ if (!link_class(class_java_util_HashMap))
+ vm_abort("linker_init: linking failed");
+
+# if defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
+ if (!link_class(class_sun_misc_Signal))
+ vm_abort("linker_init: linking failed");
+
+ if (!link_class(class_sun_reflect_MagicAccessorImpl))
+ vm_abort("linker_init: linking failed");
+# endif
if (!link_class(arrayclass_java_lang_Object))
- return false;
+ vm_abort("linker_init: linking failed");
+#endif
/* create pseudo classes used by the typechecker */
/* pseudo class for Arraystubs (extends java.lang.Object) */
-
- 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);
- }
+ pseudo_class_Arraystub->state |= CLASS_LOADED;
+ pseudo_class_Arraystub->super = class_java_lang_Object;
+
+#if defined(ENABLE_JAVASE)
+
+ pseudo_class_Arraystub->interfacescount = 2;
+ pseudo_class_Arraystub->interfaces = MNEW(classinfo*, 2);
+ pseudo_class_Arraystub->interfaces[0] = class_java_lang_Cloneable;
+ pseudo_class_Arraystub->interfaces[1] = class_java_io_Serializable;
+
+#elif defined(ENABLE_JAVAME_CLDC1_1)
+
+ pseudo_class_Arraystub->interfacescount = 0;
+ pseudo_class_Arraystub->interfaces = NULL;
+
+#else
+# error unknown Java configuration
+#endif
+
+ if (!classcache_store_unique(pseudo_class_Arraystub))
+ vm_abort("linker_init: could not cache pseudo_class_Arraystub");
if (!link_class(pseudo_class_Arraystub))
- return false;
+ vm_abort("linker_init: linking pseudo_class_Arraystub failed");
/* pseudo class representing the null type */
- pseudo_class_Null = class_create_classinfo(utf_new_char("$NULL$"));
+ 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;
+ pseudo_class_Null->super = class_java_lang_Object;
- if (!classcache_store_unique(pseudo_class_Null)) {
- log_text("could not cache pseudo_class_Null");
- assert(0);
- }
+ if (!classcache_store_unique(pseudo_class_Null))
+ vm_abort("linker_init: could not cache pseudo_class_Null");
if (!link_class(pseudo_class_Null))
- return false;
+ vm_abort("linker_init: linking failed");
/* pseudo class representing new uninitialized objects */
- pseudo_class_New = class_create_classinfo(utf_new_char("$NEW$"));
+ 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_unique(pseudo_class_New)) {
- log_text("could not cache pseudo_class_New");
- assert(0);
- }
+ pseudo_class_New->super = class_java_lang_Object;
- /* create classes representing primitive types */
-
- if (!link_primitivetype_table())
- return false;
+ if (!classcache_store_unique(pseudo_class_New))
+ vm_abort("linker_init: could not cache pseudo_class_New");
-
- /* Correct vftbl-entries (retarded loading and linking of class */
- /* java/lang/String). */
+ /* Correct vftbl-entries (retarded loading and linking of class
+ java/lang/String). */
stringtable_update();
-
- return true;
}
-/* link_primitivetype_table ****************************************************
+/* link_class ******************************************************************
- Create classes representing primitive types.
+ Wrapper function for link_class_intern to ease monitor enter/exit
+ and exception handling.
*******************************************************************************/
-static bool link_primitivetype_table(void)
-{
- classinfo *c;
- utf *u;
- s4 i;
+classinfo *link_class(classinfo *c)
+{
+ classinfo *r;
+#if defined(ENABLE_RT_TIMING)
+ struct timespec time_start, time_end;
+#endif
+
+ RT_TIMING_GET_TIME(time_start);
- for (i = 0; i < PRIMITIVETYPE_COUNT; i++) {
- /* skip dummies */
+ if (c == NULL) {
+ exceptions_throw_nullpointerexception();
+ return NULL;
+ }
- if (!primitivetype_table[i].name)
- continue;
-
- /* create primitive class */
+ LOCK_MONITOR_ENTER(c);
- c = class_create_classinfo(utf_new_char(primitivetype_table[i].name));
+ /* Maybe the class is currently linking or is already linked.*/
- c->flags = ACC_PUBLIC | ACC_FINAL | ACC_ABSTRACT;
-
- /* prevent loader from loading primitive class */
+ if ((c->state & CLASS_LINKING) || (c->state & CLASS_LINKED)) {
+ LOCK_MONITOR_EXIT(c);
- c->state |= CLASS_LOADED;
+ return c;
+ }
- /* INFO: don't put primitive classes into the classcache */
+#if defined(ENABLE_STATISTICS)
+ /* measure time */
- if (!link_class(c))
- return false;
+ if (opt_getcompilingtime)
+ compilingtime_stop();
- primitivetype_table[i].class_primitive = c;
+ if (opt_getloadingtime)
+ loadingtime_start();
+#endif
- /* create class for wrapping the primitive type */
+ /* call the internal function */
- u = utf_new_char(primitivetype_table[i].wrapname);
+ r = link_class_intern(c);
- if (!(c = load_class_bootstrap(u)))
- return false;
+ /* If return value is NULL, we had a problem and the class is not
+ linked. */
- primitivetype_table[i].class_wrap = c;
+ if (r == NULL)
+ c->state &= ~CLASS_LINKING;
- /* create the primitive array class */
+#if defined(ENABLE_STATISTICS)
+ /* measure time */
- if (primitivetype_table[i].arrayname) {
- 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;
+ if (opt_getloadingtime)
+ loadingtime_stop();
- primitivetype_table[i].arrayclass = c;
+ if (opt_getcompilingtime)
+ compilingtime_start();
+#endif
- assert(c->state & CLASS_LOADED);
+ LOCK_MONITOR_EXIT(c);
- if (!(c->state & CLASS_LINKED))
- if (!link_class(c))
- return false;
+ RT_TIMING_GET_TIME(time_end);
- primitivetype_table[i].arrayvftbl = c->vftbl;
- }
- }
+ RT_TIMING_TIME_DIFF(time_start,time_end,RT_TIMING_LINK_TOTAL);
- return true;
+ return r;
}
-/* link_class ******************************************************************
+/* linker_overwrite_method *****************************************************
- Wrapper function for link_class_intern to ease monitor enter/exit
- and exception handling.
+ Overwrite a method with another one, update method flags and check
+ assumptions.
+
+ IN:
+ mg................the general method being overwritten
+ ms................the overwriting (more specialized) method
+ wl................worklist where to add invalidated methods
+
+ RETURN VALUE:
+ true..............everything ok
+ false.............an exception has been thrown
*******************************************************************************/
-classinfo *link_class(classinfo *c)
+static bool linker_overwrite_method(methodinfo *mg,
+ methodinfo *ms,
+ method_worklist **wl)
{
- classinfo *r;
+ classinfo *cg;
+ classinfo *cs;
- if (!c) {
- exceptions_throw_nullpointerexception();
- return NULL;
- }
+ cg = mg->clazz;
+ cs = ms->clazz;
-#if defined(USE_THREADS)
- /* enter a monitor on the class */
+ /* overriding a final method is illegal */
- builtin_monitorenter((java_objectheader *) c);
-#endif
+ if (mg->flags & ACC_FINAL) {
+ exceptions_throw_verifyerror(mg, "Overriding final method");
+ return false;
+ }
- /* maybe the class is already linked */
+ /* method ms overwrites method mg */
- if (c->state & CLASS_LINKED) {
-#if defined(USE_THREADS)
- builtin_monitorexit((java_objectheader *) c);
-#endif
+#if defined(ENABLE_VERIFIER)
+ /* Add loading constraints (for the more general types of method mg). */
+ /* Not for <init>, as it is not invoked virtually. */
- return c;
+ if ((ms->name != utf_init)
+ && !classcache_add_constraints_for_params(
+ cs->classloader, cg->classloader, mg))
+ {
+ return false;
}
+#endif
-#if defined(ENABLE_STATISTICS)
- /* measure time */
+ /* inherit the vftbl index, and record the overwriting */
- if (getcompilingtime)
- compilingtime_stop();
+ ms->vftblindex = mg->vftblindex;
+ ms->overwrites = mg;
- if (getloadingtime)
- loadingtime_start();
-#endif
+ /* update flags and check assumptions */
+ /* <init> methods are a special case, as they are never dispatched dynamically */
- /* call the internal function */
+ if ((ms->flags & ACC_METHOD_IMPLEMENTED) && ms->name != utf_init) {
+ do {
- r = link_class_intern(c);
+#if defined(ENABLE_TLH)
+ if (mg->flags & ACC_METHOD_MONOMORPHY_USED) {
+ printf("%s/%s is evil! the siner is %s/%s\n", mg->clazz->name->text, mg->name->text,
+ ms->clazz->name->text, ms->name->text);
+ ms->flags |= ACC_METHOD_PARENT_MONOMORPHY_USED;
+ }
+#endif
- /* if return value is NULL, we had a problem and the class is not linked */
+ if (mg->flags & ACC_METHOD_IMPLEMENTED) {
+ /* this adds another implementation */
- if (!r)
- c->state &= ~CLASS_LINKING;
+ mg->flags &= ~ACC_METHOD_MONOMORPHIC;
-#if defined(ENABLE_STATISTICS)
- /* measure time */
+ INLINELOG( printf("becomes polymorphic: "); method_println(mg); );
- if (getloadingtime)
- loadingtime_stop();
+ method_break_assumption_monomorphic(mg, wl);
+ }
+ else {
+ /* this is the first implementation */
- if (getcompilingtime)
- compilingtime_start();
-#endif
+ mg->flags |= ACC_METHOD_IMPLEMENTED;
-#if defined(USE_THREADS)
- /* leave the monitor */
+ INLINELOG( printf("becomes implemented: "); method_println(mg); );
+ }
- builtin_monitorexit((java_objectheader *) c);
-#endif
+ ms = mg;
+ mg = mg->overwrites;
+ } while (mg != NULL);
+ }
- return r;
+ return true;
}
s4 vftbllength; /* vftbllength of current class */
s4 interfacetablelength; /* interface table length */
vftbl_t *v; /* vftbl of current class */
- s4 i,j; /* interface/method/field counter */
+ s4 i; /* interface/method/field counter */
arraydescriptor *arraydesc; /* descriptor for array classes */
+ method_worklist *worklist; /* worklist for recompilation */
+#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_subclasses;
+#endif
- /* the class is already linked */
+ RT_TIMING_GET_TIME(time_start);
- if (c->state & CLASS_LINKED)
- return c;
-
- if (linkverbose)
- log_message_class("Linking class: ", c);
+ TRACELINKCLASS(c);
/* the class must be loaded */
/* XXX should this be a specific exception? */
assert(c->state & CLASS_LOADED);
+ /* This is check in link_class. */
+
+ assert(!(c->state & CLASS_LINKED));
+
/* 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 */
c->state |= CLASS_LINKING;
arraydesc = NULL;
+ worklist = NULL;
- /* check interfaces */
+ /* Link the super interfaces. */
for (i = 0; i < c->interfacescount; i++) {
- /* resolve this super interface */
-
- if (!resolve_classref_or_classinfo(NULL, c->interfaces[i], resolveEager,
- true, false, &tc))
- return NULL;
-
- c->interfaces[i].cls = tc;
-
- /* detect circularity */
-
- if (tc == c) {
- *exceptionptr =
- new_exception_utfmessage(string_java_lang_ClassCircularityError,
- c->name);
- return NULL;
- }
-
- assert(tc->state & CLASS_LOADED);
-
- if (!(tc->flags & ACC_INTERFACE)) {
- *exceptionptr =
- new_exception_message(string_java_lang_IncompatibleClassChangeError,
- "Implementing class");
- return NULL;
- }
+ tc = c->interfaces[i];
if (!(tc->state & CLASS_LINKED))
if (!link_class(tc))
super = NULL;
- if (c->super.any == NULL) { /* class java.lang.Object */
+ /* Check for java/lang/Object. */
+
+ if (c->super == NULL) {
c->index = 0;
- c->instancesize = sizeof(java_objectheader);
+ c->instancesize = sizeof(java_object_t);
vftbllength = supervftbllength = 0;
c->finalizer = NULL;
+ }
+ else {
+ /* Get super class. */
- } else {
- /* resolve super class */
+ super = c->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,
- c->name);
- return NULL;
- }
-
- assert(super->state & CLASS_LOADED);
-
- if (super->flags & ACC_INTERFACE) {
- /* java.lang.IncompatibleClassChangeError: class a has interface java.lang.Cloneable 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 super class if necessary. */
if (!(super->state & CLASS_LINKED))
if (!link_class(super))
return NULL;
+ /* OR the ACC_CLASS_HAS_POINTERS and the ACC_CLASS_REFERENCE_*
+ flags. */
+
+ c->flags |= (super->flags &
+ (ACC_CLASS_HAS_POINTERS | ACC_CLASS_REFERENCE_MASK));
+
/* 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_resolving);
/* compute vftbl length */
if (tc->methods[j].flags & ACC_PRIVATE)
goto notfoundvftblindex;
- if (tc->methods[j].flags & ACC_FINAL) {
- /* class a overrides final method . */
- *exceptionptr =
- new_exception(string_java_lang_VerifyError);
- return NULL;
+ /* 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;
}
- m->vftblindex = tc->methods[j].vftblindex;
+ if (!linker_overwrite_method(&(tc->methods[j]), m, &worklist))
+ return NULL;
+
goto foundvftblindex;
}
}
- tc = tc->super.cls;
+ tc = tc->super;
}
notfoundvftblindex:
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;
+ ic = c->interfaces[i];
for (j = 0; j < ic->methodscount; j++) {
im = &(ic->methods[j]);
/* 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) {
for (k = 0; k < tc->methodscount; k++) {
if (method_canoverwrite(im, &(tc->methods[k])))
goto noabstractmethod;
}
-
- tc = tc->super.cls;
}
abstractmethodscount++;
c->methodscount + abstractmethodscount);
for (i = 0; i < c->interfacescount; i++) {
- ic = c->interfaces[i].cls;
+ ic = c->interfaces[i];
for (j = 0; j < ic->methodscount; j++) {
im = &(ic->methods[j]);
/* 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) {
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->clazz = c;
+ am->flags |= ACC_MIRANDA;
noabstractmethod2:
;
}
}
}
+ RT_TIMING_GET_TIME(time_abstract);
#if defined(ENABLE_STATISTICS)
/* compute interfacetable length */
interfacetablelength = 0;
- tc = c;
- while (tc) {
+
+ for (tc = c; tc != NULL; tc = tc->super) {
for (i = 0; i < tc->interfacescount; i++) {
- s4 h = class_highestinterface(tc->interfaces[i].cls) + 1;
+ s4 h = class_highestinterface(tc->interfaces[i]) + 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->vftbl = v;
- v->class = c;
- v->vftbllength = vftbllength;
+
+ c->vftbl = v;
+ v->clazz = 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++) {
+#if defined(ENABLE_JIT)
+# if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ v->table[i] = (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
+ else
+# endif
+ v->table[i] = (methodptr) (ptrint) &asm_abstractmethoderror;
+#else
+ v->table[i] = (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
+#endif
+ }
+
/* 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 = CompilerStub_generate(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);
/* compute instance size and offset of each field */
if (!(f->flags & ACC_STATIC)) {
dsize = descriptor_typesize(f->parseddesc);
- c->instancesize = ALIGN(c->instancesize, dsize);
+ c->instancesize = MEMORY_ALIGN(c->instancesize, dsize);
f->offset = c->instancesize;
c->instancesize += dsize;
}
}
+ RT_TIMING_GET_TIME(time_offsets);
/* initialize interfacetable and interfacevftbllength */
-
+
v->interfacevftbllength = MNEW(s4, interfacetablelength);
#if defined(ENABLE_STATISTICS)
v->interfacevftbllength[i] = 0;
v->interfacetable[-i] = NULL;
}
-
+
/* add interfaces */
-
- for (tc = c; tc != NULL; tc = tc->super.cls)
+
+ for (tc = c; tc != NULL; tc = tc->super)
for (i = 0; i < tc->interfacescount; i++)
- linker_addinterface(c, tc->interfaces[i].cls);
+ if (!linker_addinterface(c, tc->interfaces[i]))
+ 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++) {
- if (!m->exceptiontable[j].catchtype.any)
- continue;
- if (!resolve_classref_or_classinfo(NULL,
- m->exceptiontable[j].catchtype,
- resolveEager, true, false,
- &(m->exceptiontable[j].catchtype.cls)))
- return NULL;
- }
- }
-
/* 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 (linkverbose)
- log_message_class("Linking done class: ", c);
+ /* check worklist */
+
+ /* XXX must this also be done in case of exception? */
+
+ while (worklist != NULL) {
+ method_worklist *wi = worklist;
+
+ worklist = worklist->next;
+
+ INLINELOG( printf("MUST BE RECOMPILED: "); method_println(wi->m); );
+ jit_invalidate_code(wi->m);
+
+ /* XXX put worklist into dump memory? */
+ FREE(wi, method_worklist);
+ }
+
+ 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_subclasses ,RT_TIMING_LINK_SUBCLASS);
/* just return c to show that we didn't had a problem */
/* c is an array of references */
desc->arraytype = ARRAYTYPE_OBJECT;
desc->componentsize = sizeof(void*);
- desc->dataoffset = OFFSET(java_objectarray, data);
+ desc->dataoffset = OFFSET(java_objectarray_t, data);
compvftbl = comp->vftbl;
switch (c->name->text[1]) {
case 'Z':
desc->arraytype = ARRAYTYPE_BOOLEAN;
- desc->dataoffset = OFFSET(java_booleanarray,data);
+ desc->dataoffset = OFFSET(java_booleanarray_t,data);
desc->componentsize = sizeof(u1);
break;
case 'B':
desc->arraytype = ARRAYTYPE_BYTE;
- desc->dataoffset = OFFSET(java_bytearray,data);
+ desc->dataoffset = OFFSET(java_bytearray_t,data);
desc->componentsize = sizeof(u1);
break;
case 'C':
desc->arraytype = ARRAYTYPE_CHAR;
- desc->dataoffset = OFFSET(java_chararray,data);
+ desc->dataoffset = OFFSET(java_chararray_t,data);
desc->componentsize = sizeof(u2);
break;
case 'D':
desc->arraytype = ARRAYTYPE_DOUBLE;
- desc->dataoffset = OFFSET(java_doublearray,data);
+ desc->dataoffset = OFFSET(java_doublearray_t,data);
desc->componentsize = sizeof(double);
break;
case 'F':
desc->arraytype = ARRAYTYPE_FLOAT;
- desc->dataoffset = OFFSET(java_floatarray,data);
+ desc->dataoffset = OFFSET(java_floatarray_t,data);
desc->componentsize = sizeof(float);
break;
case 'I':
desc->arraytype = ARRAYTYPE_INT;
- desc->dataoffset = OFFSET(java_intarray,data);
+ desc->dataoffset = OFFSET(java_intarray_t,data);
desc->componentsize = sizeof(s4);
break;
case 'J':
desc->arraytype = ARRAYTYPE_LONG;
- desc->dataoffset = OFFSET(java_longarray,data);
+ desc->dataoffset = OFFSET(java_longarray_t,data);
desc->componentsize = sizeof(s8);
break;
case 'S':
desc->arraytype = ARRAYTYPE_SHORT;
- desc->dataoffset = OFFSET(java_shortarray,data);
+ desc->dataoffset = OFFSET(java_shortarray_t,data);
desc->componentsize = sizeof(s2);
break;
default:
- *exceptionptr = new_noclassdeffounderror(c->name);
+ exceptions_throw_noclassdeffounderror(c->name);
return NULL;
}
XXX
+ ATTENTION: DO NOT REMOVE ANY OF THE LOCKING MECHANISMS BELOW:
+ This function needs to take the class renumber lock and stop the
+ world during class renumbering. The lock is used in C code which
+ is not that performance critical. Whereas JIT code uses critical
+ sections to atomically access the class values.
+
*******************************************************************************/
static void linker_compute_subclasses(classinfo *c)
{
-#if defined(USE_THREADS)
-#if defined(NATIVE_THREADS)
- compiler_lock();
-#else
- intsDisable();
-#endif
-#endif
+ Mutex_lock(linker_classrenumber_mutex);
if (!(c->flags & ACC_INTERFACE)) {
- c->nextsub = 0;
- c->sub = 0;
+ c->nextsub = NULL;
+ c->sub = NULL;
}
- if (!(c->flags & ACC_INTERFACE) && (c->super.any != NULL)) {
- c->nextsub = c->super.cls->sub;
- c->super.cls->sub = c;
+ if (!(c->flags & ACC_INTERFACE) && (c->super != NULL)) {
+ c->nextsub = c->super->sub;
+ c->super->sub = c;
}
classvalue = 0;
linker_compute_class_values(class_java_lang_Object);
-#if defined(USE_THREADS)
-#if defined(NATIVE_THREADS)
- compiler_unlock();
-#else
- intsRestore();
-#endif
-#endif
+ Mutex_unlock(linker_classrenumber_mutex);
}
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;
- 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])
- return;
+ 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(ENABLE_STATISTICS)
if (opt_stat)
#endif
for (j = 0; j < ic->methodscount; j++) {
- classinfo *sc = c;
+ for (sc = c; sc != NULL; sc = sc->super) {
+ 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
+
+ /* XXX taken from gcj */
+ /* check for ACC_STATIC: IncompatibleClassChangeError */
+
+ /* check for !ACC_PUBLIC: IllegalAccessError */
- while (sc) {
- for (m = 0; m < sc->methodscount; m++) {
- methodinfo *mi = &(sc->methods[m]);
+ /* check for ACC_ABSTRACT: AbstracMethodError,
+ not sure about that one */
- if (method_canoverwrite(mi, &(ic->methods[j]))) {
- v->interfacetable[-i][j] = v->table[mi->vftblindex];
+ v->interfacetable[-i][j] = v->table[m->vftblindex];
goto foundmethod;
}
}
- sc = sc->super.cls;
}
+
+ /* If no method was found, insert the AbstractMethodError
+ stub. */
+
+#if defined(ENABLE_JIT)
+# if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ v->interfacetable[-i][j] =
+ (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
+ else
+# endif
+ v->interfacetable[-i][j] =
+ (methodptr) (ptrint) &asm_abstractmethoderror;
+#else
+ v->interfacetable[-i][j] =
+ (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
+#endif
+
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]))
+ return false;
+
+ /* everything ok */
+
+ return true;
}
h = c->index;
for (i = 0; i < c->interfacescount; i++) {
- h2 = class_highestinterface(c->interfaces[i].cls);
+ h2 = class_highestinterface(c->interfaces[i]);
if (h2 > h)
h = h2;
* c-basic-offset: 4
* tab-width: 4
* End:
+ * vim:noexpandtab:sw=4:ts=4:
*/