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.h"
  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_CLASSPATH_GNU)
 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_CLASSPATH_GNU)
 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_CLASSPATH_SUN)
 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                         if (mg->flags & ACC_METHOD_IMPLEMENTED) {
 527                                 /* this adds another implementation */
 528
 529                                 mg->flags &= ~ACC_METHOD_MONOMORPHIC;
 530
 531                                 INLINELOG( printf("becomes polymorphic: "); method_println(mg); );
 532
 533                                 method_break_assumption_monomorphic(mg, wl);
 534                         }
 535                         else {
 536                                 /* this is the first implementation */
 537
 538                                 mg->flags |= ACC_METHOD_IMPLEMENTED;
 539
 540                                 INLINELOG( printf("becomes implemented: "); method_println(mg); );
 541                         }
 542
 543                         ms = mg;
 544                         mg = mg->overwrites;
 545                 } while (mg != NULL);
 546         }
 547
 548         return true;
 549 }
 550
 551
 552 /* link_class_intern ***********************************************************
 553
 554    Tries to link a class. The function calculates the length in bytes
 555    that an instance of this class requires as well as the VTBL for
 556    methods and interface methods.
 557
 558 *******************************************************************************/
 559
 560 static classinfo *link_class_intern(classinfo *c)
 561 {
 562         classinfo *super;             /* super class                              */
 563         classinfo *tc;                /* temporary class variable                 */
 564         s4 supervftbllength;          /* vftbllegnth of super class               */
 565         s4 vftbllength;               /* vftbllength of current class             */
 566         s4 interfacetablelength;      /* interface table length                   */
 567         vftbl_t *v;                   /* vftbl of current class                   */
 568         s4 i;                         /* interface/method/field counter           */
 569         arraydescriptor *arraydesc;   /* descriptor for array classes             */
 570         method_worklist *worklist;    /* worklist for recompilation               */
 571 #if defined(ENABLE_RT_TIMING)
 572         struct timespec time_start, time_resolving, time_compute_vftbl,
 573                                         time_abstract, time_compute_iftbl, time_fill_vftbl,
 574                                         time_offsets, time_fill_iftbl, time_finalizer,
 575                                         time_subclasses;
 576 #endif
 577
 578         RT_TIMING_GET_TIME(time_start);
 579
 580         TRACELINKCLASS(c);
 581
 582         /* the class must be loaded */
 583
 584         /* XXX should this be a specific exception? */
 585         assert(c->state & CLASS_LOADED);
 586
 587         /* This is check in link_class. */
 588
 589         assert(!(c->state & CLASS_LINKED));
 590
 591         /* cache the self-reference of this class                          */
 592         /* we do this for cases where the defining loader of the class     */
 593         /* has not yet been recorded as an initiating loader for the class */
 594         /* this is needed so subsequent code can assume that self-refs     */
 595         /* will always resolve lazily                                      */
 596         /* No need to do it for the bootloader - it is always registered   */
 597         /* as initiating loader for the classes it loads.                  */
 598         if (c->classloader)
 599                 classcache_store(c->classloader,c,false);
 600
 601         /* this class is currently linking */
 602
 603         c->state |= CLASS_LINKING;
 604
 605         arraydesc = NULL;
 606         worklist = NULL;
 607
 608         /* Link the super interfaces. */
 609
 610         for (i = 0; i < c->interfacescount; i++) {
 611                 tc = c->interfaces[i];
 612
 613                 if (!(tc->state & CLASS_LINKED))
 614                         if (!link_class(tc))
 615                                 return NULL;
 616         }
 617
 618         /* check super class */
 619
 620         super = NULL;
 621
 622         /* Check for java/lang/Object. */
 623
 624         if (c->super == NULL) {
 625                 c->index = 0;
 626                 c->instancesize = sizeof(java_object_t);
 627
 628                 vftbllength = supervftbllength = 0;
 629
 630                 c->finalizer = NULL;
 631         }
 632         else {
 633                 /* Get super class. */
 634
 635                 super = c->super;
 636
 637                 /* Link the super class if necessary. */
 638
 639                 if (!(super->state & CLASS_LINKED))
 640                         if (!link_class(super))
 641                                 return NULL;
 642
 643                 /* OR the ACC_CLASS_HAS_POINTERS and the ACC_CLASS_REFERENCE_*
 644                    flags. */
 645
 646                 c->flags |= (super->flags &
 647                                          (ACC_CLASS_HAS_POINTERS | ACC_CLASS_REFERENCE_MASK));
 648
 649                 /* handle array classes */
 650
 651                 if (c->name->text[0] == '[')
 652                         if (!(arraydesc = link_array(c)))
 653                                 return NULL;
 654
 655                 if (c->flags & ACC_INTERFACE)
 656                         c->index = interfaceindex++;
 657                 else
 658                         c->index = super->index + 1;
 659
 660                 c->instancesize = super->instancesize;
 661
 662                 vftbllength = supervftbllength = super->vftbl->vftbllength;
 663
 664                 c->finalizer = super->finalizer;
 665         }
 666         RT_TIMING_GET_TIME(time_resolving);
 667
 668
 669         /* compute vftbl length */
 670
 671         for (i = 0; i < c->methodscount; i++) {
 672                 methodinfo *m = &(c->methods[i]);
 673
 674                 if (!(m->flags & ACC_STATIC)) { /* is instance method */
 675                         tc = super;
 676
 677                         while (tc) {
 678                                 s4 j;
 679
 680                                 for (j = 0; j < tc->methodscount; j++) {
 681                                         if (method_canoverwrite(m, &(tc->methods[j]))) {
 682                                                 if (tc->methods[j].flags & ACC_PRIVATE)
 683                                                         goto notfoundvftblindex;
 684
 685                                                 /* package-private methods in other packages */
 686                                                 /* must not be overridden                    */
 687                                                 /* (see Java Language Specification 8.4.8.1) */
 688                                                 if ( !(tc->methods[j].flags & (ACC_PUBLIC | ACC_PROTECTED))
 689                                                          && !SAME_PACKAGE(c,tc) )
 690                                                 {
 691                                                     goto notfoundvftblindex;
 692                                                 }
 693
 694                                                 if (!linker_overwrite_method(&(tc->methods[j]), m, &worklist))
 695                                                         return NULL;
 696
 697                                                 goto foundvftblindex;
 698                                         }
 699                                 }
 700
 701                                 tc = tc->super;
 702                         }
 703
 704                 notfoundvftblindex:
 705                         m->vftblindex = (vftbllength++);
 706                 foundvftblindex:
 707                         ;
 708                 }
 709         }
 710         RT_TIMING_GET_TIME(time_compute_vftbl);
 711
 712
 713         /* Check all interfaces of an abstract class (maybe be an
 714            interface too) for unimplemented methods.  Such methods are
 715            called miranda-methods and are marked with the ACC_MIRANDA
 716            flag.  VMClass.getDeclaredMethods does not return such
 717            methods. */
 718
 719         if (c->flags & ACC_ABSTRACT) {
 720                 classinfo  *ic;
 721                 methodinfo *im;
 722                 s4 abstractmethodscount;
 723                 s4 j;
 724                 s4 k;
 725
 726                 abstractmethodscount = 0;
 727
 728                 /* check all interfaces of the abstract class */
 729
 730                 for (i = 0; i < c->interfacescount; i++) {
 731                         ic = c->interfaces[i];
 732
 733                         for (j = 0; j < ic->methodscount; j++) {
 734                                 im = &(ic->methods[j]);
 735
 736                                 /* skip `<clinit>' and `<init>' */
 737
 738                                 if ((im->name == utf_clinit) || (im->name == utf_init))
 739                                         continue;
 740
 741                                 for (tc = c; tc != NULL; tc = tc->super) {
 742                                         for (k = 0; k < tc->methodscount; k++) {
 743                                                 if (method_canoverwrite(im, &(tc->methods[k])))
 744                                                         goto noabstractmethod;
 745                                         }
 746                                 }
 747
 748                                 abstractmethodscount++;
 749
 750                         noabstractmethod:
 751                                 ;
 752                         }
 753                 }
 754
 755                 if (abstractmethodscount > 0) {
 756                         methodinfo *am;
 757
 758                         /* reallocate methods memory */
 759
 760                         c->methods = MREALLOC(c->methods, methodinfo, c->methodscount,
 761                                                                   c->methodscount + abstractmethodscount);
 762
 763                         for (i = 0; i < c->interfacescount; i++) {
 764                                 ic = c->interfaces[i];
 765
 766                                 for (j = 0; j < ic->methodscount; j++) {
 767                                         im = &(ic->methods[j]);
 768
 769                                         /* skip `<clinit>' and `<init>' */
 770
 771                                         if ((im->name == utf_clinit) || (im->name == utf_init))
 772                                                 continue;
 773
 774                                         for (tc = c; tc != NULL; tc = tc->super) {
 775                                                 for (k = 0; k < tc->methodscount; k++) {
 776                                                         if (method_canoverwrite(im, &(tc->methods[k])))
 777                                                                 goto noabstractmethod2;
 778                                                 }
 779                                         }
 780
 781                                         /* Copy the method found into the new c->methods
 782                                            array and tag it as miranda-method. */
 783
 784                                         am = &(c->methods[c->methodscount]);
 785                                         c->methodscount++;
 786
 787                                         MCOPY(am, im, methodinfo, 1);
 788
 789                                         am->vftblindex  = (vftbllength++);
 790                                         am->clazz       = c;
 791                                         am->flags      |= ACC_MIRANDA;
 792
 793                                 noabstractmethod2:
 794                                         ;
 795                                 }
 796                         }
 797                 }
 798         }
 799         RT_TIMING_GET_TIME(time_abstract);
 800
 801
 802 #if defined(ENABLE_STATISTICS)
 803         if (opt_stat)
 804                 count_vftbl_len +=
 805                         sizeof(vftbl_t) + (sizeof(methodptr) * (vftbllength - 1));
 806 #endif
 807
 808         /* compute interfacetable length */
 809
 810         interfacetablelength = 0;
 811
 812         for (tc = c; tc != NULL; tc = tc->super) {
 813                 for (i = 0; i < tc->interfacescount; i++) {
 814                         s4 h = class_highestinterface(tc->interfaces[i]) + 1;
 815
 816                         if (h > interfacetablelength)
 817                                 interfacetablelength = h;
 818                 }
 819         }
 820         RT_TIMING_GET_TIME(time_compute_iftbl);
 821
 822         /* allocate virtual function table */
 823
 824         v = (vftbl_t *) mem_alloc(sizeof(vftbl_t) +
 825                                                           sizeof(methodptr) * (vftbllength - 1) +
 826                                                           sizeof(methodptr*) * (interfacetablelength - (interfacetablelength > 0)));
 827         v = (vftbl_t *) (((methodptr *) v) +
 828                                          (interfacetablelength - 1) * (interfacetablelength > 1));
 829
 830         c->vftbl                = v;
 831         v->clazz                = c;
 832         v->vftbllength          = vftbllength;
 833         v->interfacetablelength = interfacetablelength;
 834         v->arraydesc            = arraydesc;
 835
 836         /* store interface index in vftbl */
 837
 838         if (c->flags & ACC_INTERFACE)
 839                 v->baseval = -(c->index);
 840
 841         /* copy virtual function table of super class */
 842
 843         for (i = 0; i < supervftbllength; i++)
 844                 v->table[i] = super->vftbl->table[i];
 845
 846         /* Fill the remaining vftbl slots with the AbstractMethodError
 847            stub (all after the super class slots, because they are already
 848            initialized). */
 849
 850         for (; i < vftbllength; i++) {
 851 #if defined(ENABLE_JIT)
 852 # if defined(ENABLE_INTRP)
 853                 if (opt_intrp)
 854                         v->table[i] = (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
 855                 else
 856 # endif
 857                         v->table[i] = (methodptr) (ptrint) &asm_abstractmethoderror;
 858 #else
 859                 v->table[i] = (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
 860 #endif
 861         }
 862
 863         /* add method stubs into virtual function table */
 864
 865         for (i = 0; i < c->methodscount; i++) {
 866                 methodinfo *m = &(c->methods[i]);
 867
 868                 assert(m->stubroutine == NULL);
 869
 870                 /* Don't create a compiler stub for abstract methods as they
 871                    throw an AbstractMethodError with the default stub in the
 872                    vftbl.  This entry is simply copied by sub-classes. */
 873
 874                 if (m->flags & ACC_ABSTRACT)
 875                         continue;
 876
 877 #if defined(ENABLE_JIT)
 878 # if defined(ENABLE_INTRP)
 879                 if (opt_intrp)
 880                         m->stubroutine = intrp_createcompilerstub(m);
 881                 else
 882 #endif
 883                         m->stubroutine = codegen_generate_stub_compiler(m);
 884 #else
 885                 m->stubroutine = intrp_createcompilerstub(m);
 886 #endif
 887
 888                 /* static methods are not in the vftbl */
 889
 890                 if (m->flags & ACC_STATIC)
 891                         continue;
 892
 893                 /* insert the stubroutine into the vftbl */
 894
 895                 v->table[m->vftblindex] = (methodptr) (ptrint) m->stubroutine;
 896         }
 897         RT_TIMING_GET_TIME(time_fill_vftbl);
 898
 899         /* compute instance size and offset of each field */
 900
 901         for (i = 0; i < c->fieldscount; i++) {
 902                 s4 dsize;
 903                 fieldinfo *f = &(c->fields[i]);
 904
 905                 if (!(f->flags & ACC_STATIC)) {
 906                         dsize = descriptor_typesize(f->parseddesc);
 907
 908 #if defined(__I386__) || (defined(__ARM__) && !defined(__ARM_EABI__)) || (defined(__POWERPC__) && defined(__DARWIN__)) || defined(__M68K__)
 909                         /* On some architectures and configurations we need to
 910                            align long (int64_t) and double fields to 4-bytes to
 911                            match what GCC does for struct members.  We must do the
 912                            same as GCC here because the offsets in native header
 913                            structs like java_lang_Double must match the offsets of
 914                            the Java fields (eg. java.lang.Double.value). */
 915
 916 # if LINKER_ALIGNMENT_LONG_DOUBLE != 4
 917 #  error alignment of long and double is not 4
 918 # endif
 919
 920                         c->instancesize = MEMORY_ALIGN(c->instancesize, 4);
 921 #else
 922
 923 # if LINKER_ALIGNMENT_LONG_DOUBLE != 8
 924 #  error alignment of long and double is not 8
 925 # endif
 926
 927                         c->instancesize = MEMORY_ALIGN(c->instancesize, dsize);
 928 #endif
 929
 930                         f->offset = c->instancesize;
 931                         c->instancesize += dsize;
 932                 }
 933         }
 934         RT_TIMING_GET_TIME(time_offsets);
 935
 936         /* initialize interfacetable and interfacevftbllength */
 937
 938         v->interfacevftbllength = MNEW(s4, interfacetablelength);
 939
 940 #if defined(ENABLE_STATISTICS)
 941         if (opt_stat)
 942                 count_vftbl_len += (4 + sizeof(s4)) * v->interfacetablelength;
 943 #endif
 944
 945         for (i = 0; i < interfacetablelength; i++) {
 946                 v->interfacevftbllength[i] = 0;
 947                 v->interfacetable[-i] = NULL;
 948         }
 949
 950         /* add interfaces */
 951
 952         for (tc = c; tc != NULL; tc = tc->super)
 953                 for (i = 0; i < tc->interfacescount; i++)
 954                         if (!linker_addinterface(c, tc->interfaces[i]))
 955                                 return NULL;
 956
 957         RT_TIMING_GET_TIME(time_fill_iftbl);
 958
 959         /* add finalizer method (not for java.lang.Object) */
 960
 961         if (super) {
 962                 methodinfo *fi;
 963
 964                 fi = class_findmethod(c, utf_finalize, utf_void__void);
 965
 966                 if (fi)
 967                         if (!(fi->flags & ACC_STATIC))
 968                                 c->finalizer = fi;
 969         }
 970         RT_TIMING_GET_TIME(time_finalizer);
 971
 972         /* final tasks */
 973
 974         linker_compute_subclasses(c);
 975
 976         RT_TIMING_GET_TIME(time_subclasses);
 977
 978         /* revert the linking state and class is linked */
 979
 980         c->state = (c->state & ~CLASS_LINKING) | CLASS_LINKED;
 981
 982         /* check worklist */
 983
 984         /* XXX must this also be done in case of exception? */
 985
 986         while (worklist != NULL) {
 987                 method_worklist *wi = worklist;
 988
 989                 worklist = worklist->next;
 990
 991                 INLINELOG( printf("MUST BE RECOMPILED: "); method_println(wi->m); );
 992                 jit_invalidate_code(wi->m);
 993
 994                 /* XXX put worklist into dump memory? */
 995                 FREE(wi, method_worklist);
 996         }
 997
 998         RT_TIMING_TIME_DIFF(time_start        ,time_resolving    ,RT_TIMING_LINK_RESOLVE);
 999         RT_TIMING_TIME_DIFF(time_resolving    ,time_compute_vftbl,RT_TIMING_LINK_C_VFTBL);
1000         RT_TIMING_TIME_DIFF(time_compute_vftbl,time_abstract     ,RT_TIMING_LINK_ABSTRACT);
1001         RT_TIMING_TIME_DIFF(time_abstract     ,time_compute_iftbl,RT_TIMING_LINK_C_IFTBL);
1002         RT_TIMING_TIME_DIFF(time_compute_iftbl,time_fill_vftbl   ,RT_TIMING_LINK_F_VFTBL);
1003         RT_TIMING_TIME_DIFF(time_fill_vftbl   ,time_offsets      ,RT_TIMING_LINK_OFFSETS);
1004         RT_TIMING_TIME_DIFF(time_offsets      ,time_fill_iftbl   ,RT_TIMING_LINK_F_IFTBL);
1005         RT_TIMING_TIME_DIFF(time_fill_iftbl   ,time_finalizer    ,RT_TIMING_LINK_FINALIZER);
1006         RT_TIMING_TIME_DIFF(time_finalizer    ,time_subclasses   ,RT_TIMING_LINK_SUBCLASS);
1007
1008         /* just return c to show that we didn't had a problem */
1009
1010         return c;
1011 }
1012
1013
1014 /* link_array ******************************************************************
1015
1016    This function is called by link_class to create the arraydescriptor
1017    for an array class.
1018
1019    This function returns NULL if the array cannot be linked because
1020    the component type has not been linked yet.
1021
1022 *******************************************************************************/
1023
1024 static arraydescriptor *link_array(classinfo *c)
1025 {
1026         classinfo       *comp;
1027         s4               namelen;
1028         arraydescriptor *desc;
1029         vftbl_t         *compvftbl;
1030         utf             *u;
1031
1032         comp = NULL;
1033         namelen = c->name->blength;
1034
1035         /* Check the component type */
1036
1037         switch (c->name->text[1]) {
1038         case '[':
1039                 /* c is an array of arrays. */
1040                 u = utf_new(c->name->text + 1, namelen - 1);
1041                 if (!(comp = load_class_from_classloader(u, c->classloader)))
1042                         return NULL;
1043                 break;
1044
1045         case 'L':
1046                 /* c is an array of objects. */
1047                 u = utf_new(c->name->text + 2, namelen - 3);
1048                 if (!(comp = load_class_from_classloader(u, c->classloader)))
1049                         return NULL;
1050                 break;
1051         }
1052
1053         /* If the component type has not been linked, link it now */
1054
1055         assert(!comp || (comp->state & CLASS_LOADED));
1056
1057         if (comp && !(comp->state & CLASS_LINKED))
1058                 if (!link_class(comp))
1059                         return NULL;
1060
1061         /* Allocate the arraydescriptor */
1062
1063         desc = NEW(arraydescriptor);
1064
1065         if (comp) {
1066                 /* c is an array of references */
1067                 desc->arraytype = ARRAYTYPE_OBJECT;
1068                 desc->componentsize = sizeof(void*);
1069                 desc->dataoffset = OFFSET(java_objectarray_t, data);
1070
1071                 compvftbl = comp->vftbl;
1072
1073                 if (!compvftbl) {
1074                         log_text("Component class has no vftbl");
1075                         assert(0);
1076                 }
1077
1078                 desc->componentvftbl = compvftbl;
1079
1080                 if (compvftbl->arraydesc) {
1081                         desc->elementvftbl = compvftbl->arraydesc->elementvftbl;
1082
1083                         if (compvftbl->arraydesc->dimension >= 255) {
1084                                 log_text("Creating array of dimension >255");
1085                                 assert(0);
1086                         }
1087
1088                         desc->dimension = compvftbl->arraydesc->dimension + 1;
1089                         desc->elementtype = compvftbl->arraydesc->elementtype;
1090
1091                 } else {
1092                         desc->elementvftbl = compvftbl;
1093                         desc->dimension = 1;
1094                         desc->elementtype = ARRAYTYPE_OBJECT;
1095                 }
1096
1097         } else {
1098                 /* c is an array of a primitive type */
1099                 switch (c->name->text[1]) {
1100                 case 'Z':
1101                         desc->arraytype = ARRAYTYPE_BOOLEAN;
1102                         desc->dataoffset = OFFSET(java_booleanarray_t,data);
1103                         desc->componentsize = sizeof(u1);
1104                         break;
1105
1106                 case 'B':
1107                         desc->arraytype = ARRAYTYPE_BYTE;
1108                         desc->dataoffset = OFFSET(java_bytearray_t,data);
1109                         desc->componentsize = sizeof(u1);
1110                         break;
1111
1112                 case 'C':
1113                         desc->arraytype = ARRAYTYPE_CHAR;
1114                         desc->dataoffset = OFFSET(java_chararray_t,data);
1115                         desc->componentsize = sizeof(u2);
1116                         break;
1117
1118                 case 'D':
1119                         desc->arraytype = ARRAYTYPE_DOUBLE;
1120                         desc->dataoffset = OFFSET(java_doublearray_t,data);
1121                         desc->componentsize = sizeof(double);
1122                         break;
1123
1124                 case 'F':
1125                         desc->arraytype = ARRAYTYPE_FLOAT;
1126                         desc->dataoffset = OFFSET(java_floatarray_t,data);
1127                         desc->componentsize = sizeof(float);
1128                         break;
1129
1130                 case 'I':
1131                         desc->arraytype = ARRAYTYPE_INT;
1132                         desc->dataoffset = OFFSET(java_intarray_t,data);
1133                         desc->componentsize = sizeof(s4);
1134                         break;
1135
1136                 case 'J':
1137                         desc->arraytype = ARRAYTYPE_LONG;
1138                         desc->dataoffset = OFFSET(java_longarray_t,data);
1139                         desc->componentsize = sizeof(s8);
1140                         break;
1141
1142                 case 'S':
1143                         desc->arraytype = ARRAYTYPE_SHORT;
1144                         desc->dataoffset = OFFSET(java_shortarray_t,data);
1145                         desc->componentsize = sizeof(s2);
1146                         break;
1147
1148                 default:
1149                         exceptions_throw_noclassdeffounderror(c->name);
1150                         return NULL;
1151                 }
1152
1153                 desc->componentvftbl = NULL;
1154                 desc->elementvftbl = NULL;
1155                 desc->dimension = 1;
1156                 desc->elementtype = desc->arraytype;
1157         }
1158
1159         return desc;
1160 }
1161
1162
1163 /* linker_compute_subclasses ***************************************************
1164
1165    XXX
1166
1167    ATTENTION: DO NOT REMOVE ANY OF THE LOCKING MECHANISMS BELOW:
1168    This function needs to take the class renumber lock and stop the
1169    world during class renumbering. The lock is used in C code which
1170    is not that performance critical. Whereas JIT code uses critical
1171    sections to atomically access the class values.
1172
1173 *******************************************************************************/
1174
1175 static void linker_compute_subclasses(classinfo *c)
1176 {
1177         LOCK_MONITOR_ENTER(linker_classrenumber_lock);
1178
1179 #if 0 && defined(ENABLE_THREADS) && !defined(DISABLE_GC)
1180         threads_stopworld();
1181 #endif
1182
1183         if (!(c->flags & ACC_INTERFACE)) {
1184                 c->nextsub = NULL;
1185                 c->sub     = NULL;
1186         }
1187
1188         if (!(c->flags & ACC_INTERFACE) && (c->super != NULL)) {
1189                 c->nextsub    = c->super->sub;
1190                 c->super->sub = c;
1191         }
1192
1193         classvalue = 0;
1194
1195         /* compute class values */
1196
1197         linker_compute_class_values(class_java_lang_Object);
1198
1199         LOCK_MONITOR_EXIT(linker_classrenumber_lock);
1200
1201 #if 0 && defined(ENABLE_THREADS) && !defined(DISABLE_GC)
1202         threads_startworld();
1203 #endif
1204 }
1205
1206
1207 /* linker_compute_class_values *************************************************
1208
1209    XXX
1210
1211 *******************************************************************************/
1212
1213 static void linker_compute_class_values(classinfo *c)
1214 {
1215         classinfo *subs;
1216
1217         c->vftbl->baseval = ++classvalue;
1218
1219         subs = c->sub;
1220
1221         while (subs) {
1222                 linker_compute_class_values(subs);
1223
1224                 subs = subs->nextsub;
1225         }
1226
1227         c->vftbl->diffval = classvalue - c->vftbl->baseval;
1228 }
1229
1230
1231 /* linker_addinterface *********************************************************
1232
1233    Is needed by link_class for adding a VTBL to a class. All
1234    interfaces implemented by ic are added as well.
1235
1236    RETURN VALUE:
1237       true.........everything ok
1238           false........an exception has been thrown
1239
1240 *******************************************************************************/
1241
1242 static bool linker_addinterface(classinfo *c, classinfo *ic)
1243 {
1244         s4          j, k;
1245         vftbl_t    *v;
1246         s4          i;
1247         classinfo  *sc;
1248         methodinfo *m;
1249
1250         v = c->vftbl;
1251         i = ic->index;
1252
1253         if (i >= v->interfacetablelength)
1254                 vm_abort("Internal error: interfacetable overflow");
1255
1256         /* if this interface has already been added, return immediately */
1257
1258         if (v->interfacetable[-i] != NULL)
1259                 return true;
1260
1261         if (ic->methodscount == 0) {  /* fake entry needed for subtype test */
1262                 v->interfacevftbllength[i] = 1;
1263                 v->interfacetable[-i]      = MNEW(methodptr, 1);
1264                 v->interfacetable[-i][0]   = NULL;
1265         }
1266         else {
1267                 v->interfacevftbllength[i] = ic->methodscount;
1268                 v->interfacetable[-i]      = MNEW(methodptr, ic->methodscount);
1269
1270 #if defined(ENABLE_STATISTICS)
1271                 if (opt_stat)
1272                         count_vftbl_len += sizeof(methodptr) *
1273                                 (ic->methodscount + (ic->methodscount == 0));
1274 #endif
1275
1276                 for (j = 0; j < ic->methodscount; j++) {
1277                         for (sc = c; sc != NULL; sc = sc->super) {
1278                                 for (k = 0; k < sc->methodscount; k++) {
1279                                         m = &(sc->methods[k]);
1280
1281                                         if (method_canoverwrite(m, &(ic->methods[j]))) {
1282                                                 /* method m overwrites the (abstract) method */
1283 #if defined(ENABLE_VERIFIER)
1284                                                 /* Add loading constraints (for the more
1285                                                    general types of the method
1286                                                    ic->methods[j]).  */
1287                                                 if (!classcache_add_constraints_for_params(
1288                                                                         c->classloader, ic->classloader,
1289                                                                         &(ic->methods[j])))
1290                                                 {
1291                                                         return false;
1292                                                 }
1293 #endif
1294
1295                                                 /* XXX taken from gcj */
1296                                                 /* check for ACC_STATIC: IncompatibleClassChangeError */
1297
1298                                                 /* check for !ACC_PUBLIC: IllegalAccessError */
1299
1300                                                 /* check for ACC_ABSTRACT: AbstracMethodError,
1301                                                    not sure about that one */
1302
1303                                                 v->interfacetable[-i][j] = v->table[m->vftblindex];
1304                                                 goto foundmethod;
1305                                         }
1306                                 }
1307                         }
1308
1309                         /* If no method was found, insert the AbstractMethodError
1310                            stub. */
1311
1312 #if defined(ENABLE_JIT)
1313 # if defined(ENABLE_INTRP)
1314                         if (opt_intrp)
1315                                 v->interfacetable[-i][j] =
1316                                         (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
1317                         else
1318 # endif
1319                                 v->interfacetable[-i][j] =
1320                                         (methodptr) (ptrint) &asm_abstractmethoderror;
1321 #else
1322                         v->interfacetable[-i][j] =
1323                                 (methodptr) (ptrint) &intrp_asm_abstractmethoderror;
1324 #endif
1325
1326                 foundmethod:
1327                         ;
1328                 }
1329         }
1330
1331         /* add superinterfaces of this interface */
1332
1333         for (j = 0; j < ic->interfacescount; j++)
1334                 if (!linker_addinterface(c, ic->interfaces[j]))
1335                         return false;
1336
1337         /* everything ok */
1338
1339         return true;
1340 }
1341
1342
1343 /* class_highestinterface ******************************************************
1344
1345    Used by the function link_class to determine the amount of memory
1346    needed for the interface table.
1347
1348 *******************************************************************************/
1349
1350 static s4 class_highestinterface(classinfo *c)
1351 {
1352         s4 h;
1353         s4 h2;
1354         s4 i;
1355
1356     /* check for ACC_INTERFACE bit already done in link_class_intern */
1357
1358     h = c->index;
1359
1360         for (i = 0; i < c->interfacescount; i++) {
1361                 h2 = class_highestinterface(c->interfaces[i]);
1362
1363                 if (h2 > h)
1364                         h = h2;
1365         }
1366
1367         return h;
1368 }
1369
1370
1371 /*
1372  * These are local overrides for various environment variables in Emacs.
1373  * Please do not remove this and leave it at the end of the file, where
1374  * Emacs will automagically detect them.
1375  * ---------------------------------------------------------------------
1376  * Local variables:
1377  * mode: c
1378  * indent-tabs-mode: t
1379  * c-basic-offset: 4
1380  * tab-width: 4
1381  * End:
1382  * vim:noexpandtab:sw=4:ts=4:
1383  */