1 /* src/vmcore/linker.c - class linker functions
3 Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
4 C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
5 E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
6 J. Wenninger, Institut f. Computersprachen - TU Wien
8 This file is part of CACAO.
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2, or (at
13 your option) any later version.
15 This program is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 $Id: linker.c 7675 2007-04-05 14:23:04Z michi $
36 #include "mm/memory.h"
37 #include "native/native.h"
39 #if defined(ENABLE_THREADS)
40 # include "threads/native/lock.h"
42 # include "threads/none/lock.h"
45 #include "toolbox/logging.h"
47 #include "vm/access.h"
48 #include "vm/exceptions.h"
49 #include "vm/stringlocal.h"
52 #include "vm/jit_interface.h"
54 #include "vmcore/class.h"
55 #include "vmcore/classcache.h"
56 #include "vmcore/loader.h"
57 #include "vmcore/options.h"
58 #include "vmcore/rt-timing.h"
60 /* #include "vm/resolve.h" */
61 /* copied prototype to avoid bootstrapping problem: */
62 classinfo *resolve_classref_or_classinfo_eager(classref_or_classinfo cls, bool checkaccess);
64 #if defined(ENABLE_STATISTICS)
65 # include "vmcore/statistics.h"
68 #if !defined(NDEBUG) && defined(ENABLE_INLINING)
69 #define INLINELOG(code) do { if (opt_inline_debug_log) { code } } while (0)
71 #define INLINELOG(code)
75 /* global variables ***********************************************************/
77 static s4 interfaceindex; /* sequential numbering of interfaces */
80 java_objectheader *linker_classrenumber_lock;
83 /* primitivetype_table *********************************************************
85 Structure for primitive classes: contains the class for wrapping
86 the primitive type, the primitive class, the name of the class for
87 wrapping, the one character type signature and the name of the
90 CAUTION: Don't change the order of the types. This table is indexed
91 by the ARRAYTYPE_ constants (except ARRAYTYPE_OBJECT).
93 *******************************************************************************/
95 primitivetypeinfo primitivetype_table[PRIMITIVETYPE_COUNT] = {
96 { NULL, NULL, "java/lang/Integer", 'I', "int" , "[I", NULL, NULL },
97 { NULL, NULL, "java/lang/Long", 'J', "long" , "[J", NULL, NULL },
98 { NULL, NULL, "java/lang/Float", 'F', "float" , "[F", NULL, NULL },
99 { NULL, NULL, "java/lang/Double", 'D', "double" , "[D", NULL, NULL },
100 { NULL, NULL, NULL, 0 , NULL , NULL, NULL, NULL },
101 { NULL, NULL, "java/lang/Byte", 'B', "byte" , "[B", NULL, NULL },
102 { NULL, NULL, "java/lang/Character", 'C', "char" , "[C", NULL, NULL },
103 { NULL, NULL, "java/lang/Short", 'S', "short" , "[S", NULL, NULL },
104 { NULL, NULL, "java/lang/Boolean", 'Z', "boolean" , "[Z", NULL, NULL },
105 { NULL, NULL, NULL, 0 , NULL , NULL, NULL, NULL },
106 #if defined(ENABLE_JAVASE)
107 { NULL, NULL, "java/lang/Void", 'V', "void" , NULL, NULL, NULL }
109 { NULL, NULL, NULL, 0 , NULL , NULL, NULL, NULL },
114 /* private functions **********************************************************/
116 static bool link_primitivetype_table(void);
117 static classinfo *link_class_intern(classinfo *c);
118 static arraydescriptor *link_array(classinfo *c);
119 static void linker_compute_class_values(classinfo *c);
120 static void linker_compute_subclasses(classinfo *c);
121 static bool linker_addinterface(classinfo *c, classinfo *ic);
122 static s4 class_highestinterface(classinfo *c);
125 /* linker_init *****************************************************************
127 Initializes the linker subsystem.
129 *******************************************************************************/
131 bool linker_init(void)
133 /* reset interface index */
137 /* create the global lock object */
139 linker_classrenumber_lock = NEW(java_objectheader);
141 /* link java.lang.Class as first class of the system, because we
142 need it's vftbl for all other classes so we can use a class as
145 if (!link_class(class_java_lang_Class))
148 /* now set the header.vftbl of all classes which were created
149 before java.lang.Class was linked */
151 class_postset_header_vftbl();
154 /* link important system classes */
156 if (!link_class(class_java_lang_Object))
159 if (!link_class(class_java_lang_String))
162 #if defined(ENABLE_JAVASE)
163 if (!link_class(class_java_lang_Cloneable))
166 if (!link_class(class_java_io_Serializable))
171 /* link classes for wrapping primitive types */
173 #if defined(ENABLE_JAVASE)
174 if (!link_class(class_java_lang_Void))
178 if (!link_class(class_java_lang_Boolean))
181 if (!link_class(class_java_lang_Byte))
184 if (!link_class(class_java_lang_Character))
187 if (!link_class(class_java_lang_Short))
190 if (!link_class(class_java_lang_Integer))
193 if (!link_class(class_java_lang_Long))
196 if (!link_class(class_java_lang_Float))
199 if (!link_class(class_java_lang_Double))
203 /* load some other important classes */
205 #if defined(ENABLE_JAVASE)
206 if (!link_class(class_java_lang_ClassLoader))
209 if (!link_class(class_java_lang_SecurityManager))
213 if (!link_class(class_java_lang_System))
216 if (!link_class(class_java_lang_Thread))
219 #if defined(ENABLE_JAVASE)
220 if (!link_class(class_java_lang_ThreadGroup))
224 #if defined(WITH_CLASSPATH_GNU)
225 if (!link_class(class_java_lang_VMSystem))
228 if (!link_class(class_java_lang_VMThread))
233 /* some classes which may be used more often */
235 #if defined(ENABLE_JAVASE)
236 if (!link_class(class_java_lang_StackTraceElement))
239 if (!link_class(class_java_lang_reflect_Constructor))
242 if (!link_class(class_java_lang_reflect_Field))
245 if (!link_class(class_java_lang_reflect_Method))
248 if (!link_class(class_java_security_PrivilegedAction))
251 if (!link_class(class_java_util_Vector))
254 if (!link_class(arrayclass_java_lang_Object))
259 /* create pseudo classes used by the typechecker */
261 /* pseudo class for Arraystubs (extends java.lang.Object) */
263 pseudo_class_Arraystub =
264 class_create_classinfo(utf_new_char("$ARRAYSTUB$"));
265 pseudo_class_Arraystub->state |= CLASS_LOADED;
266 pseudo_class_Arraystub->super.cls = class_java_lang_Object;
268 #if defined(ENABLE_JAVASE)
269 pseudo_class_Arraystub->interfacescount = 2;
270 pseudo_class_Arraystub->interfaces = MNEW(classref_or_classinfo, 2);
271 pseudo_class_Arraystub->interfaces[0].cls = class_java_lang_Cloneable;
272 pseudo_class_Arraystub->interfaces[1].cls = class_java_io_Serializable;
273 #elif defined(ENABLE_JAVAME_CLDC1_1)
274 pseudo_class_Arraystub->interfacescount = 0;
275 pseudo_class_Arraystub->interfaces = NULL;
278 if (!classcache_store_unique(pseudo_class_Arraystub)) {
279 log_text("could not cache pseudo_class_Arraystub");
283 if (!link_class(pseudo_class_Arraystub))
286 /* pseudo class representing the null type */
288 pseudo_class_Null = class_create_classinfo(utf_new_char("$NULL$"));
289 pseudo_class_Null->state |= CLASS_LOADED;
290 pseudo_class_Null->super.cls = class_java_lang_Object;
292 if (!classcache_store_unique(pseudo_class_Null))
293 vm_abort("linker_init: could not cache pseudo_class_Null");
295 if (!link_class(pseudo_class_Null))
298 /* pseudo class representing new uninitialized objects */
300 pseudo_class_New = class_create_classinfo(utf_new_char("$NEW$"));
301 pseudo_class_New->state |= CLASS_LOADED;
302 pseudo_class_New->state |= CLASS_LINKED; /* XXX is this allright? */
303 pseudo_class_New->super.cls = class_java_lang_Object;
305 if (!classcache_store_unique(pseudo_class_New))
306 vm_abort("linker_init: could not cache pseudo_class_New");
308 /* create classes representing primitive types */
310 if (!link_primitivetype_table())
314 /* Correct vftbl-entries (retarded loading and linking of class
315 java/lang/String). */
317 stringtable_update();
323 /* link_primitivetype_table ****************************************************
325 Create classes representing primitive types.
327 *******************************************************************************/
329 static bool link_primitivetype_table(void)
335 for (i = 0; i < PRIMITIVETYPE_COUNT; i++) {
338 if (!primitivetype_table[i].name)
341 /* create primitive class */
343 c = class_create_classinfo(utf_new_char(primitivetype_table[i].name));
345 /* primitive classes don't have a super class */
349 /* set flags and mark it as primitive class */
351 c->flags = ACC_PUBLIC | ACC_FINAL | ACC_ABSTRACT | ACC_CLASS_PRIMITIVE;
353 /* prevent loader from loading primitive class */
355 c->state |= CLASS_LOADED;
357 /* INFO: don't put primitive classes into the classcache */
362 primitivetype_table[i].class_primitive = c;
364 /* create class for wrapping the primitive type */
366 u = utf_new_char(primitivetype_table[i].wrapname);
367 c = load_class_bootstrap(u);
372 primitivetype_table[i].class_wrap = c;
374 /* create the primitive array class */
376 if (primitivetype_table[i].arrayname) {
377 u = utf_new_char(primitivetype_table[i].arrayname);
378 c = class_create_classinfo(u);
379 c = load_newly_created_array(c, NULL);
384 primitivetype_table[i].arrayclass = c;
386 assert(c->state & CLASS_LOADED);
388 if (!(c->state & CLASS_LINKED))
392 primitivetype_table[i].arrayvftbl = c->vftbl;
400 /* link_class ******************************************************************
402 Wrapper function for link_class_intern to ease monitor enter/exit
403 and exception handling.
405 *******************************************************************************/
407 classinfo *link_class(classinfo *c)
410 #if defined(ENABLE_RT_TIMING)
411 struct timespec time_start, time_end;
414 RT_TIMING_GET_TIME(time_start);
417 exceptions_throw_nullpointerexception();
421 LOCK_MONITOR_ENTER(c);
423 /* maybe the class is already linked */
425 if (c->state & CLASS_LINKED) {
426 LOCK_MONITOR_EXIT(c);
431 #if defined(ENABLE_STATISTICS)
434 if (opt_getcompilingtime)
435 compilingtime_stop();
437 if (opt_getloadingtime)
441 /* call the internal function */
443 r = link_class_intern(c);
445 /* if return value is NULL, we had a problem and the class is not linked */
448 c->state &= ~CLASS_LINKING;
450 #if defined(ENABLE_STATISTICS)
453 if (opt_getloadingtime)
456 if (opt_getcompilingtime)
457 compilingtime_start();
460 LOCK_MONITOR_EXIT(c);
462 RT_TIMING_GET_TIME(time_end);
464 RT_TIMING_TIME_DIFF(time_start,time_end,RT_TIMING_LINK_TOTAL);
470 /* linker_overwrite_method *****************************************************
472 Overwrite a method with another one, update method flags and check
476 mg................the general method being overwritten
477 ms................the overwriting (more specialized) method
478 wl................worklist where to add invalidated methods
481 true..............everything ok
482 false.............an exception has been thrown
484 *******************************************************************************/
486 static bool linker_overwrite_method(methodinfo *mg,
488 method_worklist **wl)
496 /* overriding a final method is illegal */
498 if (mg->flags & ACC_FINAL) {
499 exceptions_throw_verifyerror(mg, "Overriding final method");
503 /* method ms overwrites method mg */
505 #if defined(ENABLE_VERIFIER)
506 /* Add loading constraints (for the more general types of method mg). */
507 /* Not for <init>, as it is not invoked virtually. */
509 if ((ms->name != utf_init)
510 && !classcache_add_constraints_for_params(
511 cs->classloader, cg->classloader, mg))
517 /* inherit the vftbl index, and record the overwriting */
519 ms->vftblindex = mg->vftblindex;
522 /* update flags and check assumptions */
523 /* <init> methods are a special case, as they are never dispatched dynamically */
525 if ((ms->flags & ACC_METHOD_IMPLEMENTED) && ms->name != utf_init) {
527 if (mg->flags & ACC_METHOD_IMPLEMENTED) {
528 /* this adds another implementation */
530 mg->flags &= ~ACC_METHOD_MONOMORPHIC;
532 INLINELOG( printf("becomes polymorphic: "); method_println(mg); );
534 method_break_assumption_monomorphic(mg, wl);
537 /* this is the first implementation */
539 mg->flags |= ACC_METHOD_IMPLEMENTED;
541 INLINELOG( printf("becomes implemented: "); method_println(mg); );
546 } while (mg != NULL);
553 /* link_class_intern ***********************************************************
555 Tries to link a class. The function calculates the length in bytes
556 that an instance of this class requires as well as the VTBL for
557 methods and interface methods.
559 *******************************************************************************/
561 static classinfo *link_class_intern(classinfo *c)
563 classinfo *super; /* super class */
564 classinfo *tc; /* temporary class variable */
565 s4 supervftbllength; /* vftbllegnth of super class */
566 s4 vftbllength; /* vftbllength of current class */
567 s4 interfacetablelength; /* interface table length */
568 vftbl_t *v; /* vftbl of current class */
569 s4 i; /* interface/method/field counter */
570 arraydescriptor *arraydesc; /* descriptor for array classes */
571 method_worklist *worklist; /* worklist for recompilation */
572 #if defined(ENABLE_RT_TIMING)
573 struct timespec time_start, time_resolving, time_compute_vftbl,
574 time_abstract, time_compute_iftbl, time_fill_vftbl,
575 time_offsets, time_fill_iftbl, time_finalizer,
579 RT_TIMING_GET_TIME(time_start);
581 /* the class is already linked */
583 if (c->state & CLASS_LINKED)
588 log_message_class("Linking class: ", c);
591 /* the class must be loaded */
593 /* XXX should this be a specific exception? */
594 assert(c->state & CLASS_LOADED);
596 /* cache the self-reference of this class */
597 /* we do this for cases where the defining loader of the class */
598 /* has not yet been recorded as an initiating loader for the class */
599 /* this is needed so subsequent code can assume that self-refs */
600 /* will always resolve lazily */
601 /* No need to do it for the bootloader - it is always registered */
602 /* as initiating loader for the classes it loads. */
604 classcache_store(c->classloader,c,false);
606 /* this class is currently linking */
608 c->state |= CLASS_LINKING;
613 /* check interfaces */
615 for (i = 0; i < c->interfacescount; i++) {
616 /* resolve this super interface */
618 if ((tc = resolve_classref_or_classinfo_eager(c->interfaces[i], true)) == NULL)
621 c->interfaces[i].cls = tc;
623 /* detect circularity */
626 exceptions_throw_classcircularityerror(c);
630 assert(tc->state & CLASS_LOADED);
632 if (!(tc->flags & ACC_INTERFACE)) {
633 exceptions_throw_incompatibleclasschangeerror(tc,
634 "Implementing class");
638 if (!(tc->state & CLASS_LINKED))
643 /* check super class */
647 if (c->super.any == NULL) { /* class java.lang.Object */
649 c->instancesize = sizeof(java_objectheader);
651 vftbllength = supervftbllength = 0;
656 /* resolve super class */
658 if ((super = resolve_classref_or_classinfo_eager(c->super, true)) == NULL)
661 c->super.cls = super;
663 /* detect circularity */
666 exceptions_throw_classcircularityerror(c);
670 assert(super->state & CLASS_LOADED);
672 if (super->flags & ACC_INTERFACE) {
673 /* java.lang.IncompatibleClassChangeError: class a has interface java.lang.Cloneable as super class */
674 log_text("Interface specified as super class");
678 /* Don't allow extending final classes */
680 if (super->flags & ACC_FINAL) {
681 exceptions_throw_verifyerror(NULL,
682 "Cannot inherit from final class");
686 /* link the superclass if necessary */
688 if (!(super->state & CLASS_LINKED))
689 if (!link_class(super))
692 /* OR the ACC_CLASS_HAS_POINTERS flag */
694 c->flags |= (super->flags & ACC_CLASS_HAS_POINTERS);
696 /* handle array classes */
698 if (c->name->text[0] == '[')
699 if (!(arraydesc = link_array(c)))
702 if (c->flags & ACC_INTERFACE)
703 c->index = interfaceindex++;
705 c->index = super->index + 1;
707 c->instancesize = super->instancesize;
709 vftbllength = supervftbllength = super->vftbl->vftbllength;
711 c->finalizer = super->finalizer;
713 RT_TIMING_GET_TIME(time_resolving);
716 /* compute vftbl length */
718 for (i = 0; i < c->methodscount; i++) {
719 methodinfo *m = &(c->methods[i]);
721 if (!(m->flags & ACC_STATIC)) { /* is instance method */
727 for (j = 0; j < tc->methodscount; j++) {
728 if (method_canoverwrite(m, &(tc->methods[j]))) {
729 if (tc->methods[j].flags & ACC_PRIVATE)
730 goto notfoundvftblindex;
732 /* package-private methods in other packages */
733 /* must not be overridden */
734 /* (see Java Language Specification 8.4.8.1) */
735 if ( !(tc->methods[j].flags & (ACC_PUBLIC | ACC_PROTECTED))
736 && !SAME_PACKAGE(c,tc) )
738 goto notfoundvftblindex;
741 if (!linker_overwrite_method(&(tc->methods[j]), m, &worklist))
744 goto foundvftblindex;
752 m->vftblindex = (vftbllength++);
757 RT_TIMING_GET_TIME(time_compute_vftbl);
760 /* Check all interfaces of an abstract class (maybe be an
761 interface too) for unimplemented methods. Such methods are
762 called miranda-methods and are marked with the ACC_MIRANDA
763 flag. VMClass.getDeclaredMethods does not return such
766 if (c->flags & ACC_ABSTRACT) {
769 s4 abstractmethodscount;
773 abstractmethodscount = 0;
775 /* check all interfaces of the abstract class */
777 for (i = 0; i < c->interfacescount; i++) {
778 ic = c->interfaces[i].cls;
780 for (j = 0; j < ic->methodscount; j++) {
781 im = &(ic->methods[j]);
783 /* skip `<clinit>' and `<init>' */
785 if ((im->name == utf_clinit) || (im->name == utf_init))
788 for (tc = c; tc != NULL; tc = tc->super.cls) {
789 for (k = 0; k < tc->methodscount; k++) {
790 if (method_canoverwrite(im, &(tc->methods[k])))
791 goto noabstractmethod;
795 abstractmethodscount++;
802 if (abstractmethodscount > 0) {
805 /* reallocate methods memory */
807 c->methods = MREALLOC(c->methods, methodinfo, c->methodscount,
808 c->methodscount + abstractmethodscount);
810 for (i = 0; i < c->interfacescount; i++) {
811 ic = c->interfaces[i].cls;
813 for (j = 0; j < ic->methodscount; j++) {
814 im = &(ic->methods[j]);
816 /* skip `<clinit>' and `<init>' */
818 if ((im->name == utf_clinit) || (im->name == utf_init))
821 for (tc = c; tc != NULL; tc = tc->super.cls) {
822 for (k = 0; k < tc->methodscount; k++) {
823 if (method_canoverwrite(im, &(tc->methods[k])))
824 goto noabstractmethod2;
828 /* Copy the method found into the new c->methods
829 array and tag it as miranda-method. */
831 am = &(c->methods[c->methodscount]);
834 MCOPY(am, im, methodinfo, 1);
836 am->vftblindex = (vftbllength++);
838 am->flags |= ACC_MIRANDA;
846 RT_TIMING_GET_TIME(time_abstract);
849 #if defined(ENABLE_STATISTICS)
852 sizeof(vftbl_t) + (sizeof(methodptr) * (vftbllength - 1));
855 /* compute interfacetable length */
857 interfacetablelength = 0;
859 for (tc = c; tc != NULL; tc = tc->super.cls) {
860 for (i = 0; i < tc->interfacescount; i++) {
861 s4 h = class_highestinterface(tc->interfaces[i].cls) + 1;
863 if (h > interfacetablelength)
864 interfacetablelength = h;
867 RT_TIMING_GET_TIME(time_compute_iftbl);
869 /* allocate virtual function table */
871 v = (vftbl_t *) mem_alloc(sizeof(vftbl_t) +
872 sizeof(methodptr) * (vftbllength - 1) +
873 sizeof(methodptr*) * (interfacetablelength - (interfacetablelength > 0)));
874 v = (vftbl_t *) (((methodptr *) v) +
875 (interfacetablelength - 1) * (interfacetablelength > 1));
879 v->vftbllength = vftbllength;
880 v->interfacetablelength = interfacetablelength;
881 v->arraydesc = arraydesc;
883 /* store interface index in vftbl */
885 if (c->flags & ACC_INTERFACE)
886 v->baseval = -(c->index);
888 /* copy virtual function table of super class */
890 for (i = 0; i < supervftbllength; i++)
891 v->table[i] = super->vftbl->table[i];
893 /* Fill the remaining vftbl slots with the AbstractMethodError
894 stub (all after the super class slots, because they are already
897 for (; i < vftbllength; i++) {
898 #if defined(ENABLE_JIT)
899 # if defined(ENABLE_INTRP)
901 v->table[i] = (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
904 v->table[i] = (methodptr) (ptrint) &asm_abstractmethoderror;
906 v->table[i] = (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
910 /* add method stubs into virtual function table */
912 for (i = 0; i < c->methodscount; i++) {
913 methodinfo *m = &(c->methods[i]);
915 assert(m->stubroutine == NULL);
917 /* Don't create a compiler stub for abstract methods as they
918 throw an AbstractMethodError with the default stub in the
919 vftbl. This entry is simply copied by sub-classes. */
921 if (m->flags & ACC_ABSTRACT)
924 #if defined(ENABLE_JIT)
925 # if defined(ENABLE_INTRP)
927 m->stubroutine = intrp_createcompilerstub(m);
930 m->stubroutine = createcompilerstub(m);
932 m->stubroutine = intrp_createcompilerstub(m);
935 /* static methods are not in the vftbl */
937 if (m->flags & ACC_STATIC)
940 /* insert the stubroutine into the vftbl */
942 v->table[m->vftblindex] = (methodptr) (ptrint) m->stubroutine;
944 RT_TIMING_GET_TIME(time_fill_vftbl);
946 /* compute instance size and offset of each field */
948 for (i = 0; i < c->fieldscount; i++) {
950 fieldinfo *f = &(c->fields[i]);
952 if (!(f->flags & ACC_STATIC)) {
953 dsize = descriptor_typesize(f->parseddesc);
955 #if defined(__I386__) || defined(__ARM__)
956 /* On i386 and ARM we align double and s8 fields to
957 4-bytes. This matches what GCC does for struct
958 members. We must do the same as gcc here because the
959 offsets in native header structs like java_lang_Double
960 must match the offsets of the Java fields
961 (eg. java.lang.Double.value). */
963 c->instancesize = MEMORY_ALIGN(c->instancesize, 4);
965 c->instancesize = MEMORY_ALIGN(c->instancesize, dsize);
968 f->offset = c->instancesize;
969 c->instancesize += dsize;
972 RT_TIMING_GET_TIME(time_offsets);
974 /* initialize interfacetable and interfacevftbllength */
976 v->interfacevftbllength = MNEW(s4, interfacetablelength);
978 #if defined(ENABLE_STATISTICS)
980 count_vftbl_len += (4 + sizeof(s4)) * v->interfacetablelength;
983 for (i = 0; i < interfacetablelength; i++) {
984 v->interfacevftbllength[i] = 0;
985 v->interfacetable[-i] = NULL;
990 for (tc = c; tc != NULL; tc = tc->super.cls)
991 for (i = 0; i < tc->interfacescount; i++)
992 if (!linker_addinterface(c, tc->interfaces[i].cls))
995 RT_TIMING_GET_TIME(time_fill_iftbl);
997 /* add finalizer method (not for java.lang.Object) */
1002 fi = class_findmethod(c, utf_finalize, utf_void__void);
1005 if (!(fi->flags & ACC_STATIC))
1008 RT_TIMING_GET_TIME(time_finalizer);
1012 linker_compute_subclasses(c);
1014 RT_TIMING_GET_TIME(time_subclasses);
1016 /* revert the linking state and class is linked */
1018 c->state = (c->state & ~CLASS_LINKING) | CLASS_LINKED;
1020 /* check worklist */
1022 /* XXX must this also be done in case of exception? */
1024 while (worklist != NULL) {
1025 method_worklist *wi = worklist;
1027 worklist = worklist->next;
1029 INLINELOG( printf("MUST BE RECOMPILED: "); method_println(wi->m); );
1030 jit_invalidate_code(wi->m);
1032 /* XXX put worklist into dump memory? */
1033 FREE(wi, method_worklist);
1036 #if !defined(NDEBUG)
1038 log_message_class("Linking done class: ", c);
1041 RT_TIMING_TIME_DIFF(time_start ,time_resolving ,RT_TIMING_LINK_RESOLVE);
1042 RT_TIMING_TIME_DIFF(time_resolving ,time_compute_vftbl,RT_TIMING_LINK_C_VFTBL);
1043 RT_TIMING_TIME_DIFF(time_compute_vftbl,time_abstract ,RT_TIMING_LINK_ABSTRACT);
1044 RT_TIMING_TIME_DIFF(time_abstract ,time_compute_iftbl,RT_TIMING_LINK_C_IFTBL);
1045 RT_TIMING_TIME_DIFF(time_compute_iftbl,time_fill_vftbl ,RT_TIMING_LINK_F_VFTBL);
1046 RT_TIMING_TIME_DIFF(time_fill_vftbl ,time_offsets ,RT_TIMING_LINK_OFFSETS);
1047 RT_TIMING_TIME_DIFF(time_offsets ,time_fill_iftbl ,RT_TIMING_LINK_F_IFTBL);
1048 RT_TIMING_TIME_DIFF(time_fill_iftbl ,time_finalizer ,RT_TIMING_LINK_FINALIZER);
1049 RT_TIMING_TIME_DIFF(time_finalizer ,time_subclasses ,RT_TIMING_LINK_SUBCLASS);
1051 /* just return c to show that we didn't had a problem */
1057 /* link_array ******************************************************************
1059 This function is called by link_class to create the arraydescriptor
1062 This function returns NULL if the array cannot be linked because
1063 the component type has not been linked yet.
1065 *******************************************************************************/
1067 static arraydescriptor *link_array(classinfo *c)
1071 arraydescriptor *desc;
1076 namelen = c->name->blength;
1078 /* Check the component type */
1080 switch (c->name->text[1]) {
1082 /* c is an array of arrays. */
1083 u = utf_new(c->name->text + 1, namelen - 1);
1084 if (!(comp = load_class_from_classloader(u, c->classloader)))
1089 /* c is an array of objects. */
1090 u = utf_new(c->name->text + 2, namelen - 3);
1091 if (!(comp = load_class_from_classloader(u, c->classloader)))
1096 /* If the component type has not been linked, link it now */
1098 assert(!comp || (comp->state & CLASS_LOADED));
1100 if (comp && !(comp->state & CLASS_LINKED))
1101 if (!link_class(comp))
1104 /* Allocate the arraydescriptor */
1106 desc = NEW(arraydescriptor);
1109 /* c is an array of references */
1110 desc->arraytype = ARRAYTYPE_OBJECT;
1111 desc->componentsize = sizeof(void*);
1112 desc->dataoffset = OFFSET(java_objectarray, data);
1114 compvftbl = comp->vftbl;
1117 log_text("Component class has no vftbl");
1121 desc->componentvftbl = compvftbl;
1123 if (compvftbl->arraydesc) {
1124 desc->elementvftbl = compvftbl->arraydesc->elementvftbl;
1126 if (compvftbl->arraydesc->dimension >= 255) {
1127 log_text("Creating array of dimension >255");
1131 desc->dimension = compvftbl->arraydesc->dimension + 1;
1132 desc->elementtype = compvftbl->arraydesc->elementtype;
1135 desc->elementvftbl = compvftbl;
1136 desc->dimension = 1;
1137 desc->elementtype = ARRAYTYPE_OBJECT;
1141 /* c is an array of a primitive type */
1142 switch (c->name->text[1]) {
1144 desc->arraytype = ARRAYTYPE_BOOLEAN;
1145 desc->dataoffset = OFFSET(java_booleanarray,data);
1146 desc->componentsize = sizeof(u1);
1150 desc->arraytype = ARRAYTYPE_BYTE;
1151 desc->dataoffset = OFFSET(java_bytearray,data);
1152 desc->componentsize = sizeof(u1);
1156 desc->arraytype = ARRAYTYPE_CHAR;
1157 desc->dataoffset = OFFSET(java_chararray,data);
1158 desc->componentsize = sizeof(u2);
1162 desc->arraytype = ARRAYTYPE_DOUBLE;
1163 desc->dataoffset = OFFSET(java_doublearray,data);
1164 desc->componentsize = sizeof(double);
1168 desc->arraytype = ARRAYTYPE_FLOAT;
1169 desc->dataoffset = OFFSET(java_floatarray,data);
1170 desc->componentsize = sizeof(float);
1174 desc->arraytype = ARRAYTYPE_INT;
1175 desc->dataoffset = OFFSET(java_intarray,data);
1176 desc->componentsize = sizeof(s4);
1180 desc->arraytype = ARRAYTYPE_LONG;
1181 desc->dataoffset = OFFSET(java_longarray,data);
1182 desc->componentsize = sizeof(s8);
1186 desc->arraytype = ARRAYTYPE_SHORT;
1187 desc->dataoffset = OFFSET(java_shortarray,data);
1188 desc->componentsize = sizeof(s2);
1192 exceptions_throw_noclassdeffounderror(c->name);
1196 desc->componentvftbl = NULL;
1197 desc->elementvftbl = NULL;
1198 desc->dimension = 1;
1199 desc->elementtype = desc->arraytype;
1206 /* linker_compute_subclasses ***************************************************
1210 *******************************************************************************/
1212 static void linker_compute_subclasses(classinfo *c)
1214 LOCK_MONITOR_ENTER(linker_classrenumber_lock);
1216 if (!(c->flags & ACC_INTERFACE)) {
1221 if (!(c->flags & ACC_INTERFACE) && (c->super.any != NULL)) {
1222 c->nextsub = c->super.cls->sub;
1223 c->super.cls->sub = c;
1228 /* compute class values */
1230 linker_compute_class_values(class_java_lang_Object);
1232 LOCK_MONITOR_EXIT(linker_classrenumber_lock);
1236 /* linker_compute_class_values *************************************************
1240 *******************************************************************************/
1242 static void linker_compute_class_values(classinfo *c)
1246 c->vftbl->baseval = ++classvalue;
1251 linker_compute_class_values(subs);
1253 subs = subs->nextsub;
1256 c->vftbl->diffval = classvalue - c->vftbl->baseval;
1260 /* linker_addinterface *********************************************************
1262 Is needed by link_class for adding a VTBL to a class. All
1263 interfaces implemented by ic are added as well.
1266 true.........everything ok
1267 false........an exception has been thrown
1269 *******************************************************************************/
1271 static bool linker_addinterface(classinfo *c, classinfo *ic)
1282 if (i >= v->interfacetablelength)
1283 vm_abort("Internal error: interfacetable overflow");
1285 /* if this interface has already been added, return immediately */
1287 if (v->interfacetable[-i] != NULL)
1290 if (ic->methodscount == 0) { /* fake entry needed for subtype test */
1291 v->interfacevftbllength[i] = 1;
1292 v->interfacetable[-i] = MNEW(methodptr, 1);
1293 v->interfacetable[-i][0] = NULL;
1296 v->interfacevftbllength[i] = ic->methodscount;
1297 v->interfacetable[-i] = MNEW(methodptr, ic->methodscount);
1299 #if defined(ENABLE_STATISTICS)
1301 count_vftbl_len += sizeof(methodptr) *
1302 (ic->methodscount + (ic->methodscount == 0));
1305 for (j = 0; j < ic->methodscount; j++) {
1306 for (sc = c; sc != NULL; sc = sc->super.cls) {
1307 for (k = 0; k < sc->methodscount; k++) {
1308 m = &(sc->methods[k]);
1310 if (method_canoverwrite(m, &(ic->methods[j]))) {
1311 /* method m overwrites the (abstract) method */
1312 #if defined(ENABLE_VERIFIER)
1313 /* Add loading constraints (for the more
1314 general types of the method
1316 if (!classcache_add_constraints_for_params(
1317 c->classloader, ic->classloader,
1324 /* XXX taken from gcj */
1325 /* check for ACC_STATIC: IncompatibleClassChangeError */
1327 /* check for !ACC_PUBLIC: IllegalAccessError */
1329 /* check for ACC_ABSTRACT: AbstracMethodError,
1330 not sure about that one */
1332 v->interfacetable[-i][j] = v->table[m->vftblindex];
1338 /* If no method was found, insert the AbstractMethodError
1341 #if defined(ENABLE_JIT)
1342 # if defined(ENABLE_INTRP)
1344 v->interfacetable[-i][j] =
1345 (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
1348 v->interfacetable[-i][j] =
1349 (methodptr) (ptrint) &asm_abstractmethoderror;
1351 v->interfacetable[-i][j] =
1352 (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
1360 /* add superinterfaces of this interface */
1362 for (j = 0; j < ic->interfacescount; j++)
1363 if (!linker_addinterface(c, ic->interfaces[j].cls))
1372 /* class_highestinterface ******************************************************
1374 Used by the function link_class to determine the amount of memory
1375 needed for the interface table.
1377 *******************************************************************************/
1379 static s4 class_highestinterface(classinfo *c)
1385 /* check for ACC_INTERFACE bit already done in link_class_intern */
1389 for (i = 0; i < c->interfacescount; i++) {
1390 h2 = class_highestinterface(c->interfaces[i].cls);
1401 * These are local overrides for various environment variables in Emacs.
1402 * Please do not remove this and leave it at the end of the file, where
1403 * Emacs will automagically detect them.
1404 * ---------------------------------------------------------------------
1407 * indent-tabs-mode: t
1411 * vim:noexpandtab:sw=4:ts=4: