src/vmcore/linker.c

   1 /* src/vmcore/linker.c - class linker functions
   2
   3    Copyright (C) 1996-2005, 2006, 2007, 2008
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5
   6    This file is part of CACAO.
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2, or (at
  11    your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23 */
  24
  25
  26 #include "config.h"
  27
  28 #include <assert.h>
  29 #include <stdint.h>
  30
  31 #include "vm/types.h"
  32
  33 #include "mm/memory.h"
  34
  35 #include "native/native.h"
  36
  37 #include "threads/lock-common.h"
  38
  39 #include "toolbox/logging.h"
  40
  41 #include "vm/access.h"
  42 #include "vm/array.h"
  43 #include "vm/exceptions.h"
  44 #include "vm/primitive.hpp"
  45 #include "vm/stringlocal.h"
  46 #include "vm/vm.h"
  47
  48 #include "vm/jit_interface.h"
  49
  50 #include "vmcore/class.h"
  51 #include "vmcore/classcache.h"
  52 #include "vmcore/loader.h"
  53 #include "vmcore/options.h"
  54 #include "vmcore/rt-timing.h"
  55
  56
  57 /* debugging macros ***********************************************************/
  58
  59 #if !defined(NDEBUG)
  60 # define TRACELINKCLASS(c) \
  61     do { \
  62         if (opt_TraceLinkClass) { \
  63             log_start(); \
  64             log_print("[Linking "); \
  65             class_print((c)); \
  66             log_print("]"); \
  67             log_finish(); \
  68         } \
  69     } while (0)
  70 #else
  71 # define TRACELINKCLASS(c)
  72 #endif
  73
  74
  75 /* #include "vm/resolve.h" */
  76 /* copied prototype to avoid bootstrapping problem: */
  77 classinfo *resolve_classref_or_classinfo_eager(classref_or_classinfo cls, bool checkaccess);
  78
  79 #if defined(ENABLE_STATISTICS)
  80 # include "vmcore/statistics.h"
  81 #endif
  82
  83 #if !defined(NDEBUG) && defined(ENABLE_INLINING)
  84 #define INLINELOG(code)  do { if (opt_TraceInlining) { code } } while (0)
  85 #else
  86 #define INLINELOG(code)
  87 #endif
  88
  89
  90 /* global variables ***********************************************************/
  91
  92 static s4 interfaceindex;       /* sequential numbering of interfaces         */
  93 static s4 classvalue;
  94
  95 java_object_t *linker_classrenumber_lock;
  96
  97
  98 /* private functions **********************************************************/
  99
 100 static classinfo *link_class_intern(classinfo *c);
 101 static arraydescriptor *link_array(classinfo *c);
 102 static void linker_compute_class_values(classinfo *c);
 103 static void linker_compute_subclasses(classinfo *c);
 104 static bool linker_addinterface(classinfo *c, classinfo *ic);
 105 static s4 class_highestinterface(classinfo *c);
 106
 107
 108 /* dummy structures for alinment checks ***************************************/
 109
 110 typedef struct dummy_alignment_long_t   dummy_alignment_long_t;
 111 typedef struct dummy_alignment_double_t dummy_alignment_double_t;
 112
 113 struct dummy_alignment_long_t {
 114         int32_t i;
 115         int64_t l;
 116 };
 117
 118 struct dummy_alignment_double_t {
 119         int32_t i;
 120         double  d;
 121 };
 122
 123
 124 /* linker_init *****************************************************************
 125
 126    Initializes the linker subsystem and links classes required for the
 127    primitive table.
 128
 129 *******************************************************************************/
 130
 131 void linker_preinit(void)
 132 {
 133         TRACESUBSYSTEMINITIALIZATION("linker_preinit");
 134
 135         /* Check for if alignment for long and double matches what we
 136            assume for the current architecture. */
 137
 138 #if defined(__I386__) || (defined(__ARM__) && !defined(__ARM_EABI__)) || (defined(__POWERPC__) && defined(__DARWIN__)) || defined(__M68K__)
 139         /* Define a define here which is later checked when we use this
 140            offset. */
 141
 142 # define LINKER_ALIGNMENT_LONG_DOUBLE 4
 143
 144         if (OFFSET(dummy_alignment_long_t, l) != 4)
 145                 vm_abort("linker_preinit: long alignment is different from what assumed: %d != %d",
 146                                  OFFSET(dummy_alignment_long_t, l), 4);
 147
 148         if (OFFSET(dummy_alignment_double_t, d) != 4)
 149                 vm_abort("linker_preinit: double alignment is different from what assumed: %d != %d",
 150                                  OFFSET(dummy_alignment_double_t, d), 4);
 151 #else
 152
 153 # define LINKER_ALIGNMENT_LONG_DOUBLE 8
 154
 155         if (OFFSET(dummy_alignment_long_t, l) != 8)
 156                 vm_abort("linker_preinit: long alignment is different from what assumed: %d != %d",
 157                                  OFFSET(dummy_alignment_long_t, l), 8);
 158
 159         if (OFFSET(dummy_alignment_double_t, d) != 8)
 160                 vm_abort("linker_preinit: double alignment is different from what assumed: %d != %d",
 161                                  OFFSET(dummy_alignment_double_t, d), 8);
 162 #endif
 163
 164         /* Reset interface index. */
 165
 166         interfaceindex = 0;
 167
 168 #if defined(ENABLE_THREADS)
 169         /* create the global lock object */
 170
 171         linker_classrenumber_lock = NEW(java_object_t);
 172
 173         LOCK_INIT_OBJECT_LOCK(linker_classrenumber_lock);
 174 #endif
 175
 176         /* Link the most basic classes. */
 177
 178         if (!link_class(class_java_lang_Object))
 179                 vm_abort("linker_preinit: linking java/lang/Object failed");
 180
 181 #if defined(ENABLE_JAVASE)
 182         if (!link_class(class_java_lang_Cloneable))
 183                 vm_abort("linker_preinit: linking java/lang/Cloneable failed");
 184
 185         if (!link_class(class_java_io_Serializable))
 186                 vm_abort("linker_preinit: linking java/io/Serializable failed");
 187 #endif
 188 }
 189
 190
 191 /* linker_init *****************************************************************
 192
 193    Links all classes required in the VM.
 194
 195 *******************************************************************************/
 196
 197 void linker_init(void)
 198 {
 199         TRACESUBSYSTEMINITIALIZATION("linker_init");
 200
 201         /* Link java.lang.Class as first class of the system, because we
 202        need it's vftbl for all other classes so we can use a class as
 203        object. */
 204
 205         if (!link_class(class_java_lang_Class))
 206                 vm_abort("linker_init: linking java/lang/Class failed");
 207
 208         /* Now set the header.vftbl of all classes which were created
 209        before java.lang.Class was linked. */
 210
 211         class_postset_header_vftbl();
 212
 213         /* Link primitive-type wrapping classes. */
 214
 215 #if defined(ENABLE_JAVASE)
 216         if (!link_class(class_java_lang_Void))
 217                 vm_abort("linker_init: linking failed");
 218 #endif
 219
 220         if (!link_class(class_java_lang_Boolean))
 221                 vm_abort("linker_init: linking failed");
 222
 223         if (!link_class(class_java_lang_Byte))
 224                 vm_abort("linker_init: linking failed");
 225
 226         if (!link_class(class_java_lang_Character))
 227                 vm_abort("linker_init: linking failed");
 228
 229         if (!link_class(class_java_lang_Short))
 230                 vm_abort("linker_init: linking failed");
 231
 232         if (!link_class(class_java_lang_Integer))
 233                 vm_abort("linker_init: linking failed");
 234
 235         if (!link_class(class_java_lang_Long))
 236                 vm_abort("linker_init: linking failed");
 237
 238         if (!link_class(class_java_lang_Float))
 239                 vm_abort("linker_init: linking failed");
 240
 241         if (!link_class(class_java_lang_Double))
 242                 vm_abort("linker_init: linking failed");
 243
 244         /* Link important system classes. */
 245
 246         if (!link_class(class_java_lang_String))
 247                 vm_abort("linker_init: linking java/lang/String failed");
 248
 249 #if defined(ENABLE_JAVASE)
 250         if (!link_class(class_java_lang_ClassLoader))
 251                 vm_abort("linker_init: linking failed");
 252
 253         if (!link_class(class_java_lang_SecurityManager))
 254                 vm_abort("linker_init: linking failed");
 255 #endif
 256
 257         if (!link_class(class_java_lang_System))
 258                 vm_abort("linker_init: linking failed");
 259
 260         if (!link_class(class_java_lang_Thread))
 261                 vm_abort("linker_init: linking failed");
 262
 263 #if defined(ENABLE_JAVASE)
 264         if (!link_class(class_java_lang_ThreadGroup))
 265                 vm_abort("linker_init: linking failed");
 266 #endif
 267
 268         if (!link_class(class_java_lang_Throwable))
 269                 vm_abort("linker_init: linking failed");
 270
 271 #if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
 272         if (!link_class(class_java_lang_VMSystem))
 273                 vm_abort("linker_init: linking failed");
 274
 275         if (!link_class(class_java_lang_VMThread))
 276                 vm_abort("linker_init: linking failed");
 277
 278         if (!link_class(class_java_lang_VMThrowable))
 279                 vm_abort("linker_init: linking failed");
 280 #endif
 281
 282         /* Important system exceptions. */
 283
 284         if (!link_class(class_java_lang_Exception))
 285                 vm_abort("linker_init: linking failed");
 286
 287         if (!link_class(class_java_lang_ClassNotFoundException))
 288                 vm_abort("linker_init: linking failed");
 289
 290         if (!link_class(class_java_lang_RuntimeException))
 291                 vm_abort("linker_init: linking failed");
 292
 293         /* some classes which may be used more often */
 294
 295 #if defined(ENABLE_JAVASE)
 296         if (!link_class(class_java_lang_StackTraceElement))
 297                 vm_abort("linker_init: linking failed");
 298
 299         if (!link_class(class_java_lang_reflect_Constructor))
 300                 vm_abort("linker_init: linking failed");
 301
 302         if (!link_class(class_java_lang_reflect_Field))
 303                 vm_abort("linker_init: linking failed");
 304
 305         if (!link_class(class_java_lang_reflect_Method))
 306                 vm_abort("linker_init: linking failed");
 307
 308 # if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
 309         if (!link_class(class_java_lang_reflect_VMConstructor))
 310                 vm_abort("linker_init: linking failed");
 311
 312         if (!link_class(class_java_lang_reflect_VMField))
 313                 vm_abort("linker_init: linking failed");
 314
 315         if (!link_class(class_java_lang_reflect_VMMethod))
 316                 vm_abort("linker_init: linking failed");
 317 # endif
 318
 319         if (!link_class(class_java_security_PrivilegedAction))
 320                 vm_abort("linker_init: linking failed");
 321
 322         if (!link_class(class_java_util_Vector))
 323                 vm_abort("linker_init: linking failed");
 324
 325         if (!link_class(class_java_util_HashMap))
 326                 vm_abort("linker_init: linking failed");
 327
 328 # if defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
 329         if (!link_class(class_sun_reflect_MagicAccessorImpl))
 330                 vm_abort("linker_init: linking failed");
 331 # endif
 332
 333         if (!link_class(arrayclass_java_lang_Object))
 334                 vm_abort("linker_init: linking failed");
 335 #endif
 336
 337
 338         /* create pseudo classes used by the typechecker */
 339
 340     /* pseudo class for Arraystubs (extends java.lang.Object) */
 341
 342         pseudo_class_Arraystub                   =
 343                 class_create_classinfo(utf_new_char("$ARRAYSTUB$"));
 344         pseudo_class_Arraystub->state           |= CLASS_LOADED;
 345         pseudo_class_Arraystub->super            = class_java_lang_Object;
 346
 347 #if defined(ENABLE_JAVASE)
 348
 349         pseudo_class_Arraystub->interfacescount  = 2;
 350         pseudo_class_Arraystub->interfaces       = MNEW(classinfo*, 2);
 351         pseudo_class_Arraystub->interfaces[0]    = class_java_lang_Cloneable;
 352         pseudo_class_Arraystub->interfaces[1]    = class_java_io_Serializable;
 353
 354 #elif defined(ENABLE_JAVAME_CLDC1_1)
 355
 356         pseudo_class_Arraystub->interfacescount    = 0;
 357         pseudo_class_Arraystub->interfaces         = NULL;
 358
 359 #else
 360 # error unknown Java configuration
 361 #endif
 362
 363         if (!classcache_store_unique(pseudo_class_Arraystub))
 364                 vm_abort("linker_init: could not cache pseudo_class_Arraystub");
 365
 366         if (!link_class(pseudo_class_Arraystub))
 367                 vm_abort("linker_init: linking pseudo_class_Arraystub failed");
 368
 369         /* pseudo class representing the null type */
 370
 371         pseudo_class_Null         = class_create_classinfo(utf_new_char("$NULL$"));
 372         pseudo_class_Null->state |= CLASS_LOADED;
 373         pseudo_class_Null->super  = class_java_lang_Object;
 374
 375         if (!classcache_store_unique(pseudo_class_Null))
 376                 vm_abort("linker_init: could not cache pseudo_class_Null");
 377
 378         if (!link_class(pseudo_class_Null))
 379                 vm_abort("linker_init: linking failed");
 380
 381         /* pseudo class representing new uninitialized objects */
 382
 383         pseudo_class_New         = class_create_classinfo(utf_new_char("$NEW$"));
 384         pseudo_class_New->state |= CLASS_LOADED;
 385         pseudo_class_New->state |= CLASS_LINKED; /* XXX is this allright? */
 386         pseudo_class_New->super  = class_java_lang_Object;
 387
 388         if (!classcache_store_unique(pseudo_class_New))
 389                 vm_abort("linker_init: could not cache pseudo_class_New");
 390
 391         /* Correct vftbl-entries (retarded loading and linking of class
 392            java/lang/String). */
 393
 394         stringtable_update();
 395 }
 396
 397
 398 /* link_class ******************************************************************
 399
 400    Wrapper function for link_class_intern to ease monitor enter/exit
 401    and exception handling.
 402
 403 *******************************************************************************/
 404
 405 classinfo *link_class(classinfo *c)
 406 {
 407         classinfo *r;
 408 #if defined(ENABLE_RT_TIMING)
 409         struct timespec time_start, time_end;
 410 #endif
 411
 412         RT_TIMING_GET_TIME(time_start);
 413
 414         if (c == NULL) {
 415                 exceptions_throw_nullpointerexception();
 416                 return NULL;
 417         }
 418
 419         LOCK_MONITOR_ENTER(c);
 420
 421         /* Maybe the class is currently linking or is already linked.*/
 422
 423         if ((c->state & CLASS_LINKING) || (c->state & CLASS_LINKED)) {
 424                 LOCK_MONITOR_EXIT(c);
 425
 426                 return c;
 427         }
 428
 429 #if defined(ENABLE_STATISTICS)
 430         /* measure time */
 431
 432         if (opt_getcompilingtime)
 433                 compilingtime_stop();
 434
 435         if (opt_getloadingtime)
 436                 loadingtime_start();
 437 #endif
 438
 439         /* call the internal function */
 440
 441         r = link_class_intern(c);
 442
 443         /* If return value is NULL, we had a problem and the class is not
 444            linked. */
 445
 446         if (r == NULL)
 447                 c->state &= ~CLASS_LINKING;
 448
 449 #if defined(ENABLE_STATISTICS)
 450         /* measure time */
 451
 452         if (opt_getloadingtime)
 453                 loadingtime_stop();
 454
 455         if (opt_getcompilingtime)
 456                 compilingtime_start();
 457 #endif
 458
 459         LOCK_MONITOR_EXIT(c);
 460
 461         RT_TIMING_GET_TIME(time_end);
 462
 463         RT_TIMING_TIME_DIFF(time_start,time_end,RT_TIMING_LINK_TOTAL);
 464
 465         return r;
 466 }
 467
 468
 469 /* linker_overwrite_method *****************************************************
 470
 471    Overwrite a method with another one, update method flags and check
 472    assumptions.
 473
 474    IN:
 475       mg................the general method being overwritten
 476           ms................the overwriting (more specialized) method
 477           wl................worklist where to add invalidated methods
 478
 479    RETURN VALUE:
 480       true..............everything ok
 481           false.............an exception has been thrown
 482
 483 *******************************************************************************/
 484
 485 static bool linker_overwrite_method(methodinfo *mg,
 486                                                                         methodinfo *ms,
 487                                                                         method_worklist **wl)
 488 {
 489         classinfo *cg;
 490         classinfo *cs;
 491
 492         cg = mg->clazz;
 493         cs = ms->clazz;
 494
 495         /* overriding a final method is illegal */
 496
 497         if (mg->flags & ACC_FINAL) {
 498                 exceptions_throw_verifyerror(mg, "Overriding final method");
 499                 return false;
 500         }
 501
 502         /* method ms overwrites method mg */
 503
 504 #if defined(ENABLE_VERIFIER)
 505         /* Add loading constraints (for the more general types of method mg). */
 506         /* Not for <init>, as it is not invoked virtually.                    */
 507
 508         if ((ms->name != utf_init)
 509                         && !classcache_add_constraints_for_params(
 510                                 cs->classloader, cg->classloader, mg))
 511         {
 512                 return false;
 513         }
 514 #endif
 515
 516         /* inherit the vftbl index, and record the overwriting */
 517
 518         ms->vftblindex = mg->vftblindex;
 519         ms->overwrites = mg;
 520
 521         /* update flags and check assumptions */
 522         /* <init> methods are a special case, as they are never dispatched dynamically */
 523
 524         if ((ms->flags & ACC_METHOD_IMPLEMENTED) && ms->name != utf_init) {
 525                 do {
 526
 527 #if defined(ENABLE_TLH)
 528                         if (mg->flags & ACC_METHOD_MONOMORPHY_USED) {
 529                                 printf("%s/%s is evil! the siner is %s/%s\n", mg->clazz->name->text, mg->name->text,
 530                                         ms->clazz->name->text, ms->name->text);
 531                                 ms->flags |= ACC_METHOD_PARENT_MONOMORPHY_USED;
 532                         }
 533 #endif
 534
 535                         if (mg->flags & ACC_METHOD_IMPLEMENTED) {
 536                                 /* this adds another implementation */
 537
 538                                 mg->flags &= ~ACC_METHOD_MONOMORPHIC;
 539
 540                                 INLINELOG( printf("becomes polymorphic: "); method_println(mg); );
 541
 542                                 method_break_assumption_monomorphic(mg, wl);
 543                         }
 544                         else {
 545                                 /* this is the first implementation */
 546
 547                                 mg->flags |= ACC_METHOD_IMPLEMENTED;
 548
 549                                 INLINELOG( printf("becomes implemented: "); method_println(mg); );
 550                         }
 551
 552                         ms = mg;
 553                         mg = mg->overwrites;
 554                 } while (mg != NULL);
 555         }
 556
 557         return true;
 558 }
 559
 560
 561 /* link_class_intern ***********************************************************
 562
 563    Tries to link a class. The function calculates the length in bytes
 564    that an instance of this class requires as well as the VTBL for
 565    methods and interface methods.
 566
 567 *******************************************************************************/
 568
 569 static classinfo *link_class_intern(classinfo *c)
 570 {
 571         classinfo *super;             /* super class                              */
 572         classinfo *tc;                /* temporary class variable                 */
 573         s4 supervftbllength;          /* vftbllegnth of super class               */
 574         s4 vftbllength;               /* vftbllength of current class             */
 575         s4 interfacetablelength;      /* interface table length                   */
 576         vftbl_t *v;                   /* vftbl of current class                   */
 577         s4 i;                         /* interface/method/field counter           */
 578         arraydescriptor *arraydesc;   /* descriptor for array classes             */
 579         method_worklist *worklist;    /* worklist for recompilation               */
 580 #if defined(ENABLE_RT_TIMING)
 581         struct timespec time_start, time_resolving, time_compute_vftbl,
 582                                         time_abstract, time_compute_iftbl, time_fill_vftbl,
 583                                         time_offsets, time_fill_iftbl, time_finalizer,
 584                                         time_subclasses;
 585 #endif
 586
 587         RT_TIMING_GET_TIME(time_start);
 588
 589         TRACELINKCLASS(c);
 590
 591         /* the class must be loaded */
 592
 593         /* XXX should this be a specific exception? */
 594         assert(c->state & CLASS_LOADED);
 595
 596         /* This is check in link_class. */
 597
 598         assert(!(c->state & CLASS_LINKED));
 599
 600         /* cache the self-reference of this class                          */
 601         /* we do this for cases where the defining loader of the class     */
 602         /* has not yet been recorded as an initiating loader for the class */
 603         /* this is needed so subsequent code can assume that self-refs     */
 604         /* will always resolve lazily                                      */
 605         /* No need to do it for the bootloader - it is always registered   */
 606         /* as initiating loader for the classes it loads.                  */
 607         if (c->classloader)
 608                 classcache_store(c->classloader,c,false);
 609
 610         /* this class is currently linking */
 611
 612         c->state |= CLASS_LINKING;
 613
 614         arraydesc = NULL;
 615         worklist = NULL;
 616
 617         /* Link the super interfaces. */
 618
 619         for (i = 0; i < c->interfacescount; i++) {
 620                 tc = c->interfaces[i];
 621
 622                 if (!(tc->state & CLASS_LINKED))
 623                         if (!link_class(tc))
 624                                 return NULL;
 625         }
 626
 627         /* check super class */
 628
 629         super = NULL;
 630
 631         /* Check for java/lang/Object. */
 632
 633         if (c->super == NULL) {
 634                 c->index = 0;
 635                 c->instancesize = sizeof(java_object_t);
 636
 637                 vftbllength = supervftbllength = 0;
 638
 639                 c->finalizer = NULL;
 640         }
 641         else {
 642                 /* Get super class. */
 643
 644                 super = c->super;
 645
 646                 /* Link the super class if necessary. */
 647
 648                 if (!(super->state & CLASS_LINKED))
 649                         if (!link_class(super))
 650                                 return NULL;
 651
 652                 /* OR the ACC_CLASS_HAS_POINTERS and the ACC_CLASS_REFERENCE_*
 653                    flags. */
 654
 655                 c->flags |= (super->flags &
 656                                          (ACC_CLASS_HAS_POINTERS | ACC_CLASS_REFERENCE_MASK));
 657
 658                 /* handle array classes */
 659
 660                 if (c->name->text[0] == '[')
 661                         if (!(arraydesc = link_array(c)))
 662                                 return NULL;
 663
 664                 if (c->flags & ACC_INTERFACE)
 665                         c->index = interfaceindex++;
 666                 else
 667                         c->index = super->index + 1;
 668
 669                 c->instancesize = super->instancesize;
 670
 671                 vftbllength = supervftbllength = super->vftbl->vftbllength;
 672
 673                 c->finalizer = super->finalizer;
 674         }
 675         RT_TIMING_GET_TIME(time_resolving);
 676
 677
 678         /* compute vftbl length */
 679
 680         for (i = 0; i < c->methodscount; i++) {
 681                 methodinfo *m = &(c->methods[i]);
 682
 683                 if (!(m->flags & ACC_STATIC)) { /* is instance method */
 684                         tc = super;
 685
 686                         while (tc) {
 687                                 s4 j;
 688
 689                                 for (j = 0; j < tc->methodscount; j++) {
 690                                         if (method_canoverwrite(m, &(tc->methods[j]))) {
 691                                                 if (tc->methods[j].flags & ACC_PRIVATE)
 692                                                         goto notfoundvftblindex;
 693
 694                                                 /* package-private methods in other packages */
 695                                                 /* must not be overridden                    */
 696                                                 /* (see Java Language Specification 8.4.8.1) */
 697                                                 if ( !(tc->methods[j].flags & (ACC_PUBLIC | ACC_PROTECTED))
 698                                                          && !SAME_PACKAGE(c,tc) )
 699                                                 {
 700                                                     goto notfoundvftblindex;
 701                                                 }
 702
 703                                                 if (!linker_overwrite_method(&(tc->methods[j]), m, &worklist))
 704                                                         return NULL;
 705
 706                                                 goto foundvftblindex;
 707                                         }
 708                                 }
 709
 710                                 tc = tc->super;
 711                         }
 712
 713                 notfoundvftblindex:
 714                         m->vftblindex = (vftbllength++);
 715                 foundvftblindex:
 716                         ;
 717                 }
 718         }
 719         RT_TIMING_GET_TIME(time_compute_vftbl);
 720
 721
 722         /* Check all interfaces of an abstract class (maybe be an
 723            interface too) for unimplemented methods.  Such methods are
 724            called miranda-methods and are marked with the ACC_MIRANDA
 725            flag.  VMClass.getDeclaredMethods does not return such
 726            methods. */
 727
 728         if (c->flags & ACC_ABSTRACT) {
 729                 classinfo  *ic;
 730                 methodinfo *im;
 731                 s4 abstractmethodscount;
 732                 s4 j;
 733                 s4 k;
 734
 735                 abstractmethodscount = 0;
 736
 737                 /* check all interfaces of the abstract class */
 738
 739                 for (i = 0; i < c->interfacescount; i++) {
 740                         ic = c->interfaces[i];
 741
 742                         for (j = 0; j < ic->methodscount; j++) {
 743                                 im = &(ic->methods[j]);
 744
 745                                 /* skip `<clinit>' and `<init>' */
 746
 747                                 if ((im->name == utf_clinit) || (im->name == utf_init))
 748                                         continue;
 749
 750                                 for (tc = c; tc != NULL; tc = tc->super) {
 751                                         for (k = 0; k < tc->methodscount; k++) {
 752                                                 if (method_canoverwrite(im, &(tc->methods[k])))
 753                                                         goto noabstractmethod;
 754                                         }
 755                                 }
 756
 757                                 abstractmethodscount++;
 758
 759                         noabstractmethod:
 760                                 ;
 761                         }
 762                 }
 763
 764                 if (abstractmethodscount > 0) {
 765                         methodinfo *am;
 766
 767                         /* reallocate methods memory */
 768
 769                         c->methods = MREALLOC(c->methods, methodinfo, c->methodscount,
 770                                                                   c->methodscount + abstractmethodscount);
 771
 772                         for (i = 0; i < c->interfacescount; i++) {
 773                                 ic = c->interfaces[i];
 774
 775                                 for (j = 0; j < ic->methodscount; j++) {
 776                                         im = &(ic->methods[j]);
 777
 778                                         /* skip `<clinit>' and `<init>' */
 779
 780                                         if ((im->name == utf_clinit) || (im->name == utf_init))
 781                                                 continue;
 782
 783                                         for (tc = c; tc != NULL; tc = tc->super) {
 784                                                 for (k = 0; k < tc->methodscount; k++) {
 785                                                         if (method_canoverwrite(im, &(tc->methods[k])))
 786                                                                 goto noabstractmethod2;
 787                                                 }
 788                                         }
 789
 790                                         /* Copy the method found into the new c->methods
 791                                            array and tag it as miranda-method. */
 792
 793                                         am = &(c->methods[c->methodscount]);
 794                                         c->methodscount++;
 795
 796                                         MCOPY(am, im, methodinfo, 1);
 797
 798                                         am->vftblindex  = (vftbllength++);
 799                                         am->clazz       = c;
 800                                         am->flags      |= ACC_MIRANDA;
 801
 802                                 noabstractmethod2:
 803                                         ;
 804                                 }
 805                         }
 806                 }
 807         }
 808         RT_TIMING_GET_TIME(time_abstract);
 809
 810
 811 #if defined(ENABLE_STATISTICS)
 812         if (opt_stat)
 813                 count_vftbl_len +=
 814                         sizeof(vftbl_t) + (sizeof(methodptr) * (vftbllength - 1));
 815 #endif
 816
 817         /* compute interfacetable length */
 818
 819         interfacetablelength = 0;
 820
 821         for (tc = c; tc != NULL; tc = tc->super) {
 822                 for (i = 0; i < tc->interfacescount; i++) {
 823                         s4 h = class_highestinterface(tc->interfaces[i]) + 1;
 824
 825                         if (h > interfacetablelength)
 826                                 interfacetablelength = h;
 827                 }
 828         }
 829         RT_TIMING_GET_TIME(time_compute_iftbl);
 830
 831         /* allocate virtual function table */
 832
 833         v = (vftbl_t *) mem_alloc(sizeof(vftbl_t) +
 834                                                           sizeof(methodptr) * (vftbllength - 1) +
 835                                                           sizeof(methodptr*) * (interfacetablelength - (interfacetablelength > 0)));
 836         v = (vftbl_t *) (((methodptr *) v) +
 837                                          (interfacetablelength - 1) * (interfacetablelength > 1));
 838
 839         c->vftbl                = v;
 840         v->clazz                = c;
 841         v->vftbllength          = vftbllength;
 842         v->interfacetablelength = interfacetablelength;
 843         v->arraydesc            = arraydesc;
 844
 845         /* store interface index in vftbl */
 846
 847         if (c->flags & ACC_INTERFACE)
 848                 v->baseval = -(c->index);
 849
 850         /* copy virtual function table of super class */
 851
 852         for (i = 0; i < supervftbllength; i++)
 853                 v->table[i] = super->vftbl->table[i];
 854
 855         /* Fill the remaining vftbl slots with the AbstractMethodError
 856            stub (all after the super class slots, because they are already
 857            initialized). */
 858
 859         for (; i < vftbllength; i++) {
 860 #if defined(ENABLE_JIT)
 861 # if defined(ENABLE_INTRP)
 862                 if (opt_intrp)
 863                         v->table[i] = (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
 864                 else
 865 # endif
 866                         v->table[i] = (methodptr) (ptrint) &asm_abstractmethoderror;
 867 #else
 868                 v->table[i] = (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
 869 #endif
 870         }
 871
 872         /* add method stubs into virtual function table */
 873
 874         for (i = 0; i < c->methodscount; i++) {
 875                 methodinfo *m = &(c->methods[i]);
 876
 877                 assert(m->stubroutine == NULL);
 878
 879                 /* Don't create a compiler stub for abstract methods as they
 880                    throw an AbstractMethodError with the default stub in the
 881                    vftbl.  This entry is simply copied by sub-classes. */
 882
 883                 if (m->flags & ACC_ABSTRACT)
 884                         continue;
 885
 886 #if defined(ENABLE_JIT)
 887 # if defined(ENABLE_INTRP)
 888                 if (opt_intrp)
 889                         m->stubroutine = intrp_createcompilerstub(m);
 890                 else
 891 #endif
 892                         m->stubroutine = codegen_generate_stub_compiler(m);
 893 #else
 894                 m->stubroutine = intrp_createcompilerstub(m);
 895 #endif
 896
 897                 /* static methods are not in the vftbl */
 898
 899                 if (m->flags & ACC_STATIC)
 900                         continue;
 901
 902                 /* insert the stubroutine into the vftbl */
 903
 904                 v->table[m->vftblindex] = (methodptr) (ptrint) m->stubroutine;
 905         }
 906         RT_TIMING_GET_TIME(time_fill_vftbl);
 907
 908         /* compute instance size and offset of each field */
 909
 910         for (i = 0; i < c->fieldscount; i++) {
 911                 s4 dsize;
 912                 fieldinfo *f = &(c->fields[i]);
 913
 914                 if (!(f->flags & ACC_STATIC)) {
 915                         dsize = descriptor_typesize(f->parseddesc);
 916
 917 #if defined(__I386__) || (defined(__ARM__) && !defined(__ARM_EABI__)) || (defined(__POWERPC__) && defined(__DARWIN__)) || defined(__M68K__)
 918                         /* On some architectures and configurations we need to
 919                            align long (int64_t) and double fields to 4-bytes to
 920                            match what GCC does for struct members.  We must do the
 921                            same as GCC here because the offsets in native header
 922                            structs like java_lang_Double must match the offsets of
 923                            the Java fields (eg. java.lang.Double.value). */
 924
 925 # if LINKER_ALIGNMENT_LONG_DOUBLE != 4
 926 #  error alignment of long and double is not 4
 927 # endif
 928
 929                         c->instancesize = MEMORY_ALIGN(c->instancesize, 4);
 930 #else
 931
 932 # if LINKER_ALIGNMENT_LONG_DOUBLE != 8
 933 #  error alignment of long and double is not 8
 934 # endif
 935
 936                         c->instancesize = MEMORY_ALIGN(c->instancesize, dsize);
 937 #endif
 938
 939                         f->offset = c->instancesize;
 940                         c->instancesize += dsize;
 941                 }
 942         }
 943         RT_TIMING_GET_TIME(time_offsets);
 944
 945         /* initialize interfacetable and interfacevftbllength */
 946
 947         v->interfacevftbllength = MNEW(s4, interfacetablelength);
 948
 949 #if defined(ENABLE_STATISTICS)
 950         if (opt_stat)
 951                 count_vftbl_len += (4 + sizeof(s4)) * v->interfacetablelength;
 952 #endif
 953
 954         for (i = 0; i < interfacetablelength; i++) {
 955                 v->interfacevftbllength[i] = 0;
 956                 v->interfacetable[-i] = NULL;
 957         }
 958
 959         /* add interfaces */
 960
 961         for (tc = c; tc != NULL; tc = tc->super)
 962                 for (i = 0; i < tc->interfacescount; i++)
 963                         if (!linker_addinterface(c, tc->interfaces[i]))
 964                                 return NULL;
 965
 966         RT_TIMING_GET_TIME(time_fill_iftbl);
 967
 968         /* add finalizer method (not for java.lang.Object) */
 969
 970         if (super) {
 971                 methodinfo *fi;
 972
 973                 fi = class_findmethod(c, utf_finalize, utf_void__void);
 974
 975                 if (fi)
 976                         if (!(fi->flags & ACC_STATIC))
 977                                 c->finalizer = fi;
 978         }
 979         RT_TIMING_GET_TIME(time_finalizer);
 980
 981         /* final tasks */
 982
 983         linker_compute_subclasses(c);
 984
 985         RT_TIMING_GET_TIME(time_subclasses);
 986
 987         /* revert the linking state and class is linked */
 988
 989         c->state = (c->state & ~CLASS_LINKING) | CLASS_LINKED;
 990
 991         /* check worklist */
 992
 993         /* XXX must this also be done in case of exception? */
 994
 995         while (worklist != NULL) {
 996                 method_worklist *wi = worklist;
 997
 998                 worklist = worklist->next;
 999
1000                 INLINELOG( printf("MUST BE RECOMPILED: "); method_println(wi->m); );
1001                 jit_invalidate_code(wi->m);
1002
1003                 /* XXX put worklist into dump memory? */
1004                 FREE(wi, method_worklist);
1005         }
1006
1007         RT_TIMING_TIME_DIFF(time_start        ,time_resolving    ,RT_TIMING_LINK_RESOLVE);
1008         RT_TIMING_TIME_DIFF(time_resolving    ,time_compute_vftbl,RT_TIMING_LINK_C_VFTBL);
1009         RT_TIMING_TIME_DIFF(time_compute_vftbl,time_abstract     ,RT_TIMING_LINK_ABSTRACT);
1010         RT_TIMING_TIME_DIFF(time_abstract     ,time_compute_iftbl,RT_TIMING_LINK_C_IFTBL);
1011         RT_TIMING_TIME_DIFF(time_compute_iftbl,time_fill_vftbl   ,RT_TIMING_LINK_F_VFTBL);
1012         RT_TIMING_TIME_DIFF(time_fill_vftbl   ,time_offsets      ,RT_TIMING_LINK_OFFSETS);
1013         RT_TIMING_TIME_DIFF(time_offsets      ,time_fill_iftbl   ,RT_TIMING_LINK_F_IFTBL);
1014         RT_TIMING_TIME_DIFF(time_fill_iftbl   ,time_finalizer    ,RT_TIMING_LINK_FINALIZER);
1015         RT_TIMING_TIME_DIFF(time_finalizer    ,time_subclasses   ,RT_TIMING_LINK_SUBCLASS);
1016
1017         /* just return c to show that we didn't had a problem */
1018
1019         return c;
1020 }
1021
1022
1023 /* link_array ******************************************************************
1024
1025    This function is called by link_class to create the arraydescriptor
1026    for an array class.
1027
1028    This function returns NULL if the array cannot be linked because
1029    the component type has not been linked yet.
1030
1031 *******************************************************************************/
1032
1033 static arraydescriptor *link_array(classinfo *c)
1034 {
1035         classinfo       *comp;
1036         s4               namelen;
1037         arraydescriptor *desc;
1038         vftbl_t         *compvftbl;
1039         utf             *u;
1040
1041         comp = NULL;
1042         namelen = c->name->blength;
1043
1044         /* Check the component type */
1045
1046         switch (c->name->text[1]) {
1047         case '[':
1048                 /* c is an array of arrays. */
1049                 u = utf_new(c->name->text + 1, namelen - 1);
1050                 if (!(comp = load_class_from_classloader(u, c->classloader)))
1051                         return NULL;
1052                 break;
1053
1054         case 'L':
1055                 /* c is an array of objects. */
1056                 u = utf_new(c->name->text + 2, namelen - 3);
1057                 if (!(comp = load_class_from_classloader(u, c->classloader)))
1058                         return NULL;
1059                 break;
1060         }
1061
1062         /* If the component type has not been linked, link it now */
1063
1064         assert(!comp || (comp->state & CLASS_LOADED));
1065
1066         if (comp && !(comp->state & CLASS_LINKED))
1067                 if (!link_class(comp))
1068                         return NULL;
1069
1070         /* Allocate the arraydescriptor */
1071
1072         desc = NEW(arraydescriptor);
1073
1074         if (comp) {
1075                 /* c is an array of references */
1076                 desc->arraytype = ARRAYTYPE_OBJECT;
1077                 desc->componentsize = sizeof(void*);
1078                 desc->dataoffset = OFFSET(java_objectarray_t, data);
1079
1080                 compvftbl = comp->vftbl;
1081
1082                 if (!compvftbl) {
1083                         log_text("Component class has no vftbl");
1084                         assert(0);
1085                 }
1086
1087                 desc->componentvftbl = compvftbl;
1088
1089                 if (compvftbl->arraydesc) {
1090                         desc->elementvftbl = compvftbl->arraydesc->elementvftbl;
1091
1092                         if (compvftbl->arraydesc->dimension >= 255) {
1093                                 log_text("Creating array of dimension >255");
1094                                 assert(0);
1095                         }
1096
1097                         desc->dimension = compvftbl->arraydesc->dimension + 1;
1098                         desc->elementtype = compvftbl->arraydesc->elementtype;
1099
1100                 } else {
1101                         desc->elementvftbl = compvftbl;
1102                         desc->dimension = 1;
1103                         desc->elementtype = ARRAYTYPE_OBJECT;
1104                 }
1105
1106         } else {
1107                 /* c is an array of a primitive type */
1108                 switch (c->name->text[1]) {
1109                 case 'Z':
1110                         desc->arraytype = ARRAYTYPE_BOOLEAN;
1111                         desc->dataoffset = OFFSET(java_booleanarray_t,data);
1112                         desc->componentsize = sizeof(u1);
1113                         break;
1114
1115                 case 'B':
1116                         desc->arraytype = ARRAYTYPE_BYTE;
1117                         desc->dataoffset = OFFSET(java_bytearray_t,data);
1118                         desc->componentsize = sizeof(u1);
1119                         break;
1120
1121                 case 'C':
1122                         desc->arraytype = ARRAYTYPE_CHAR;
1123                         desc->dataoffset = OFFSET(java_chararray_t,data);
1124                         desc->componentsize = sizeof(u2);
1125                         break;
1126
1127                 case 'D':
1128                         desc->arraytype = ARRAYTYPE_DOUBLE;
1129                         desc->dataoffset = OFFSET(java_doublearray_t,data);
1130                         desc->componentsize = sizeof(double);
1131                         break;
1132
1133                 case 'F':
1134                         desc->arraytype = ARRAYTYPE_FLOAT;
1135                         desc->dataoffset = OFFSET(java_floatarray_t,data);
1136                         desc->componentsize = sizeof(float);
1137                         break;
1138
1139                 case 'I':
1140                         desc->arraytype = ARRAYTYPE_INT;
1141                         desc->dataoffset = OFFSET(java_intarray_t,data);
1142                         desc->componentsize = sizeof(s4);
1143                         break;
1144
1145                 case 'J':
1146                         desc->arraytype = ARRAYTYPE_LONG;
1147                         desc->dataoffset = OFFSET(java_longarray_t,data);
1148                         desc->componentsize = sizeof(s8);
1149                         break;
1150
1151                 case 'S':
1152                         desc->arraytype = ARRAYTYPE_SHORT;
1153                         desc->dataoffset = OFFSET(java_shortarray_t,data);
1154                         desc->componentsize = sizeof(s2);
1155                         break;
1156
1157                 default:
1158                         exceptions_throw_noclassdeffounderror(c->name);
1159                         return NULL;
1160                 }
1161
1162                 desc->componentvftbl = NULL;
1163                 desc->elementvftbl = NULL;
1164                 desc->dimension = 1;
1165                 desc->elementtype = desc->arraytype;
1166         }
1167
1168         return desc;
1169 }
1170
1171
1172 /* linker_compute_subclasses ***************************************************
1173
1174    XXX
1175
1176    ATTENTION: DO NOT REMOVE ANY OF THE LOCKING MECHANISMS BELOW:
1177    This function needs to take the class renumber lock and stop the
1178    world during class renumbering. The lock is used in C code which
1179    is not that performance critical. Whereas JIT code uses critical
1180    sections to atomically access the class values.
1181
1182 *******************************************************************************/
1183
1184 static void linker_compute_subclasses(classinfo *c)
1185 {
1186         LOCK_MONITOR_ENTER(linker_classrenumber_lock);
1187
1188         if (!(c->flags & ACC_INTERFACE)) {
1189                 c->nextsub = NULL;
1190                 c->sub     = NULL;
1191         }
1192
1193         if (!(c->flags & ACC_INTERFACE) && (c->super != NULL)) {
1194                 c->nextsub    = c->super->sub;
1195                 c->super->sub = c;
1196         }
1197
1198         classvalue = 0;
1199
1200         /* compute class values */
1201
1202         linker_compute_class_values(class_java_lang_Object);
1203
1204         LOCK_MONITOR_EXIT(linker_classrenumber_lock);
1205 }
1206
1207
1208 /* linker_compute_class_values *************************************************
1209
1210    XXX
1211
1212 *******************************************************************************/
1213
1214 static void linker_compute_class_values(classinfo *c)
1215 {
1216         classinfo *subs;
1217
1218         c->vftbl->baseval = ++classvalue;
1219
1220         subs = c->sub;
1221
1222         while (subs) {
1223                 linker_compute_class_values(subs);
1224
1225                 subs = subs->nextsub;
1226         }
1227
1228         c->vftbl->diffval = classvalue - c->vftbl->baseval;
1229 }
1230
1231
1232 /* linker_addinterface *********************************************************
1233
1234    Is needed by link_class for adding a VTBL to a class. All
1235    interfaces implemented by ic are added as well.
1236
1237    RETURN VALUE:
1238       true.........everything ok
1239           false........an exception has been thrown
1240
1241 *******************************************************************************/
1242
1243 static bool linker_addinterface(classinfo *c, classinfo *ic)
1244 {
1245         s4          j, k;
1246         vftbl_t    *v;
1247         s4          i;
1248         classinfo  *sc;
1249         methodinfo *m;
1250
1251         v = c->vftbl;
1252         i = ic->index;
1253
1254         if (i >= v->interfacetablelength)
1255                 vm_abort("Internal error: interfacetable overflow");
1256
1257         /* if this interface has already been added, return immediately */
1258
1259         if (v->interfacetable[-i] != NULL)
1260                 return true;
1261
1262         if (ic->methodscount == 0) {  /* fake entry needed for subtype test */
1263                 v->interfacevftbllength[i] = 1;
1264                 v->interfacetable[-i]      = MNEW(methodptr, 1);
1265                 v->interfacetable[-i][0]   = NULL;
1266         }
1267         else {
1268                 v->interfacevftbllength[i] = ic->methodscount;
1269                 v->interfacetable[-i]      = MNEW(methodptr, ic->methodscount);
1270
1271 #if defined(ENABLE_STATISTICS)
1272                 if (opt_stat)
1273                         count_vftbl_len += sizeof(methodptr) *
1274                                 (ic->methodscount + (ic->methodscount == 0));
1275 #endif
1276
1277                 for (j = 0; j < ic->methodscount; j++) {
1278                         for (sc = c; sc != NULL; sc = sc->super) {
1279                                 for (k = 0; k < sc->methodscount; k++) {
1280                                         m = &(sc->methods[k]);
1281
1282                                         if (method_canoverwrite(m, &(ic->methods[j]))) {
1283                                                 /* method m overwrites the (abstract) method */
1284 #if defined(ENABLE_VERIFIER)
1285                                                 /* Add loading constraints (for the more
1286                                                    general types of the method
1287                                                    ic->methods[j]).  */
1288                                                 if (!classcache_add_constraints_for_params(
1289                                                                         c->classloader, ic->classloader,
1290                                                                         &(ic->methods[j])))
1291                                                 {
1292                                                         return false;
1293                                                 }
1294 #endif
1295
1296                                                 /* XXX taken from gcj */
1297                                                 /* check for ACC_STATIC: IncompatibleClassChangeError */
1298
1299                                                 /* check for !ACC_PUBLIC: IllegalAccessError */
1300
1301                                                 /* check for ACC_ABSTRACT: AbstracMethodError,
1302                                                    not sure about that one */
1303
1304                                                 v->interfacetable[-i][j] = v->table[m->vftblindex];
1305                                                 goto foundmethod;
1306                                         }
1307                                 }
1308                         }
1309
1310                         /* If no method was found, insert the AbstractMethodError
1311                            stub. */
1312
1313 #if defined(ENABLE_JIT)
1314 # if defined(ENABLE_INTRP)
1315                         if (opt_intrp)
1316                                 v->interfacetable[-i][j] =
1317                                         (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
1318                         else
1319 # endif
1320                                 v->interfacetable[-i][j] =
1321                                         (methodptr) (ptrint) &asm_abstractmethoderror;
1322 #else
1323                         v->interfacetable[-i][j] =
1324                                 (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
1325 #endif
1326
1327                 foundmethod:
1328                         ;
1329                 }
1330         }
1331
1332         /* add superinterfaces of this interface */
1333
1334         for (j = 0; j < ic->interfacescount; j++)
1335                 if (!linker_addinterface(c, ic->interfaces[j]))
1336                         return false;
1337
1338         /* everything ok */
1339
1340         return true;
1341 }
1342
1343
1344 /* class_highestinterface ******************************************************
1345
1346    Used by the function link_class to determine the amount of memory
1347    needed for the interface table.
1348
1349 *******************************************************************************/
1350
1351 static s4 class_highestinterface(classinfo *c)
1352 {
1353         s4 h;
1354         s4 h2;
1355         s4 i;
1356
1357     /* check for ACC_INTERFACE bit already done in link_class_intern */
1358
1359     h = c->index;
1360
1361         for (i = 0; i < c->interfacescount; i++) {
1362                 h2 = class_highestinterface(c->interfaces[i]);
1363
1364                 if (h2 > h)
1365                         h = h2;
1366         }
1367
1368         return h;
1369 }
1370
1371
1372 /*
1373  * These are local overrides for various environment variables in Emacs.
1374  * Please do not remove this and leave it at the end of the file, where
1375  * Emacs will automagically detect them.
1376  * ---------------------------------------------------------------------
1377  * Local variables:
1378  * mode: c
1379  * indent-tabs-mode: t
1380  * c-basic-offset: 4
1381  * tab-width: 4
1382  * End:
1383  * vim:noexpandtab:sw=4:ts=4:
1384  */