src/vm/linker.cpp

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