src/vm/linker.c

   1 /* src/vm/linker.c - class linker functions
   2
   3    Copyright (C) 1996-2005, 2006 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
   7
   8    This file is part of CACAO.
   9
  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.
  14
  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.
  19
  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
  23    02110-1301, USA.
  24
  25    Contact: cacao@cacaojvm.org
  26
  27    Authors: Reinhard Grafl
  28
  29    Changes: Andreas Krall
  30             Roman Obermaiser
  31             Mark Probst
  32             Edwin Steiner
  33             Christian Thalinger
  34
  35    $Id: linker.c 4801 2006-04-20 21:47:41Z edwin $
  36
  37 */
  38
  39
  40 #include "config.h"
  41
  42 #include <assert.h>
  43
  44 #include "vm/types.h"
  45
  46 #include "mm/memory.h"
  47 #include "native/native.h"
  48 #include "vm/builtin.h"
  49 #include "vm/class.h"
  50 #include "vm/classcache.h"
  51 #include "vm/exceptions.h"
  52 #include "vm/loader.h"
  53 #include "vm/options.h"
  54 #include "vm/resolve.h"
  55 #include "vm/statistics.h"
  56 #include "vm/stringlocal.h"
  57 #include "vm/access.h"
  58 #include "vm/rt-timing.h"
  59
  60
  61 /* global variables ***********************************************************/
  62
  63 static s4 interfaceindex;       /* sequential numbering of interfaces         */
  64 static s4 classvalue;
  65
  66
  67 /* primitivetype_table *********************************************************
  68
  69    Structure for primitive classes: contains the class for wrapping
  70    the primitive type, the primitive class, the name of the class for
  71    wrapping, the one character type signature and the name of the
  72    primitive class.
  73
  74    CAUTION: Don't change the order of the types. This table is indexed
  75    by the ARRAYTYPE_ constants (except ARRAYTYPE_OBJECT).
  76
  77 *******************************************************************************/
  78
  79 primitivetypeinfo primitivetype_table[PRIMITIVETYPE_COUNT] = {
  80         { NULL, NULL, "java/lang/Integer",   'I', "int"     , "[I", NULL, NULL },
  81         { NULL, NULL, "java/lang/Long",      'J', "long"    , "[J", NULL, NULL },
  82         { NULL, NULL, "java/lang/Float",     'F', "float"   , "[F", NULL, NULL },
  83         { NULL, NULL, "java/lang/Double",    'D', "double"  , "[D", NULL, NULL },
  84         { NULL, NULL, NULL,                   0 , NULL      , NULL, NULL, NULL },
  85         { NULL, NULL, "java/lang/Byte",      'B', "byte"    , "[B", NULL, NULL },
  86         { NULL, NULL, "java/lang/Character", 'C', "char"    , "[C", NULL, NULL },
  87         { NULL, NULL, "java/lang/Short",     'S', "short"   , "[S", NULL, NULL },
  88         { NULL, NULL, "java/lang/Boolean",   'Z', "boolean" , "[Z", NULL, NULL },
  89         { NULL, NULL, NULL,                   0 , NULL      , NULL, NULL, NULL },
  90         { NULL, NULL, "java/lang/Void",      'V', "void"    , NULL, NULL, NULL }
  91 };
  92
  93
  94 /* private functions **********************************************************/
  95
  96 static bool link_primitivetype_table(void);
  97 static classinfo *link_class_intern(classinfo *c);
  98 static arraydescriptor *link_array(classinfo *c);
  99 static void linker_compute_class_values(classinfo *c);
 100 static void linker_compute_subclasses(classinfo *c);
 101 static bool linker_addinterface(classinfo *c, classinfo *ic);
 102 static s4 class_highestinterface(classinfo *c);
 103
 104
 105 /* linker_init *****************************************************************
 106
 107    Initializes the linker subsystem.
 108
 109 *******************************************************************************/
 110
 111 bool linker_init(void)
 112 {
 113         /* reset interface index */
 114
 115         interfaceindex = 0;
 116
 117         /* link java.lang.Class as first class of the system, because we
 118        need it's vftbl for all other classes so we can use a class as
 119        object */
 120
 121         if (!link_class(class_java_lang_Class))
 122                 return false;
 123
 124         /* now set the header.vftbl of all classes which were created
 125        before java.lang.Class was linked */
 126
 127         class_postset_header_vftbl();
 128
 129
 130         /* link important system classes */
 131
 132         if (!link_class(class_java_lang_Object))
 133                 return false;
 134
 135         if (!link_class(class_java_lang_String))
 136                 return false;
 137
 138         if (!link_class(class_java_lang_Cloneable))
 139                 return false;
 140
 141         if (!link_class(class_java_io_Serializable))
 142                 return false;
 143
 144
 145         /* link classes for wrapping primitive types */
 146
 147         if (!link_class(class_java_lang_Void))
 148                 return false;
 149
 150         if (!link_class(class_java_lang_Boolean))
 151                 return false;
 152
 153         if (!link_class(class_java_lang_Byte))
 154                 return false;
 155
 156         if (!link_class(class_java_lang_Character))
 157                 return false;
 158
 159         if (!link_class(class_java_lang_Short))
 160                 return false;
 161
 162         if (!link_class(class_java_lang_Integer))
 163                 return false;
 164
 165         if (!link_class(class_java_lang_Long))
 166                 return false;
 167
 168         if (!link_class(class_java_lang_Float))
 169                 return false;
 170
 171         if (!link_class(class_java_lang_Double))
 172                 return false;
 173
 174
 175         /* load some other important classes */
 176
 177         if (!link_class(class_java_lang_ClassLoader))
 178                 return false;
 179
 180         if (!link_class(class_java_lang_SecurityManager))
 181                 return false;
 182
 183         if (!link_class(class_java_lang_System))
 184                 return false;
 185
 186         if (!link_class(class_java_lang_Thread))
 187                 return false;
 188
 189         if (!link_class(class_java_lang_ThreadGroup))
 190                 return false;
 191
 192         if (!link_class(class_java_lang_VMThread))
 193                 return false;
 194
 195
 196         /* some classes which may be used more often */
 197
 198         if (!link_class(class_java_lang_StackTraceElement))
 199                 return false;
 200
 201         if (!link_class(class_java_lang_reflect_Constructor))
 202                 return false;
 203
 204         if (!link_class(class_java_lang_reflect_Field))
 205                 return false;
 206
 207         if (!link_class(class_java_lang_reflect_Method))
 208                 return false;
 209
 210         if (!link_class(class_java_security_PrivilegedAction))
 211                 return false;
 212
 213         if (!link_class(class_java_util_Vector))
 214                 return false;
 215
 216         if (!link_class(arrayclass_java_lang_Object))
 217                 return false;
 218
 219
 220         /* create pseudo classes used by the typechecker */
 221
 222     /* pseudo class for Arraystubs (extends java.lang.Object) */
 223
 224         pseudo_class_Arraystub =
 225                 class_create_classinfo(utf_new_char("$ARRAYSTUB$"));
 226         pseudo_class_Arraystub->state |= CLASS_LOADED;
 227         pseudo_class_Arraystub->super.cls = class_java_lang_Object;
 228         pseudo_class_Arraystub->interfacescount = 2;
 229         pseudo_class_Arraystub->interfaces = MNEW(classref_or_classinfo, 2);
 230         pseudo_class_Arraystub->interfaces[0].cls = class_java_lang_Cloneable;
 231         pseudo_class_Arraystub->interfaces[1].cls = class_java_io_Serializable;
 232
 233         if (!classcache_store_unique(pseudo_class_Arraystub)) {
 234                 log_text("could not cache pseudo_class_Arraystub");
 235                 assert(0);
 236         }
 237
 238         if (!link_class(pseudo_class_Arraystub))
 239                 return false;
 240
 241         /* pseudo class representing the null type */
 242
 243         pseudo_class_Null = class_create_classinfo(utf_new_char("$NULL$"));
 244         pseudo_class_Null->state |= CLASS_LOADED;
 245         pseudo_class_Null->super.cls = class_java_lang_Object;
 246
 247         if (!classcache_store_unique(pseudo_class_Null)) {
 248                 log_text("could not cache pseudo_class_Null");
 249                 assert(0);
 250         }
 251
 252         if (!link_class(pseudo_class_Null))
 253                 return false;
 254
 255         /* pseudo class representing new uninitialized objects */
 256
 257         pseudo_class_New = class_create_classinfo(utf_new_char("$NEW$"));
 258         pseudo_class_New->state |= CLASS_LOADED;
 259         pseudo_class_New->state |= CLASS_LINKED; /* XXX is this allright? */
 260         pseudo_class_New->super.cls = class_java_lang_Object;
 261
 262         if (!classcache_store_unique(pseudo_class_New)) {
 263                 log_text("could not cache pseudo_class_New");
 264                 assert(0);
 265         }
 266
 267         /* create classes representing primitive types */
 268
 269         if (!link_primitivetype_table())
 270                 return false;
 271
 272
 273         /* Correct vftbl-entries (retarded loading and linking of class           */
 274         /* java/lang/String).                                                     */
 275
 276         stringtable_update();
 277
 278         return true;
 279 }
 280
 281
 282 /* link_primitivetype_table ****************************************************
 283
 284    Create classes representing primitive types.
 285
 286 *******************************************************************************/
 287
 288 static bool link_primitivetype_table(void)
 289 {
 290         classinfo *c;
 291         utf       *u;
 292         s4         i;
 293
 294         for (i = 0; i < PRIMITIVETYPE_COUNT; i++) {
 295                 /* skip dummies */
 296
 297                 if (!primitivetype_table[i].name)
 298                         continue;
 299
 300                 /* create primitive class */
 301
 302                 c = class_create_classinfo(utf_new_char(primitivetype_table[i].name));
 303
 304                 c->flags = ACC_PUBLIC | ACC_FINAL | ACC_ABSTRACT;
 305
 306                 /* prevent loader from loading primitive class */
 307
 308                 c->state |= CLASS_LOADED;
 309
 310                 /* INFO: don't put primitive classes into the classcache */
 311
 312                 if (!link_class(c))
 313                         return false;
 314
 315                 primitivetype_table[i].class_primitive = c;
 316
 317                 /* create class for wrapping the primitive type */
 318
 319                 u = utf_new_char(primitivetype_table[i].wrapname);
 320
 321                 if (!(c = load_class_bootstrap(u)))
 322                         return false;
 323
 324                 primitivetype_table[i].class_wrap = c;
 325
 326                 /* create the primitive array class */
 327
 328                 if (primitivetype_table[i].arrayname) {
 329                         u = utf_new_char(primitivetype_table[i].arrayname);
 330                         c = class_create_classinfo(u);
 331                         c = load_newly_created_array(c, NULL);
 332                         if (c == NULL)
 333                                 return false;
 334
 335                         primitivetype_table[i].arrayclass = c;
 336
 337                         assert(c->state & CLASS_LOADED);
 338
 339                         if (!(c->state & CLASS_LINKED))
 340                                 if (!link_class(c))
 341                                         return false;
 342
 343                         primitivetype_table[i].arrayvftbl = c->vftbl;
 344                 }
 345         }
 346
 347         return true;
 348 }
 349
 350
 351 /* link_class ******************************************************************
 352
 353    Wrapper function for link_class_intern to ease monitor enter/exit
 354    and exception handling.
 355
 356 *******************************************************************************/
 357
 358 classinfo *link_class(classinfo *c)
 359 {
 360         classinfo *r;
 361 #if defined(ENABLE_RT_TIMING)
 362         struct timespec time_start, time_end;
 363 #endif
 364
 365         RT_TIMING_GET_TIME(time_start);
 366
 367         if (!c) {
 368                 exceptions_throw_nullpointerexception();
 369                 return NULL;
 370         }
 371
 372 #if defined(USE_THREADS)
 373         /* enter a monitor on the class */
 374
 375         builtin_monitorenter((java_objectheader *) c);
 376 #endif
 377
 378         /* maybe the class is already linked */
 379
 380         if (c->state & CLASS_LINKED) {
 381 #if defined(USE_THREADS)
 382                 builtin_monitorexit((java_objectheader *) c);
 383 #endif
 384
 385                 return c;
 386         }
 387
 388 #if defined(ENABLE_STATISTICS)
 389         /* measure time */
 390
 391         if (getcompilingtime)
 392                 compilingtime_stop();
 393
 394         if (getloadingtime)
 395                 loadingtime_start();
 396 #endif
 397
 398         /* call the internal function */
 399
 400         r = link_class_intern(c);
 401
 402         /* if return value is NULL, we had a problem and the class is not linked */
 403
 404         if (!r)
 405                 c->state &= ~CLASS_LINKING;
 406
 407 #if defined(ENABLE_STATISTICS)
 408         /* measure time */
 409
 410         if (getloadingtime)
 411                 loadingtime_stop();
 412
 413         if (getcompilingtime)
 414                 compilingtime_start();
 415 #endif
 416
 417 #if defined(USE_THREADS)
 418         /* leave the monitor */
 419
 420         builtin_monitorexit((java_objectheader *) c);
 421 #endif
 422
 423         RT_TIMING_GET_TIME(time_end);
 424
 425         RT_TIMING_TIME_DIFF(time_start,time_end,RT_TIMING_LINK_TOTAL);
 426
 427         return r;
 428 }
 429
 430
 431 /* link_class_intern ***********************************************************
 432
 433    Tries to link a class. The function calculates the length in bytes
 434    that an instance of this class requires as well as the VTBL for
 435    methods and interface methods.
 436
 437 *******************************************************************************/
 438
 439 static classinfo *link_class_intern(classinfo *c)
 440 {
 441         classinfo *super;             /* super class                              */
 442         classinfo *tc;                /* temporary class variable                 */
 443         s4 supervftbllength;          /* vftbllegnth of super class               */
 444         s4 vftbllength;               /* vftbllength of current class             */
 445         s4 interfacetablelength;      /* interface table length                   */
 446         vftbl_t *v;                   /* vftbl of current class                   */
 447         s4 i,j;                       /* interface/method/field counter           */
 448         arraydescriptor *arraydesc;   /* descriptor for array classes             */
 449 #if defined(ENABLE_RT_TIMING)
 450         struct timespec time_start, time_resolving, time_compute_vftbl,
 451                                         time_abstract, time_compute_iftbl, time_fill_vftbl,
 452                                         time_offsets, time_fill_iftbl, time_finalizer,
 453                                         time_exceptions, time_subclasses;
 454 #endif
 455
 456         RT_TIMING_GET_TIME(time_start);
 457
 458         /* the class is already linked */
 459
 460         if (c->state & CLASS_LINKED)
 461                 return c;
 462
 463 #if !defined(NDEBUG)
 464         if (linkverbose)
 465                 log_message_class("Linking class: ", c);
 466 #endif
 467
 468         /* the class must be loaded */
 469
 470         /* XXX should this be a specific exception? */
 471         assert(c->state & CLASS_LOADED);
 472
 473         /* cache the self-reference of this class                          */
 474         /* we do this for cases where the defining loader of the class     */
 475         /* has not yet been recorded as an initiating loader for the class */
 476         /* this is needed so subsequent code can assume that self-refs     */
 477         /* will always resolve lazily                                      */
 478         /* No need to do it for the bootloader - it is always registered   */
 479         /* as initiating loader for the classes it loads.                  */
 480         if (c->classloader)
 481                 classcache_store(c->classloader,c,false);
 482
 483         /* this class is currently linking */
 484
 485         c->state |= CLASS_LINKING;
 486
 487         arraydesc = NULL;
 488
 489         /* check interfaces */
 490
 491         for (i = 0; i < c->interfacescount; i++) {
 492                 /* resolve this super interface */
 493
 494                 if (!resolve_classref_or_classinfo(NULL, c->interfaces[i], resolveEager,
 495                                                                                    true, false, &tc))
 496                         return NULL;
 497
 498                 c->interfaces[i].cls = tc;
 499
 500                 /* detect circularity */
 501
 502                 if (tc == c) {
 503                         *exceptionptr =
 504                                 new_exception_utfmessage(string_java_lang_ClassCircularityError,
 505                                                                                  c->name);
 506                         return NULL;
 507                 }
 508
 509                 assert(tc->state & CLASS_LOADED);
 510
 511                 if (!(tc->flags & ACC_INTERFACE)) {
 512                         *exceptionptr =
 513                                 new_exception_message(string_java_lang_IncompatibleClassChangeError,
 514                                                                           "Implementing class");
 515                         return NULL;
 516                 }
 517
 518                 if (!(tc->state & CLASS_LINKED))
 519                         if (!link_class(tc))
 520                                 return NULL;
 521         }
 522
 523         /* check super class */
 524
 525         super = NULL;
 526
 527         if (c->super.any == NULL) {                     /* class java.lang.Object */
 528                 c->index = 0;
 529                 c->instancesize = sizeof(java_objectheader);
 530
 531                 vftbllength = supervftbllength = 0;
 532
 533                 c->finalizer = NULL;
 534
 535         } else {
 536                 /* resolve super class */
 537
 538                 if (!resolve_classref_or_classinfo(NULL, c->super, resolveEager, true, false,
 539                                                                                    &super))
 540                         return NULL;
 541                 c->super.cls = super;
 542
 543                 /* detect circularity */
 544
 545                 if (super == c) {
 546                         *exceptionptr =
 547                                 new_exception_utfmessage(string_java_lang_ClassCircularityError,
 548                                                                                  c->name);
 549                         return NULL;
 550                 }
 551
 552                 assert(super->state & CLASS_LOADED);
 553
 554                 if (super->flags & ACC_INTERFACE) {
 555                         /* java.lang.IncompatibleClassChangeError: class a has interface java.lang.Cloneable as super class */
 556                         log_text("Interface specified as super class");
 557                         assert(0);
 558                 }
 559
 560                 /* Don't allow extending final classes */
 561
 562                 if (super->flags & ACC_FINAL) {
 563                         *exceptionptr =
 564                                 new_exception_message(string_java_lang_VerifyError,
 565                                                                           "Cannot inherit from final class");
 566                         return NULL;
 567                 }
 568
 569                 if (!(super->state & CLASS_LINKED))
 570                         if (!link_class(super))
 571                                 return NULL;
 572
 573                 /* handle array classes */
 574
 575                 if (c->name->text[0] == '[')
 576                         if (!(arraydesc = link_array(c)))
 577                                 return NULL;
 578
 579                 if (c->flags & ACC_INTERFACE)
 580                         c->index = interfaceindex++;
 581                 else
 582                         c->index = super->index + 1;
 583
 584                 c->instancesize = super->instancesize;
 585
 586                 vftbllength = supervftbllength = super->vftbl->vftbllength;
 587
 588                 c->finalizer = super->finalizer;
 589         }
 590         RT_TIMING_GET_TIME(time_resolving);
 591
 592
 593         /* compute vftbl length */
 594
 595         for (i = 0; i < c->methodscount; i++) {
 596                 methodinfo *m = &(c->methods[i]);
 597
 598                 if (!(m->flags & ACC_STATIC)) { /* is instance method */
 599                         tc = super;
 600
 601                         while (tc) {
 602                                 s4 j;
 603
 604                                 for (j = 0; j < tc->methodscount; j++) {
 605                                         if (method_canoverwrite(m, &(tc->methods[j]))) {
 606                                                 if (tc->methods[j].flags & ACC_PRIVATE)
 607                                                         goto notfoundvftblindex;
 608
 609                                                 /* package-private methods in other packages */
 610                                                 /* must not be overridden                    */
 611                                                 /* (see Java Language Specification 8.4.8.1) */
 612                                                 if ( !(tc->methods[j].flags & (ACC_PUBLIC | ACC_PROTECTED))
 613                                                          && !SAME_PACKAGE(c,tc) )
 614                                                 {
 615                                                     goto notfoundvftblindex;
 616                                                 }
 617
 618                                                 if (tc->methods[j].flags & ACC_FINAL) {
 619                                                         /* class a overrides final method . */
 620                                                         *exceptionptr =
 621                                                                 new_exception(string_java_lang_VerifyError);
 622                                                         return NULL;
 623                                                 }
 624
 625                                                 /* method m overwrites method j of class tc */
 626
 627 #if defined(ENABLE_VERIFIER)
 628                                                 if (!classcache_add_constraints_for_params(
 629                                                                         c->classloader, tc->classloader, m))
 630                                                         return NULL;
 631 #endif
 632
 633                                                 m->vftblindex = tc->methods[j].vftblindex;
 634                                                 goto foundvftblindex;
 635                                         }
 636                                 }
 637
 638                                 tc = tc->super.cls;
 639                         }
 640
 641                 notfoundvftblindex:
 642                         m->vftblindex = (vftbllength++);
 643                 foundvftblindex:
 644                         ;
 645                 }
 646         }
 647         RT_TIMING_GET_TIME(time_compute_vftbl);
 648
 649
 650         /* Check all interfaces of an abtract class (maybe be an interface
 651            too) for unimplemented methods.  Such methods are called
 652            miranda-methods and are marked with the ACC_MIRANDA flag.
 653            VMClass.getDeclaredMethods does not return such methods. */
 654
 655         if (c->flags & ACC_ABSTRACT) {
 656                 classinfo  *ic;
 657                 methodinfo *im;
 658                 s4 abstractmethodscount;
 659                 s4 j;
 660                 s4 k;
 661
 662                 abstractmethodscount = 0;
 663
 664                 /* check all interfaces of the abtract class */
 665
 666                 for (i = 0; i < c->interfacescount; i++) {
 667                         ic = c->interfaces[i].cls;
 668
 669                         for (j = 0; j < ic->methodscount; j++) {
 670                                 im = &(ic->methods[j]);
 671
 672                                 /* skip `<clinit>' and `<init>' */
 673
 674                                 if ((im->name == utf_clinit) || (im->name == utf_init))
 675                                         continue;
 676
 677                                 for (tc = c; tc != NULL; tc = tc->super.cls) {
 678                                         for (k = 0; k < tc->methodscount; k++) {
 679                                                 if (method_canoverwrite(im, &(tc->methods[k])))
 680                                                         goto noabstractmethod;
 681                                         }
 682                                 }
 683
 684                                 abstractmethodscount++;
 685
 686                         noabstractmethod:
 687                                 ;
 688                         }
 689                 }
 690
 691                 if (abstractmethodscount > 0) {
 692                         methodinfo *am;
 693
 694                         /* reallocate methods memory */
 695
 696                         c->methods = MREALLOC(c->methods, methodinfo, c->methodscount,
 697                                                                   c->methodscount + abstractmethodscount);
 698
 699                         for (i = 0; i < c->interfacescount; i++) {
 700                                 ic = c->interfaces[i].cls;
 701
 702                                 for (j = 0; j < ic->methodscount; j++) {
 703                                         im = &(ic->methods[j]);
 704
 705                                         /* skip `<clinit>' and `<init>' */
 706
 707                                         if ((im->name == utf_clinit) || (im->name == utf_init))
 708                                                 continue;
 709
 710                                         for (tc = c; tc != NULL; tc = tc->super.cls) {
 711                                                 for (k = 0; k < tc->methodscount; k++) {
 712                                                         if (method_canoverwrite(im, &(tc->methods[k])))
 713                                                                 goto noabstractmethod2;
 714                                                 }
 715                                         }
 716
 717                                         /* Copy the method found into the new c->methods
 718                                            array and tag it as miranda-method. */
 719
 720                                         am = &(c->methods[c->methodscount]);
 721                                         c->methodscount++;
 722
 723                                         MCOPY(am, im, methodinfo, 1);
 724
 725                                         am->vftblindex  = (vftbllength++);
 726                                         am->class       = c;
 727                                         am->flags      |= ACC_MIRANDA;
 728
 729                                 noabstractmethod2:
 730                                         ;
 731                                 }
 732                         }
 733                 }
 734         }
 735         RT_TIMING_GET_TIME(time_abstract);
 736
 737
 738 #if defined(ENABLE_STATISTICS)
 739         if (opt_stat)
 740                 count_vftbl_len +=
 741                         sizeof(vftbl_t) + (sizeof(methodptr) * (vftbllength - 1));
 742 #endif
 743
 744         /* compute interfacetable length */
 745
 746         interfacetablelength = 0;
 747         tc = c;
 748         while (tc) {
 749                 for (i = 0; i < tc->interfacescount; i++) {
 750                         s4 h = class_highestinterface(tc->interfaces[i].cls) + 1;
 751                         if (h > interfacetablelength)
 752                                 interfacetablelength = h;
 753                 }
 754                 tc = tc->super.cls;
 755         }
 756         RT_TIMING_GET_TIME(time_compute_iftbl);
 757
 758         /* allocate virtual function table */
 759
 760         v = (vftbl_t *) mem_alloc(sizeof(vftbl_t) +
 761                                                           sizeof(methodptr) * (vftbllength - 1) +
 762                                                           sizeof(methodptr*) * (interfacetablelength - (interfacetablelength > 0)));
 763         v = (vftbl_t *) (((methodptr *) v) +
 764                                          (interfacetablelength - 1) * (interfacetablelength > 1));
 765         c->vftbl = v;
 766         v->class = c;
 767         v->vftbllength = vftbllength;
 768         v->interfacetablelength = interfacetablelength;
 769         v->arraydesc = arraydesc;
 770
 771         /* store interface index in vftbl */
 772
 773         if (c->flags & ACC_INTERFACE)
 774                 v->baseval = -(c->index);
 775
 776         /* copy virtual function table of super class */
 777
 778         for (i = 0; i < supervftbllength; i++)
 779                 v->table[i] = super->vftbl->table[i];
 780
 781         /* add method stubs into virtual function table */
 782
 783         for (i = 0; i < c->methodscount; i++) {
 784                 methodinfo *m = &(c->methods[i]);
 785
 786                 /* Methods in ABSTRACT classes from interfaces maybe already
 787                    have a stubroutine. */
 788
 789                 if (!m->stubroutine) {
 790 #if defined(ENABLE_JIT)
 791 # if defined(ENABLE_INTRP)
 792                         if (opt_intrp)
 793                                 m->stubroutine = intrp_createcompilerstub(m);
 794                         else
 795 #endif
 796                                 m->stubroutine = createcompilerstub(m);
 797 #else
 798                         m->stubroutine = intrp_createcompilerstub(m);
 799 #endif
 800                 }
 801
 802                 if (!(m->flags & ACC_STATIC))
 803                         v->table[m->vftblindex] = (methodptr) (ptrint) m->stubroutine;
 804         }
 805         RT_TIMING_GET_TIME(time_fill_vftbl);
 806
 807         /* compute instance size and offset of each field */
 808
 809         for (i = 0; i < c->fieldscount; i++) {
 810                 s4 dsize;
 811                 fieldinfo *f = &(c->fields[i]);
 812
 813                 if (!(f->flags & ACC_STATIC)) {
 814                         dsize = descriptor_typesize(f->parseddesc);
 815                         c->instancesize = ALIGN(c->instancesize, dsize);
 816                         f->offset = c->instancesize;
 817                         c->instancesize += dsize;
 818                 }
 819         }
 820         RT_TIMING_GET_TIME(time_offsets);
 821
 822         /* initialize interfacetable and interfacevftbllength */
 823
 824         v->interfacevftbllength = MNEW(s4, interfacetablelength);
 825
 826 #if defined(ENABLE_STATISTICS)
 827         if (opt_stat)
 828                 count_vftbl_len += (4 + sizeof(s4)) * v->interfacetablelength;
 829 #endif
 830
 831         for (i = 0; i < interfacetablelength; i++) {
 832                 v->interfacevftbllength[i] = 0;
 833                 v->interfacetable[-i] = NULL;
 834         }
 835
 836         /* add interfaces */
 837
 838         for (tc = c; tc != NULL; tc = tc->super.cls)
 839                 for (i = 0; i < tc->interfacescount; i++)
 840                         if (!linker_addinterface(c, tc->interfaces[i].cls))
 841                                 return NULL;
 842
 843         RT_TIMING_GET_TIME(time_fill_iftbl);
 844
 845         /* add finalizer method (not for java.lang.Object) */
 846
 847         if (super) {
 848                 methodinfo *fi;
 849
 850                 fi = class_findmethod(c, utf_finalize, utf_void__void);
 851
 852                 if (fi)
 853                         if (!(fi->flags & ACC_STATIC))
 854                                 c->finalizer = fi;
 855         }
 856         RT_TIMING_GET_TIME(time_finalizer);
 857
 858         /* resolve exception class references */
 859
 860         for (i = 0; i < c->methodscount; i++) {
 861                 methodinfo *m = &(c->methods[i]);
 862
 863                 for (j = 0; j < m->exceptiontablelength; j++) {
 864                         if (!m->exceptiontable[j].catchtype.any)
 865                                 continue;
 866                         if (!resolve_classref_or_classinfo(NULL,
 867                                                                                            m->exceptiontable[j].catchtype,
 868                                                                                            resolveEager, true, false,
 869                                                                                            &(m->exceptiontable[j].catchtype.cls)))
 870                                 return NULL;
 871                 }
 872         }
 873         RT_TIMING_GET_TIME(time_exceptions);
 874
 875         /* final tasks */
 876
 877         linker_compute_subclasses(c);
 878
 879         RT_TIMING_GET_TIME(time_subclasses);
 880
 881         /* revert the linking state and class is linked */
 882
 883         c->state = (c->state & ~CLASS_LINKING) | CLASS_LINKED;
 884
 885 #if !defined(NDEBUG)
 886         if (linkverbose)
 887                 log_message_class("Linking done class: ", c);
 888 #endif
 889
 890         RT_TIMING_TIME_DIFF(time_start        ,time_resolving    ,RT_TIMING_LINK_RESOLVE);
 891         RT_TIMING_TIME_DIFF(time_resolving    ,time_compute_vftbl,RT_TIMING_LINK_C_VFTBL);
 892         RT_TIMING_TIME_DIFF(time_compute_vftbl,time_abstract     ,RT_TIMING_LINK_ABSTRACT);
 893         RT_TIMING_TIME_DIFF(time_abstract     ,time_compute_iftbl,RT_TIMING_LINK_C_IFTBL);
 894         RT_TIMING_TIME_DIFF(time_compute_iftbl,time_fill_vftbl   ,RT_TIMING_LINK_F_VFTBL);
 895         RT_TIMING_TIME_DIFF(time_fill_vftbl   ,time_offsets      ,RT_TIMING_LINK_OFFSETS);
 896         RT_TIMING_TIME_DIFF(time_offsets      ,time_fill_iftbl   ,RT_TIMING_LINK_F_IFTBL);
 897         RT_TIMING_TIME_DIFF(time_fill_iftbl   ,time_finalizer    ,RT_TIMING_LINK_FINALIZER);
 898         RT_TIMING_TIME_DIFF(time_finalizer    ,time_exceptions   ,RT_TIMING_LINK_EXCEPTS);
 899         RT_TIMING_TIME_DIFF(time_exceptions   ,time_subclasses   ,RT_TIMING_LINK_SUBCLASS);
 900
 901         /* just return c to show that we didn't had a problem */
 902
 903         return c;
 904 }
 905
 906
 907 /* link_array ******************************************************************
 908
 909    This function is called by link_class to create the arraydescriptor
 910    for an array class.
 911
 912    This function returns NULL if the array cannot be linked because
 913    the component type has not been linked yet.
 914
 915 *******************************************************************************/
 916
 917 static arraydescriptor *link_array(classinfo *c)
 918 {
 919         classinfo       *comp;
 920         s4               namelen;
 921         arraydescriptor *desc;
 922         vftbl_t         *compvftbl;
 923         utf             *u;
 924
 925         comp = NULL;
 926         namelen = c->name->blength;
 927
 928         /* Check the component type */
 929
 930         switch (c->name->text[1]) {
 931         case '[':
 932                 /* c is an array of arrays. */
 933                 u = utf_new(c->name->text + 1, namelen - 1);
 934                 if (!(comp = load_class_from_classloader(u, c->classloader)))
 935                         return NULL;
 936                 break;
 937
 938         case 'L':
 939                 /* c is an array of objects. */
 940                 u = utf_new(c->name->text + 2, namelen - 3);
 941                 if (!(comp = load_class_from_classloader(u, c->classloader)))
 942                         return NULL;
 943                 break;
 944         }
 945
 946         /* If the component type has not been linked, link it now */
 947
 948         assert(!comp || (comp->state & CLASS_LOADED));
 949
 950         if (comp && !(comp->state & CLASS_LINKED))
 951                 if (!link_class(comp))
 952                         return NULL;
 953
 954         /* Allocate the arraydescriptor */
 955
 956         desc = NEW(arraydescriptor);
 957
 958         if (comp) {
 959                 /* c is an array of references */
 960                 desc->arraytype = ARRAYTYPE_OBJECT;
 961                 desc->componentsize = sizeof(void*);
 962                 desc->dataoffset = OFFSET(java_objectarray, data);
 963
 964                 compvftbl = comp->vftbl;
 965
 966                 if (!compvftbl) {
 967                         log_text("Component class has no vftbl");
 968                         assert(0);
 969                 }
 970
 971                 desc->componentvftbl = compvftbl;
 972
 973                 if (compvftbl->arraydesc) {
 974                         desc->elementvftbl = compvftbl->arraydesc->elementvftbl;
 975
 976                         if (compvftbl->arraydesc->dimension >= 255) {
 977                                 log_text("Creating array of dimension >255");
 978                                 assert(0);
 979                         }
 980
 981                         desc->dimension = compvftbl->arraydesc->dimension + 1;
 982                         desc->elementtype = compvftbl->arraydesc->elementtype;
 983
 984                 } else {
 985                         desc->elementvftbl = compvftbl;
 986                         desc->dimension = 1;
 987                         desc->elementtype = ARRAYTYPE_OBJECT;
 988                 }
 989
 990         } else {
 991                 /* c is an array of a primitive type */
 992                 switch (c->name->text[1]) {
 993                 case 'Z':
 994                         desc->arraytype = ARRAYTYPE_BOOLEAN;
 995                         desc->dataoffset = OFFSET(java_booleanarray,data);
 996                         desc->componentsize = sizeof(u1);
 997                         break;
 998
 999                 case 'B':
1000                         desc->arraytype = ARRAYTYPE_BYTE;
1001                         desc->dataoffset = OFFSET(java_bytearray,data);
1002                         desc->componentsize = sizeof(u1);
1003                         break;
1004
1005                 case 'C':
1006                         desc->arraytype = ARRAYTYPE_CHAR;
1007                         desc->dataoffset = OFFSET(java_chararray,data);
1008                         desc->componentsize = sizeof(u2);
1009                         break;
1010
1011                 case 'D':
1012                         desc->arraytype = ARRAYTYPE_DOUBLE;
1013                         desc->dataoffset = OFFSET(java_doublearray,data);
1014                         desc->componentsize = sizeof(double);
1015                         break;
1016
1017                 case 'F':
1018                         desc->arraytype = ARRAYTYPE_FLOAT;
1019                         desc->dataoffset = OFFSET(java_floatarray,data);
1020                         desc->componentsize = sizeof(float);
1021                         break;
1022
1023                 case 'I':
1024                         desc->arraytype = ARRAYTYPE_INT;
1025                         desc->dataoffset = OFFSET(java_intarray,data);
1026                         desc->componentsize = sizeof(s4);
1027                         break;
1028
1029                 case 'J':
1030                         desc->arraytype = ARRAYTYPE_LONG;
1031                         desc->dataoffset = OFFSET(java_longarray,data);
1032                         desc->componentsize = sizeof(s8);
1033                         break;
1034
1035                 case 'S':
1036                         desc->arraytype = ARRAYTYPE_SHORT;
1037                         desc->dataoffset = OFFSET(java_shortarray,data);
1038                         desc->componentsize = sizeof(s2);
1039                         break;
1040
1041                 default:
1042                         *exceptionptr = new_noclassdeffounderror(c->name);
1043                         return NULL;
1044                 }
1045
1046                 desc->componentvftbl = NULL;
1047                 desc->elementvftbl = NULL;
1048                 desc->dimension = 1;
1049                 desc->elementtype = desc->arraytype;
1050         }
1051
1052         return desc;
1053 }
1054
1055
1056 /* linker_compute_subclasses ***************************************************
1057
1058    XXX
1059
1060 *******************************************************************************/
1061
1062 static void linker_compute_subclasses(classinfo *c)
1063 {
1064 #if defined(USE_THREADS)
1065 #if defined(NATIVE_THREADS)
1066         compiler_lock();
1067 #else
1068         intsDisable();
1069 #endif
1070 #endif
1071
1072         if (!(c->flags & ACC_INTERFACE)) {
1073                 c->nextsub = 0;
1074                 c->sub = 0;
1075         }
1076
1077         if (!(c->flags & ACC_INTERFACE) && (c->super.any != NULL)) {
1078                 c->nextsub = c->super.cls->sub;
1079                 c->super.cls->sub = c;
1080         }
1081
1082         classvalue = 0;
1083
1084         /* compute class values */
1085
1086         linker_compute_class_values(class_java_lang_Object);
1087
1088 #if defined(USE_THREADS)
1089 #if defined(NATIVE_THREADS)
1090         compiler_unlock();
1091 #else
1092         intsRestore();
1093 #endif
1094 #endif
1095 }
1096
1097
1098 /* linker_compute_class_values *************************************************
1099
1100    XXX
1101
1102 *******************************************************************************/
1103
1104 static void linker_compute_class_values(classinfo *c)
1105 {
1106         classinfo *subs;
1107
1108         c->vftbl->baseval = ++classvalue;
1109
1110         subs = c->sub;
1111
1112         while (subs) {
1113                 linker_compute_class_values(subs);
1114
1115                 subs = subs->nextsub;
1116         }
1117
1118         c->vftbl->diffval = classvalue - c->vftbl->baseval;
1119 }
1120
1121
1122 /* linker_addinterface *********************************************************
1123
1124    Is needed by link_class for adding a VTBL to a class. All
1125    interfaces implemented by ic are added as well.
1126
1127    RETURN VALUE:
1128       true.........everything ok
1129           false........an exception has been thrown
1130
1131 *******************************************************************************/
1132
1133 static bool linker_addinterface(classinfo *c, classinfo *ic)
1134 {
1135         s4     j, m;
1136         s4     i   = ic->index;
1137         vftbl_t *v = c->vftbl;
1138
1139         if (i >= v->interfacetablelength) {
1140                 log_text("Inernal error: interfacetable overflow");
1141                 assert(0);
1142         }
1143
1144         /* if this interface has already been added, return immediately */
1145
1146         if (v->interfacetable[-i])
1147                 return true;
1148
1149         if (ic->methodscount == 0) {  /* fake entry needed for subtype test */
1150                 v->interfacevftbllength[i] = 1;
1151                 v->interfacetable[-i] = MNEW(methodptr, 1);
1152                 v->interfacetable[-i][0] = NULL;
1153
1154         }
1155         else {
1156                 v->interfacevftbllength[i] = ic->methodscount;
1157                 v->interfacetable[-i] = MNEW(methodptr, ic->methodscount);
1158
1159 #if defined(ENABLE_STATISTICS)
1160                 if (opt_stat)
1161                         count_vftbl_len += sizeof(methodptr) *
1162                                 (ic->methodscount + (ic->methodscount == 0));
1163 #endif
1164
1165                 for (j = 0; j < ic->methodscount; j++) {
1166                         classinfo *sc = c;
1167
1168                         while (sc) {
1169                                 for (m = 0; m < sc->methodscount; m++) {
1170                                         methodinfo *mi = &(sc->methods[m]);
1171
1172                                         if (method_canoverwrite(mi, &(ic->methods[j]))) {
1173                                                 /* method mi overwrites the (abstract) interface method */
1174 #if defined(ENABLE_VERIFIER)
1175                                                 if (!classcache_add_constraints_for_params(
1176                                                                         ic->classloader, c->classloader, mi))
1177                                                         return false;
1178 #endif
1179                                                 v->interfacetable[-i][j] = v->table[mi->vftblindex];
1180                                                 goto foundmethod;
1181                                         }
1182                                 }
1183                                 sc = sc->super.cls;
1184                         }
1185                 foundmethod:
1186                         ;
1187                 }
1188         }
1189
1190         /* add superinterfaces of this interface */
1191
1192         for (j = 0; j < ic->interfacescount; j++)
1193                 if (!linker_addinterface(c, ic->interfaces[j].cls))
1194                         return false;
1195
1196         /* everything ok */
1197         return true;
1198 }
1199
1200
1201 /* class_highestinterface ******************************************************
1202
1203    Used by the function link_class to determine the amount of memory
1204    needed for the interface table.
1205
1206 *******************************************************************************/
1207
1208 static s4 class_highestinterface(classinfo *c)
1209 {
1210         s4 h;
1211         s4 h2;
1212         s4 i;
1213
1214     /* check for ACC_INTERFACE bit already done in link_class_intern */
1215
1216     h = c->index;
1217
1218         for (i = 0; i < c->interfacescount; i++) {
1219                 h2 = class_highestinterface(c->interfaces[i].cls);
1220
1221                 if (h2 > h)
1222                         h = h2;
1223         }
1224
1225         return h;
1226 }
1227
1228
1229 /*
1230  * These are local overrides for various environment variables in Emacs.
1231  * Please do not remove this and leave it at the end of the file, where
1232  * Emacs will automagically detect them.
1233  * ---------------------------------------------------------------------
1234  * Local variables:
1235  * mode: c
1236  * indent-tabs-mode: t
1237  * c-basic-offset: 4
1238  * tab-width: 4
1239  * End:
1240  * vim:noexpandtab:sw=4:ts=4:
1241  */