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