libjava/link.cc

   1 // link.cc - Code for linking and resolving classes and pool entries.
   2
   3 /* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   4    Free Software Foundation
   5
   6    This file is part of libgcj.
   7
   8 This software is copyrighted work licensed under the terms of the
   9 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
  10 details.  */
  11
  12 /* Author: Kresten Krab Thorup <krab@gnu.org>  */
  13
  14 #include <config.h>
  15 #include <platform.h>
  16
  17 #include <stdio.h>
  18
  19 #ifdef USE_LIBFFI
  20 #include <ffi.h>
  21 #endif
  22
  23 #include <java-interp.h>
  24
  25 // Set GC_DEBUG before including gc.h!
  26 #ifdef LIBGCJ_GC_DEBUG
  27 # define GC_DEBUG
  28 #endif
  29 #include <gc.h>
  30
  31 #include <jvm.h>
  32 #include <gcj/cni.h>
  33 #include <string.h>
  34 #include <limits.h>
  35 #include <java-cpool.h>
  36 #include <execution.h>
  37 #ifdef INTERPRETER
  38 #include <jvmti.h>
  39 #include "jvmti-int.h"
  40 #endif
  41 #include <java/lang/Class.h>
  42 #include <java/lang/String.h>
  43 #include <java/lang/StringBuffer.h>
  44 #include <java/lang/Thread.h>
  45 #include <java/lang/InternalError.h>
  46 #include <java/lang/VirtualMachineError.h>
  47 #include <java/lang/VerifyError.h>
  48 #include <java/lang/NoSuchFieldError.h>
  49 #include <java/lang/NoSuchMethodError.h>
  50 #include <java/lang/ClassFormatError.h>
  51 #include <java/lang/IllegalAccessError.h>
  52 #include <java/lang/InternalError.h>
  53 #include <java/lang/AbstractMethodError.h>
  54 #include <java/lang/NoClassDefFoundError.h>
  55 #include <java/lang/IncompatibleClassChangeError.h>
  56 #include <java/lang/VerifyError.h>
  57 #include <java/lang/VMClassLoader.h>
  58 #include <java/lang/reflect/Modifier.h>
  59 #include <java/security/CodeSource.h>
  60
  61 using namespace gcj;
  62
  63 template<typename T>
  64 struct aligner
  65 {
  66   char c;
  67   T field;
  68 };
  69
  70 #define ALIGNOF(TYPE) (offsetof (aligner<TYPE>, field))
  71
  72 // This returns the alignment of a type as it would appear in a
  73 // structure.  This can be different from the alignment of the type
  74 // itself.  For instance on x86 double is 8-aligned but struct{double}
  75 // is 4-aligned.
  76 int
  77 _Jv_Linker::get_alignment_from_class (jclass klass)
  78 {
  79   if (klass == JvPrimClass (byte))
  80     return ALIGNOF (jbyte);
  81   else if (klass == JvPrimClass (short))
  82     return ALIGNOF (jshort);
  83   else if (klass == JvPrimClass (int))
  84     return ALIGNOF (jint);
  85   else if (klass == JvPrimClass (long))
  86     return ALIGNOF (jlong);
  87   else if (klass == JvPrimClass (boolean))
  88     return ALIGNOF (jboolean);
  89   else if (klass == JvPrimClass (char))
  90     return ALIGNOF (jchar);
  91   else if (klass == JvPrimClass (float))
  92     return ALIGNOF (jfloat);
  93   else if (klass == JvPrimClass (double))
  94     return ALIGNOF (jdouble);
  95   else
  96     return ALIGNOF (jobject);
  97 }
  98
  99 void
 100 _Jv_Linker::resolve_field (_Jv_Field *field, java::lang::ClassLoader *loader)
 101 {
 102   if (! field->isResolved ())
 103     {
 104       _Jv_Utf8Const *sig = (_Jv_Utf8Const *) field->type;
 105       jclass type = _Jv_FindClassFromSignature (sig->chars(), loader);
 106       if (type == NULL)
 107         throw new java::lang::NoClassDefFoundError(field->name->toString());
 108       field->type = type;
 109       field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
 110     }
 111 }
 112
 113 // A helper for find_field that knows how to recursively search
 114 // superclasses and interfaces.
 115 _Jv_Field *
 116 _Jv_Linker::find_field_helper (jclass search, _Jv_Utf8Const *name,
 117                                _Jv_Utf8Const *type_name, jclass type,
 118                                jclass *declarer)
 119 {
 120   while (search)
 121     {
 122       // From 5.4.3.2.  First search class itself.
 123       for (int i = 0; i < search->field_count; ++i)
 124         {
 125           _Jv_Field *field = &search->fields[i];
 126           if (! _Jv_equalUtf8Consts (field->name, name))
 127             continue;
 128
 129           // Checks for the odd situation where we were able to retrieve the
 130           // field's class from signature but the resolution of the field itself
 131           // failed which means a different class was resolved.
 132           if (type != NULL)
 133             {
 134               try
 135                 {
 136                   resolve_field (field, search->loader);
 137                 }
 138               catch (java::lang::Throwable *exc)
 139                 {
 140                   java::lang::LinkageError *le = new java::lang::LinkageError
 141                     (JvNewStringLatin1
 142                       ("field type mismatch with different loaders"));
 143
 144                   le->initCause(exc);
 145
 146                   throw le;
 147                 }
 148             }
 149
 150           // Note that we compare type names and not types.  This is
 151           // bizarre, but we do it because we want to find a field
 152           // (and terminate the search) if it has the correct
 153           // descriptor -- but then later reject it if the class
 154           // loader check results in different classes.  We can't just
 155           // pass in the descriptor and check that way, because when
 156           // the field is already resolved there is no easy way to
 157           // find its descriptor again.
 158           if ((field->isResolved ()
 159                ? _Jv_equalUtf8Classnames (type_name, field->type->name)
 160                : _Jv_equalUtf8Classnames (type_name,
 161                                           (_Jv_Utf8Const *) field->type)))
 162             {
 163               *declarer = search;
 164               return field;
 165             }
 166         }
 167
 168       // Next search direct interfaces.
 169       for (int i = 0; i < search->interface_count; ++i)
 170         {
 171           _Jv_Field *result = find_field_helper (search->interfaces[i], name,
 172                                                  type_name, type, declarer);
 173           if (result)
 174             return result;
 175         }
 176
 177       // Now search superclass.
 178       search = search->superclass;
 179     }
 180
 181   return NULL;
 182 }
 183
 184 bool
 185 _Jv_Linker::has_field_p (jclass search, _Jv_Utf8Const *field_name)
 186 {
 187   for (int i = 0; i < search->field_count; ++i)
 188     {
 189       _Jv_Field *field = &search->fields[i];
 190       if (_Jv_equalUtf8Consts (field->name, field_name))
 191         return true;
 192     }
 193   return false;
 194 }
 195
 196 // Find a field.
 197 // KLASS is the class that is requesting the field.
 198 // OWNER is the class in which the field should be found.
 199 // FIELD_TYPE_NAME is the type descriptor for the field.
 200 // Fill FOUND_CLASS with the address of the class in which the field
 201 // is actually declared.
 202 // This function does the class loader type checks, and
 203 // also access checks.  Returns the field, or throws an
 204 // exception on error.
 205 _Jv_Field *
 206 _Jv_Linker::find_field (jclass klass, jclass owner,
 207                         jclass *found_class,
 208                         _Jv_Utf8Const *field_name,
 209                         _Jv_Utf8Const *field_type_name)
 210 {
 211   // FIXME: this allocates a _Jv_Utf8Const each time.  We should make
 212   // it cheaper.
 213   // Note: This call will resolve the primitive type names ("Z", "B", ...) to
 214   // their Java counterparts ("boolean", "byte", ...) if accessed via
 215   // field_type->name later.  Using these variants of the type name is in turn
 216   // important for the find_field_helper function.  However if the class
 217   // resolution failed then we can only use the already given type name.
 218   jclass field_type
 219     = _Jv_FindClassFromSignatureNoException (field_type_name->chars(),
 220                                              klass->loader);
 221
 222   _Jv_Field *the_field
 223     = find_field_helper (owner, field_name,
 224                          (field_type
 225                            ? field_type->name :
 226                              field_type_name ),
 227                            field_type, found_class);
 228
 229   if (the_field == 0)
 230     {
 231       java::lang::StringBuffer *sb = new java::lang::StringBuffer();
 232       sb->append(JvNewStringLatin1("field "));
 233       sb->append(owner->getName());
 234       sb->append(JvNewStringLatin1("."));
 235       sb->append(_Jv_NewStringUTF(field_name->chars()));
 236       sb->append(JvNewStringLatin1(" was not found."));
 237       throw new java::lang::NoSuchFieldError (sb->toString());
 238     }
 239
 240   // Accept it when the field's class could not be resolved.
 241   if (field_type == NULL)
 242     // Silently ignore that we were not able to retrieve the type to make it
 243     // possible to run code which does not access this field.
 244     return the_field;
 245
 246   if (_Jv_CheckAccess (klass, *found_class, the_field->flags))
 247     {
 248       // Note that the field returned by find_field_helper is always
 249       // resolved.  However, we still use the constraint mechanism
 250       // because this may affect other lookups.
 251       _Jv_CheckOrCreateLoadingConstraint (field_type, (*found_class)->loader);
 252     }
 253   else
 254     {
 255       java::lang::StringBuffer *sb
 256         = new java::lang::StringBuffer ();
 257       sb->append(klass->getName());
 258       sb->append(JvNewStringLatin1(": "));
 259       sb->append((*found_class)->getName());
 260       sb->append(JvNewStringLatin1("."));
 261       sb->append(_Jv_NewStringUtf8Const (field_name));
 262       throw new java::lang::IllegalAccessError(sb->toString());
 263     }
 264
 265   return the_field;
 266 }
 267
 268 // Check loading constraints for method.
 269 void
 270 _Jv_Linker::check_loading_constraints (_Jv_Method *method, jclass self_class,
 271                                        jclass other_class)
 272 {
 273   JArray<jclass> *klass_args;
 274   jclass klass_return;
 275
 276   _Jv_GetTypesFromSignature (method, self_class, &klass_args, &klass_return);
 277   jclass *klass_arg = elements (klass_args);
 278   java::lang::ClassLoader *found_loader = other_class->loader;
 279
 280   _Jv_CheckOrCreateLoadingConstraint (klass_return, found_loader);
 281   for (int i = 0; i < klass_args->length; i++)
 282     _Jv_CheckOrCreateLoadingConstraint (*(klass_arg++), found_loader);
 283 }
 284
 285 _Jv_Method *
 286 _Jv_Linker::resolve_method_entry (jclass klass, jclass &found_class,
 287                                   int class_index, int name_and_type_index,
 288                                   bool init, bool is_iface)
 289 {
 290   _Jv_Constants *pool = &klass->constants;
 291   jclass owner = resolve_pool_entry (klass, class_index).clazz;
 292
 293   if (init && owner != klass)
 294     _Jv_InitClass (owner);
 295
 296   _Jv_ushort name_index, type_index;
 297   _Jv_loadIndexes (&pool->data[name_and_type_index],
 298                    name_index,
 299                    type_index);
 300
 301   _Jv_Utf8Const *method_name = pool->data[name_index].utf8;
 302   _Jv_Utf8Const *method_signature = pool->data[type_index].utf8;
 303
 304   _Jv_Method *the_method = 0;
 305   found_class = 0;
 306
 307   // We're going to cache a pointer to the _Jv_Method object
 308   // when we find it.  So, to ensure this doesn't get moved from
 309   // beneath us, we first put all the needed Miranda methods
 310   // into the target class.
 311   wait_for_state (klass, JV_STATE_LOADED);
 312
 313   // First search the class itself.
 314   the_method = search_method_in_class (owner, klass,
 315                                        method_name, method_signature);
 316
 317   if (the_method != 0)
 318     {
 319       found_class = owner;
 320       goto end_of_method_search;
 321     }
 322
 323   // If we are resolving an interface method, search the
 324   // interface's superinterfaces (A superinterface is not an
 325   // interface's superclass - a superinterface is implemented by
 326   // the interface).
 327   if (is_iface)
 328     {
 329       _Jv_ifaces ifaces;
 330       ifaces.count = 0;
 331       ifaces.len = 4;
 332       ifaces.list = (jclass *) _Jv_Malloc (ifaces.len
 333                                            * sizeof (jclass *));
 334
 335       get_interfaces (owner, &ifaces);
 336
 337       for (int i = 0; i < ifaces.count; i++)
 338         {
 339           jclass cls = ifaces.list[i];
 340           the_method = search_method_in_class (cls, klass, method_name,
 341                                                method_signature);
 342           if (the_method != 0)
 343             {
 344               found_class = cls;
 345               break;
 346             }
 347         }
 348
 349       _Jv_Free (ifaces.list);
 350
 351       if (the_method != 0)
 352         goto end_of_method_search;
 353     }
 354
 355   // Finally, search superclasses.
 356   the_method = (search_method_in_superclasses
 357                 (owner->getSuperclass (), klass, method_name,
 358                  method_signature, &found_class));
 359
 360
 361  end_of_method_search:
 362   if (the_method == 0)
 363     {
 364       java::lang::StringBuffer *sb = new java::lang::StringBuffer();
 365       sb->append(JvNewStringLatin1("method "));
 366       sb->append(owner->getName());
 367       sb->append(JvNewStringLatin1("."));
 368       sb->append(_Jv_NewStringUTF(method_name->chars()));
 369       sb->append(JvNewStringLatin1(" with signature "));
 370       sb->append(_Jv_NewStringUTF(method_signature->chars()));
 371       sb->append(JvNewStringLatin1(" was not found."));
 372       throw new java::lang::NoSuchMethodError (sb->toString());
 373     }
 374
 375   // if (found_class->loader != klass->loader), then we must actually
 376   // check that the types of arguments correspond.  JVMS 5.4.3.3.
 377   if (found_class->loader != klass->loader)
 378     check_loading_constraints (the_method, klass, found_class);
 379
 380   return the_method;
 381 }
 382
 383 _Jv_Mutex_t _Jv_Linker::resolve_mutex;
 384
 385 void
 386 _Jv_Linker::init (void)
 387 {
 388   _Jv_MutexInit (&_Jv_Linker::resolve_mutex);
 389 }
 390
 391 // Locking in resolve_pool_entry is somewhat subtle.  Constant
 392 // resolution is idempotent, so it doesn't matter if two threads
 393 // resolve the same entry.  However, it is important that we always
 394 // write the resolved flag and the data together, atomically.  It is
 395 // also important that we read them atomically.
 396 _Jv_word
 397 _Jv_Linker::resolve_pool_entry (jclass klass, int index, bool lazy)
 398 {
 399   using namespace java::lang::reflect;
 400
 401   if (GC_base (klass) && klass->constants.data
 402       && ! GC_base (klass->constants.data))
 403     // If a class is heap-allocated but the constant pool is not this
 404     // is a "new ABI" class, i.e. one where the initial constant pool
 405     // is in the read-only data section of an object file.  Copy the
 406     // initial constant pool from there to a new heap-allocated pool.
 407     {
 408       jsize count = klass->constants.size;
 409       if (count)
 410         {
 411           _Jv_word* constants
 412             = (_Jv_word*) _Jv_AllocRawObj (count * sizeof (_Jv_word));
 413           memcpy ((void*)constants,
 414                   (void*)klass->constants.data,
 415                   count * sizeof (_Jv_word));
 416           klass->constants.data = constants;
 417         }
 418     }
 419
 420   _Jv_Constants *pool = &klass->constants;
 421
 422   jbyte tags;
 423   _Jv_word data;
 424   tags = read_cpool_entry (&data, pool, index);
 425
 426   if ((tags & JV_CONSTANT_ResolvedFlag) != 0)
 427     return data;
 428
 429   switch (tags & ~JV_CONSTANT_LazyFlag)
 430     {
 431     case JV_CONSTANT_Class:
 432       {
 433         _Jv_Utf8Const *name = data.utf8;
 434
 435         jclass found;
 436         if (name->first() == '[')
 437           found = _Jv_FindClassFromSignatureNoException (name->chars(),
 438                                                          klass->loader);
 439         else
 440           found = _Jv_FindClassNoException (name, klass->loader);
 441
 442         // If the class could not be loaded a phantom class is created. Any
 443         // function that deals with such a class but cannot do something useful
 444         // with it should just throw a NoClassDefFoundError with the class'
 445         // name.
 446         if (! found)
 447           {
 448             if (lazy)
 449               {
 450                 found = _Jv_NewClass(name, NULL, NULL);
 451                 found->state = JV_STATE_PHANTOM;
 452                 tags |= JV_CONSTANT_ResolvedFlag;
 453                 data.clazz = found;
 454                 break;
 455               }
 456             else
 457               throw new java::lang::NoClassDefFoundError (name->toString());
 458           }
 459
 460         // Check accessibility, but first strip array types as
 461         // _Jv_ClassNameSamePackage can't handle arrays.
 462         jclass check;
 463         for (check = found;
 464              check && check->isArray();
 465              check = check->getComponentType())
 466           ;
 467         if ((found->accflags & Modifier::PUBLIC) == Modifier::PUBLIC
 468             || (_Jv_ClassNameSamePackage (check->name,
 469                                           klass->name)))
 470           {
 471             data.clazz = found;
 472             tags |= JV_CONSTANT_ResolvedFlag;
 473           }
 474         else
 475           {
 476             java::lang::StringBuffer *sb = new java::lang::StringBuffer ();
 477             sb->append(klass->getName());
 478             sb->append(JvNewStringLatin1(" can't access class "));
 479             sb->append(found->getName());
 480             throw new java::lang::IllegalAccessError(sb->toString());
 481           }
 482       }
 483       break;
 484
 485     case JV_CONSTANT_String:
 486       {
 487         jstring str;
 488         str = _Jv_NewStringUtf8Const (data.utf8);
 489         data.o = str;
 490         tags |= JV_CONSTANT_ResolvedFlag;
 491       }
 492       break;
 493
 494     case JV_CONSTANT_Fieldref:
 495       {
 496         _Jv_ushort class_index, name_and_type_index;
 497         _Jv_loadIndexes (&data,
 498                          class_index,
 499                          name_and_type_index);
 500         jclass owner = (resolve_pool_entry (klass, class_index, true)).clazz;
 501
 502         // If a phantom class was resolved our field reference is
 503         // unusable because of the missing class.
 504         if (owner->state == JV_STATE_PHANTOM)
 505           throw new java::lang::NoClassDefFoundError(owner->getName());
 506
 507         // We don't initialize 'owner', but we do make sure that its
 508         // fields exist.
 509         wait_for_state (owner, JV_STATE_PREPARED);
 510
 511         _Jv_ushort name_index, type_index;
 512         _Jv_loadIndexes (&pool->data[name_and_type_index],
 513                          name_index,
 514                          type_index);
 515
 516         _Jv_Utf8Const *field_name = pool->data[name_index].utf8;
 517         _Jv_Utf8Const *field_type_name = pool->data[type_index].utf8;
 518
 519         jclass found_class = 0;
 520         _Jv_Field *the_field = find_field (klass, owner,
 521                                            &found_class,
 522                                            field_name,
 523                                            field_type_name);
 524         // Initialize the field's declaring class, not its qualifying
 525         // class.
 526         _Jv_InitClass (found_class);
 527         data.field = the_field;
 528         tags |= JV_CONSTANT_ResolvedFlag;
 529       }
 530       break;
 531
 532     case JV_CONSTANT_Methodref:
 533     case JV_CONSTANT_InterfaceMethodref:
 534       {
 535         _Jv_ushort class_index, name_and_type_index;
 536         _Jv_loadIndexes (&data,
 537                          class_index,
 538                          name_and_type_index);
 539
 540         _Jv_Method *the_method;
 541         jclass found_class;
 542         the_method = resolve_method_entry (klass, found_class,
 543                                            class_index, name_and_type_index,
 544                                            true,
 545                                            tags == JV_CONSTANT_InterfaceMethodref);
 546
 547         data.rmethod
 548           = klass->engine->resolve_method(the_method,
 549                                           found_class,
 550                                           ((the_method->accflags
 551                                             & Modifier::STATIC) != 0));
 552         tags |= JV_CONSTANT_ResolvedFlag;
 553       }
 554       break;
 555     }
 556
 557   write_cpool_entry (data, tags, pool, index);
 558
 559   return data;
 560 }
 561
 562 // This function is used to lazily locate superclasses and
 563 // superinterfaces.  This must be called with the class lock held.
 564 void
 565 _Jv_Linker::resolve_class_ref (jclass klass, jclass *classref)
 566 {
 567   jclass ret = *classref;
 568
 569   // If superclass looks like a constant pool entry, resolve it now.
 570   if (ret && (uaddr) ret < (uaddr) klass->constants.size)
 571     {
 572       if (klass->state < JV_STATE_LINKED)
 573         {
 574           _Jv_Utf8Const *name = klass->constants.data[(uaddr) *classref].utf8;
 575           ret = _Jv_FindClass (name, klass->loader);
 576           if (! ret)
 577             {
 578               throw new java::lang::NoClassDefFoundError (name->toString());
 579             }
 580         }
 581       else
 582         ret = klass->constants.data[(uaddr) classref].clazz;
 583       *classref = ret;
 584     }
 585 }
 586
 587 // Find a method declared in the cls that is referenced from klass and
 588 // perform access checks if CHECK_PERMS is true.
 589 _Jv_Method *
 590 _Jv_Linker::search_method_in_class (jclass cls, jclass klass,
 591                                     _Jv_Utf8Const *method_name,
 592                                     _Jv_Utf8Const *method_signature,
 593                                     bool check_perms)
 594 {
 595   using namespace java::lang::reflect;
 596
 597   for (int i = 0;  i < cls->method_count;  i++)
 598     {
 599       _Jv_Method *method = &cls->methods[i];
 600       if (   (!_Jv_equalUtf8Consts (method->name,
 601                                     method_name))
 602           || (!_Jv_equalUtf8Consts (method->signature,
 603                                     method_signature)))
 604         continue;
 605
 606       if (!check_perms || _Jv_CheckAccess (klass, cls, method->accflags))
 607         return method;
 608       else
 609         {
 610           java::lang::StringBuffer *sb = new java::lang::StringBuffer();
 611           sb->append(klass->getName());
 612           sb->append(JvNewStringLatin1(": "));
 613           sb->append(cls->getName());
 614           sb->append(JvNewStringLatin1("."));
 615           sb->append(_Jv_NewStringUTF(method_name->chars()));
 616           sb->append(_Jv_NewStringUTF(method_signature->chars()));
 617           throw new java::lang::IllegalAccessError (sb->toString());
 618         }
 619     }
 620   return 0;
 621 }
 622
 623 // Like search_method_in_class, but work our way up the superclass
 624 // chain.
 625 _Jv_Method *
 626 _Jv_Linker::search_method_in_superclasses (jclass cls, jclass klass,
 627                                            _Jv_Utf8Const *method_name,
 628                                            _Jv_Utf8Const *method_signature,
 629                                            jclass *found_class, bool check_perms)
 630 {
 631   _Jv_Method *the_method = NULL;
 632
 633   for ( ; cls != 0; cls = cls->getSuperclass ())
 634     {
 635       the_method = search_method_in_class (cls, klass, method_name,
 636                                            method_signature, check_perms);
 637       if (the_method != 0)
 638         {
 639           if (found_class)
 640             *found_class = cls;
 641           break;
 642         }
 643     }
 644
 645   return the_method;
 646 }
 647
 648 #define INITIAL_IOFFSETS_LEN 4
 649 #define INITIAL_IFACES_LEN 4
 650
 651 static _Jv_IDispatchTable null_idt = {SHRT_MAX, 0, {}};
 652
 653 // Generate tables for constant-time assignment testing and interface
 654 // method lookup. This implements the technique described by Per Bothner
 655 // <per@bothner.com> on the java-discuss mailing list on 1999-09-02:
 656 // http://gcc.gnu.org/ml/java/1999-q3/msg00377.html
 657 void
 658 _Jv_Linker::prepare_constant_time_tables (jclass klass)
 659 {
 660   if (klass->isPrimitive () || klass->isInterface ())
 661     return;
 662
 663   // Short-circuit in case we've been called already.
 664   if ((klass->idt != NULL) || klass->depth != 0)
 665     return;
 666
 667   // Calculate the class depth and ancestor table. The depth of a class
 668   // is how many "extends" it is removed from Object. Thus the depth of
 669   // java.lang.Object is 0, but the depth of java.io.FilterOutputStream
 670   // is 2. Depth is defined for all regular and array classes, but not
 671   // interfaces or primitive types.
 672
 673   jclass klass0 = klass;
 674   jboolean has_interfaces = false;
 675   while (klass0 != &java::lang::Object::class$)
 676     {
 677       if (klass0->interface_count)
 678         has_interfaces = true;
 679       klass0 = klass0->superclass;
 680       klass->depth++;
 681     }
 682
 683   // We do class member testing in constant time by using a small table
 684   // of all the ancestor classes within each class. The first element is
 685   // a pointer to the current class, and the rest are pointers to the
 686   // classes ancestors, ordered from the current class down by decreasing
 687   // depth. We do not include java.lang.Object in the table of ancestors,
 688   // since it is redundant.  Note that the classes pointed to by
 689   // 'ancestors' will always be reachable by other paths.
 690
 691   klass->ancestors = (jclass *) _Jv_AllocBytes (klass->depth
 692                                                 * sizeof (jclass));
 693   klass0 = klass;
 694   for (int index = 0; index < klass->depth; index++)
 695     {
 696       klass->ancestors[index] = klass0;
 697       klass0 = klass0->superclass;
 698     }
 699
 700   if ((klass->accflags & java::lang::reflect::Modifier::ABSTRACT) != 0)
 701     return;
 702
 703   // Optimization: If class implements no interfaces, use a common
 704   // predefined interface table.
 705   if (!has_interfaces)
 706     {
 707       klass->idt = &null_idt;
 708       return;
 709     }
 710
 711   _Jv_ifaces ifaces;
 712   ifaces.count = 0;
 713   ifaces.len = INITIAL_IFACES_LEN;
 714   ifaces.list = (jclass *) _Jv_Malloc (ifaces.len * sizeof (jclass *));
 715
 716   int itable_size = get_interfaces (klass, &ifaces);
 717
 718   if (ifaces.count > 0)
 719     {
 720       // The classes pointed to by the itable will always be reachable
 721       // via other paths.
 722       int idt_bytes = sizeof (_Jv_IDispatchTable) + (itable_size
 723                                                      * sizeof (void *));
 724       klass->idt = (_Jv_IDispatchTable *) _Jv_AllocBytes (idt_bytes);
 725       klass->idt->itable_length = itable_size;
 726
 727       jshort *itable_offsets =
 728         (jshort *) _Jv_Malloc (ifaces.count * sizeof (jshort));
 729
 730       generate_itable (klass, &ifaces, itable_offsets);
 731
 732       jshort cls_iindex = find_iindex (ifaces.list, itable_offsets,
 733                                        ifaces.count);
 734
 735       for (int i = 0; i < ifaces.count; i++)
 736         {
 737           ifaces.list[i]->ioffsets[cls_iindex] = itable_offsets[i];
 738         }
 739
 740       klass->idt->iindex = cls_iindex;
 741
 742       _Jv_Free (ifaces.list);
 743       _Jv_Free (itable_offsets);
 744     }
 745   else
 746     {
 747       klass->idt->iindex = SHRT_MAX;
 748     }
 749 }
 750
 751 // Return index of item in list, or -1 if item is not present.
 752 inline jshort
 753 _Jv_Linker::indexof (void *item, void **list, jshort list_len)
 754 {
 755   for (int i=0; i < list_len; i++)
 756     {
 757       if (list[i] == item)
 758         return i;
 759     }
 760   return -1;
 761 }
 762
 763 // Find all unique interfaces directly or indirectly implemented by klass.
 764 // Returns the size of the interface dispatch table (itable) for klass, which
 765 // is the number of unique interfaces plus the total number of methods that
 766 // those interfaces declare. May extend ifaces if required.
 767 jshort
 768 _Jv_Linker::get_interfaces (jclass klass, _Jv_ifaces *ifaces)
 769 {
 770   jshort result = 0;
 771
 772   for (int i = 0; i < klass->interface_count; i++)
 773     {
 774       jclass iface = klass->interfaces[i];
 775
 776       /* Make sure interface is linked.  */
 777       wait_for_state(iface, JV_STATE_LINKED);
 778
 779       if (indexof (iface, (void **) ifaces->list, ifaces->count) == -1)
 780         {
 781           if (ifaces->count + 1 >= ifaces->len)
 782             {
 783               /* Resize ifaces list */
 784               ifaces->len = ifaces->len * 2;
 785               ifaces->list
 786                 = (jclass *) _Jv_Realloc (ifaces->list,
 787                                           ifaces->len * sizeof(jclass));
 788             }
 789           ifaces->list[ifaces->count] = iface;
 790           ifaces->count++;
 791
 792           result += get_interfaces (klass->interfaces[i], ifaces);
 793         }
 794     }
 795
 796   if (klass->isInterface())
 797     {
 798       // We want to add 1 plus the number of interface methods here.
 799       // But, we take special care to skip <clinit>.
 800       ++result;
 801       for (int i = 0; i < klass->method_count; ++i)
 802         {
 803           if (klass->methods[i].name->first() != '<')
 804             ++result;
 805         }
 806     }
 807   else if (klass->superclass)
 808     result += get_interfaces (klass->superclass, ifaces);
 809   return result;
 810 }
 811
 812 // Fill out itable in klass, resolving method declarations in each ifaces.
 813 // itable_offsets is filled out with the position of each iface in itable,
 814 // such that itable[itable_offsets[n]] == ifaces.list[n].
 815 void
 816 _Jv_Linker::generate_itable (jclass klass, _Jv_ifaces *ifaces,
 817                                jshort *itable_offsets)
 818 {
 819   void **itable = klass->idt->itable;
 820   jshort itable_pos = 0;
 821
 822   for (int i = 0; i < ifaces->count; i++)
 823     {
 824       jclass iface = ifaces->list[i];
 825       itable_offsets[i] = itable_pos;
 826       itable_pos = append_partial_itable (klass, iface, itable, itable_pos);
 827
 828       /* Create ioffsets table for iface */
 829       if (iface->ioffsets == NULL)
 830         {
 831           // The first element of ioffsets is its length (itself included).
 832           jshort *ioffsets = (jshort *) _Jv_AllocBytes (INITIAL_IOFFSETS_LEN
 833                                                         * sizeof (jshort));
 834           ioffsets[0] = INITIAL_IOFFSETS_LEN;
 835           for (int i = 1; i < INITIAL_IOFFSETS_LEN; i++)
 836             ioffsets[i] = -1;
 837
 838           iface->ioffsets = ioffsets;
 839         }
 840     }
 841 }
 842
 843 // Format method name for use in error messages.
 844 jstring
 845 _Jv_GetMethodString (jclass klass, _Jv_Method *meth,
 846                      jclass derived)
 847 {
 848   using namespace java::lang;
 849   StringBuffer *buf = new StringBuffer (klass->name->toString());
 850   buf->append (jchar ('.'));
 851   buf->append (meth->name->toString());
 852   buf->append ((jchar) ' ');
 853   buf->append (meth->signature->toString());
 854   if (derived)
 855     {
 856       buf->append(JvNewStringLatin1(" in "));
 857       buf->append(derived->name->toString());
 858     }
 859   return buf->toString();
 860 }
 861
 862 void
 863 _Jv_ThrowNoSuchMethodError ()
 864 {
 865   throw new java::lang::NoSuchMethodError;
 866 }
 867
 868 #if defined USE_LIBFFI && FFI_CLOSURES && defined(INTERPRETER)
 869 // A function whose invocation is prepared using libffi. It gets called
 870 // whenever a static method of a missing class is invoked. The data argument
 871 // holds a reference to a String denoting the missing class.
 872 // The prepared function call is stored in a class' atable.
 873 void
 874 _Jv_ThrowNoClassDefFoundErrorTrampoline(ffi_cif *,
 875                                         void *,
 876                                         void **,
 877                                         void *data)
 878 {
 879   throw new java::lang::NoClassDefFoundError(
 880     _Jv_NewStringUtf8Const((_Jv_Utf8Const *) data));
 881 }
 882 #else
 883 // A variant of the NoClassDefFoundError throwing method that can
 884 // be used without libffi.
 885 void
 886 _Jv_ThrowNoClassDefFoundError()
 887 {
 888   throw new java::lang::NoClassDefFoundError();
 889 }
 890 #endif
 891
 892 // Throw a NoSuchFieldError.  Called by compiler-generated code when
 893 // an otable entry is zero.  OTABLE_INDEX is the index in the caller's
 894 // otable that refers to the missing field.  This index may be used to
 895 // print diagnostic information about the field.
 896 void
 897 _Jv_ThrowNoSuchFieldError (int /* otable_index */)
 898 {
 899   throw new java::lang::NoSuchFieldError;
 900 }
 901
 902 // This is put in empty vtable slots.
 903 void
 904 _Jv_ThrowAbstractMethodError ()
 905 {
 906   throw new java::lang::AbstractMethodError();
 907 }
 908
 909 // Each superinterface of a class (i.e. each interface that the class
 910 // directly or indirectly implements) has a corresponding "Partial
 911 // Interface Dispatch Table" whose size is (number of methods + 1) words.
 912 // The first word is a pointer to the interface (i.e. the java.lang.Class
 913 // instance for that interface).  The remaining words are pointers to the
 914 // actual methods that implement the methods declared in the interface,
 915 // in order of declaration.
 916 //
 917 // Append partial interface dispatch table for "iface" to "itable", at
 918 // position itable_pos.
 919 // Returns the offset at which the next partial ITable should be appended.
 920 jshort
 921 _Jv_Linker::append_partial_itable (jclass klass, jclass iface,
 922                                    void **itable, jshort pos)
 923 {
 924   using namespace java::lang::reflect;
 925
 926   itable[pos++] = (void *) iface;
 927   _Jv_Method *meth;
 928
 929   for (int j=0; j < iface->method_count; j++)
 930     {
 931       // Skip '<clinit>' here.
 932       if (iface->methods[j].name->first() == '<')
 933         continue;
 934
 935       meth = NULL;
 936       jclass cl;
 937       for (cl = klass; cl; cl = cl->getSuperclass())
 938         {
 939           meth = _Jv_GetMethodLocal (cl, iface->methods[j].name,
 940                                      iface->methods[j].signature);
 941
 942           if (meth)
 943             break;
 944         }
 945
 946       if (meth)
 947         {
 948           if ((meth->accflags & Modifier::STATIC) != 0)
 949             throw new java::lang::IncompatibleClassChangeError
 950               (_Jv_GetMethodString (klass, meth));
 951           if ((meth->accflags & Modifier::PUBLIC) == 0)
 952             throw new java::lang::IllegalAccessError
 953               (_Jv_GetMethodString (klass, meth));
 954
 955           if ((meth->accflags & Modifier::ABSTRACT) != 0)
 956             itable[pos] = (void *) &_Jv_ThrowAbstractMethodError;
 957           else
 958             itable[pos] = meth->ncode;
 959
 960           if (cl->loader != iface->loader)
 961             check_loading_constraints (meth, cl, iface);
 962         }
 963       else
 964         {
 965           // The method doesn't exist in klass. Binary compatibility rules
 966           // permit this, so we delay the error until runtime using a pointer
 967           // to a method which throws an exception.
 968           itable[pos] = (void *) _Jv_ThrowNoSuchMethodError;
 969         }
 970       pos++;
 971     }
 972
 973   return pos;
 974 }
 975
 976 static _Jv_Mutex_t iindex_mutex;
 977 static bool iindex_mutex_initialized = false;
 978
 979 // We need to find the correct offset in the Class Interface Dispatch
 980 // Table for a given interface. Once we have that, invoking an interface
 981 // method just requires combining the Method's index in the interface
 982 // (known at compile time) to get the correct method.  Doing a type test
 983 // (cast or instanceof) is the same problem: Once we have a possible Partial
 984 // Interface Dispatch Table, we just compare the first element to see if it
 985 // matches the desired interface. So how can we find the correct offset?
 986 // Our solution is to keep a vector of candiate offsets in each interface
 987 // (ioffsets), and in each class we have an index (idt->iindex) used to
 988 // select the correct offset from ioffsets.
 989 //
 990 // Calculate and return iindex for a new class.
 991 // ifaces is a vector of num interfaces that the class implements.
 992 // offsets[j] is the offset in the interface dispatch table for the
 993 // interface corresponding to ifaces[j].
 994 // May extend the interface ioffsets if required.
 995 jshort
 996 _Jv_Linker::find_iindex (jclass *ifaces, jshort *offsets, jshort num)
 997 {
 998   int i;
 999   int j;
1000
1001   // Acquire a global lock to prevent itable corruption in case of multiple
1002   // classes that implement an intersecting set of interfaces being linked
1003   // simultaneously. We can assume that the mutex will be initialized
1004   // single-threaded.
1005   if (! iindex_mutex_initialized)
1006     {
1007       _Jv_MutexInit (&iindex_mutex);
1008       iindex_mutex_initialized = true;
1009     }
1010
1011   _Jv_MutexLock (&iindex_mutex);
1012
1013   for (i=1;; i++)  /* each potential position in ioffsets */
1014     {
1015       for (j=0;; j++)  /* each iface */
1016         {
1017           if (j >= num)
1018             goto found;
1019           if (i >= ifaces[j]->ioffsets[0])
1020             continue;
1021           int ioffset = ifaces[j]->ioffsets[i];
1022           /* We can potentially share this position with another class. */
1023           if (ioffset >= 0 && ioffset != offsets[j])
1024             break; /* Nope. Try next i. */
1025         }
1026     }
1027   found:
1028   for (j = 0; j < num; j++)
1029     {
1030       int len = ifaces[j]->ioffsets[0];
1031       if (i >= len)
1032         {
1033           // Resize ioffsets.
1034           int newlen = 2 * len;
1035           if (i >= newlen)
1036             newlen = i + 3;
1037
1038           jshort *old_ioffsets = ifaces[j]->ioffsets;
1039           jshort *new_ioffsets = (jshort *) _Jv_AllocBytes (newlen
1040                                                             * sizeof(jshort));
1041           memcpy (&new_ioffsets[1], &old_ioffsets[1],
1042                   (len - 1) * sizeof (jshort));
1043           new_ioffsets[0] = newlen;
1044
1045           while (len < newlen)
1046             new_ioffsets[len++] = -1;
1047
1048           ifaces[j]->ioffsets = new_ioffsets;
1049         }
1050       ifaces[j]->ioffsets[i] = offsets[j];
1051     }
1052
1053   _Jv_MutexUnlock (&iindex_mutex);
1054
1055   return i;
1056 }
1057
1058 #if defined USE_LIBFFI && FFI_CLOSURES && defined(INTERPRETER)
1059 // We use a structure of this type to store the closure that
1060 // represents a missing method.
1061 struct method_closure
1062 {
1063   // This field must come first, since the address of this field will
1064   // be the same as the address of the overall structure.  This is due
1065   // to disabling interior pointers in the GC.
1066   ffi_closure closure;
1067   _Jv_ClosureList list;
1068   ffi_cif cif;
1069   ffi_type *arg_types[1];
1070 };
1071
1072 void *
1073 _Jv_Linker::create_error_method (_Jv_Utf8Const *class_name, jclass klass)
1074 {
1075   void *code;
1076   method_closure *closure
1077     = (method_closure *)ffi_closure_alloc (sizeof (method_closure), &code);
1078
1079   closure->arg_types[0] = &ffi_type_void;
1080
1081   // Initializes the cif and the closure.  If that worked the closure
1082   // is returned and can be used as a function pointer in a class'
1083   // atable.
1084   if (   ffi_prep_cif (&closure->cif,
1085                        FFI_DEFAULT_ABI,
1086                        1,
1087                        &ffi_type_void,
1088                        closure->arg_types) == FFI_OK
1089       && ffi_prep_closure_loc (&closure->closure,
1090                                &closure->cif,
1091                                _Jv_ThrowNoClassDefFoundErrorTrampoline,
1092                                class_name,
1093                                code) == FFI_OK)
1094     {
1095       closure->list.registerClosure (klass, closure);
1096       return code;
1097     }
1098   else
1099     {
1100       ffi_closure_free (closure);
1101       java::lang::StringBuffer *buffer = new java::lang::StringBuffer();
1102       buffer->append(JvNewStringLatin1("Error setting up FFI closure"
1103                                        " for static method of"
1104                                        " missing class: "));
1105       buffer->append (_Jv_NewStringUtf8Const(class_name));
1106       throw new java::lang::InternalError(buffer->toString());
1107     }
1108 }
1109 #else
1110 void *
1111 _Jv_Linker::create_error_method (_Jv_Utf8Const *, jclass)
1112 {
1113   // Codepath for platforms which do not support (or want) libffi.
1114   // You have to accept that it is impossible to provide the name
1115   // of the missing class then.
1116   return (void *) _Jv_ThrowNoClassDefFoundError;
1117 }
1118 #endif // USE_LIBFFI && FFI_CLOSURES
1119
1120 // Functions for indirect dispatch (symbolic virtual binding) support.
1121
1122 // There are three tables, atable otable and itable.  atable is an
1123 // array of addresses, and otable is an array of offsets, and these
1124 // are used for static and virtual members respectively.  itable is an
1125 // array of pairs {address, index} where each address is a pointer to
1126 // an interface.
1127
1128 // {a,o,i}table_syms is an array of _Jv_MethodSymbols.  Each such
1129 // symbol is a tuple of {classname, member name, signature}.
1130
1131 // Set this to true to enable debugging of indirect dispatch tables/linking.
1132 static bool debug_link = false;
1133
1134 // link_symbol_table() scans these two arrays and fills in the
1135 // corresponding atable and otable with the addresses of static
1136 // members and the offsets of virtual members.
1137
1138 // The offset (in bytes) for each resolved method or field is placed
1139 // at the corresponding position in the virtual method offset table
1140 // (klass->otable).
1141
1142 // This must be called while holding the class lock.
1143
1144 void
1145 _Jv_Linker::link_symbol_table (jclass klass)
1146 {
1147   int index = 0;
1148   _Jv_MethodSymbol sym;
1149   if (klass->otable == NULL
1150       || klass->otable->state != 0)
1151     goto atable;
1152
1153   klass->otable->state = 1;
1154
1155   if (debug_link)
1156     fprintf (stderr, "Fixing up otable in %s:\n", klass->name->chars());
1157   for (index = 0;
1158        (sym = klass->otable_syms[index]).class_name != NULL;
1159        ++index)
1160     {
1161       jclass target_class = _Jv_FindClass (sym.class_name, klass->loader);
1162       _Jv_Method *meth = NULL;
1163
1164       _Jv_Utf8Const *signature = sym.signature;
1165       uaddr special;
1166       maybe_adjust_signature (signature, special);
1167
1168       if (target_class == NULL)
1169         throw new java::lang::NoClassDefFoundError
1170           (_Jv_NewStringUTF (sym.class_name->chars()));
1171
1172       // We're looking for a field or a method, and we can tell
1173       // which is needed by looking at the signature.
1174       if (signature->first() == '(' && signature->len() >= 2)
1175         {
1176           // Looks like someone is trying to invoke an interface method
1177           if (target_class->isInterface())
1178             {
1179               using namespace java::lang;
1180               StringBuffer *sb = new StringBuffer();
1181               sb->append(JvNewStringLatin1("found interface "));
1182               sb->append(target_class->getName());
1183               sb->append(JvNewStringLatin1(" when searching for a class"));
1184               throw new VerifyError(sb->toString());
1185             }
1186
1187           // If the target class does not have a vtable_method_count yet,
1188           // then we can't tell the offsets for its methods, so we must lay
1189           // it out now.
1190           wait_for_state(target_class, JV_STATE_PREPARED);
1191
1192           try
1193             {
1194               meth = (search_method_in_superclasses
1195                       (target_class, klass, sym.name, signature,
1196                        NULL, special == 0));
1197             }
1198           catch (::java::lang::IllegalAccessError *e)
1199             {
1200             }
1201
1202           // Every class has a throwNoSuchMethodErrorIndex method that
1203           // it inherits from java.lang.Object.  Find its vtable
1204           // offset.
1205           static int throwNoSuchMethodErrorIndex;
1206           if (throwNoSuchMethodErrorIndex == 0)
1207             {
1208               Utf8Const* name
1209                 = _Jv_makeUtf8Const ("throwNoSuchMethodError",
1210                                      strlen ("throwNoSuchMethodError"));
1211               _Jv_Method* meth
1212                 = _Jv_LookupDeclaredMethod (&java::lang::Object::class$,
1213                                             name, gcj::void_signature);
1214               throwNoSuchMethodErrorIndex
1215                 = _Jv_VTable::idx_to_offset (meth->index);
1216             }
1217
1218           // If we don't find a nonstatic method, insert the
1219           // vtable index of Object.throwNoSuchMethodError().
1220           // This defers the missing method error until an attempt
1221           // is made to execute it.
1222           {
1223             int offset;
1224
1225             if (meth != NULL)
1226               offset = _Jv_VTable::idx_to_offset (meth->index);
1227             else
1228               offset = throwNoSuchMethodErrorIndex;
1229
1230             if (offset == -1)
1231               JvFail ("Bad method index");
1232             JvAssert (meth->index < target_class->vtable_method_count);
1233
1234             klass->otable->offsets[index] = offset;
1235           }
1236
1237           if (debug_link)
1238             fprintf (stderr, "  offsets[%d] = %d (class %s@%p : %s(%s))\n",
1239                      (int)index,
1240                      (int)klass->otable->offsets[index],
1241                      (const char*)target_class->name->chars(),
1242                      target_class,
1243                      (const char*)sym.name->chars(),
1244                      (const char*)signature->chars());
1245           continue;
1246         }
1247
1248       // Try fields.
1249       {
1250         wait_for_state(target_class, JV_STATE_PREPARED);
1251         jclass found_class;
1252         _Jv_Field *the_field = NULL;
1253         try
1254           {
1255             the_field = find_field (klass, target_class, &found_class,
1256                                     sym.name, signature);
1257             if ((the_field->flags & java::lang::reflect::Modifier::STATIC))
1258               throw new java::lang::IncompatibleClassChangeError;
1259             else
1260               klass->otable->offsets[index] = the_field->u.boffset;
1261           }
1262         catch (java::lang::NoSuchFieldError *err)
1263           {
1264             klass->otable->offsets[index] = 0;
1265           }
1266       }
1267     }
1268
1269  atable:
1270   if (klass->atable == NULL || klass->atable->state != 0)
1271     goto itable;
1272
1273   klass->atable->state = 1;
1274
1275   for (index = 0;
1276        (sym = klass->atable_syms[index]).class_name != NULL;
1277        ++index)
1278     {
1279       jclass target_class =
1280         _Jv_FindClassNoException (sym.class_name, klass->loader);
1281
1282       _Jv_Method *meth = NULL;
1283
1284       _Jv_Utf8Const *signature = sym.signature;
1285       uaddr special;
1286       maybe_adjust_signature (signature, special);
1287
1288       // ??? Setting this pointer to null will at least get us a
1289       // NullPointerException
1290       klass->atable->addresses[index] = NULL;
1291
1292       bool use_error_method = false;
1293
1294       // If the target class is missing we prepare a function call
1295       // that throws a NoClassDefFoundError and store the address of
1296       // that newly prepared method in the atable. The user can run
1297       // code in classes where the missing class is part of the
1298       // execution environment as long as it is never referenced.
1299       if (target_class == NULL)
1300         use_error_method = true;
1301       // We're looking for a static field or a static method, and we
1302       // can tell which is needed by looking at the signature.
1303       else if (signature->first() == '(' && signature->len() >= 2)
1304         {
1305           // If the target class does not have a vtable_method_count yet,
1306           // then we can't tell the offsets for its methods, so we must lay
1307           // it out now.
1308           wait_for_state (target_class, JV_STATE_PREPARED);
1309
1310           // Interface methods cannot have bodies.
1311           if (target_class->isInterface())
1312             {
1313               using namespace java::lang;
1314               StringBuffer *sb = new StringBuffer();
1315               sb->append(JvNewStringLatin1("class "));
1316               sb->append(target_class->getName());
1317               sb->append(JvNewStringLatin1(" is an interface: "
1318                                            "class expected"));
1319               throw new VerifyError(sb->toString());
1320             }
1321
1322           try
1323             {
1324               meth = (search_method_in_superclasses
1325                       (target_class, klass, sym.name, signature,
1326                        NULL, special == 0));
1327             }
1328           catch (::java::lang::IllegalAccessError *e)
1329             {
1330             }
1331
1332           if (meth != NULL)
1333             {
1334               if (meth->ncode) // Maybe abstract?
1335                 {
1336                   klass->atable->addresses[index] = meth->ncode;
1337                   if (debug_link)
1338                     fprintf (stderr, "  addresses[%d] = %p (class %s@%p : %s(%s))\n",
1339                              index,
1340                              &klass->atable->addresses[index],
1341                              (const char*)target_class->name->chars(),
1342                              klass,
1343                              (const char*)sym.name->chars(),
1344                              (const char*)signature->chars());
1345                 }
1346             }
1347           else
1348             use_error_method = true;
1349
1350           if (use_error_method)
1351             klass->atable->addresses[index]
1352               = create_error_method(sym.class_name, klass);
1353
1354           continue;
1355         }
1356
1357
1358       // Try fields only if the target class exists.
1359       if (target_class != NULL)
1360       {
1361         wait_for_state(target_class, JV_STATE_PREPARED);
1362         jclass found_class;
1363         _Jv_Field *the_field = find_field (klass, target_class, &found_class,
1364                                            sym.name, signature);
1365         if ((the_field->flags & java::lang::reflect::Modifier::STATIC))
1366           klass->atable->addresses[index] = the_field->u.addr;
1367         else
1368           throw new java::lang::IncompatibleClassChangeError;
1369       }
1370     }
1371
1372  itable:
1373   if (klass->itable == NULL
1374       || klass->itable->state != 0)
1375     return;
1376
1377   klass->itable->state = 1;
1378
1379   for (index = 0;
1380        (sym = klass->itable_syms[index]).class_name != NULL;
1381        ++index)
1382     {
1383       jclass target_class = _Jv_FindClass (sym.class_name, klass->loader);
1384
1385       _Jv_Utf8Const *signature = sym.signature;
1386       uaddr special;
1387       maybe_adjust_signature (signature, special);
1388
1389       jclass cls;
1390       int i;
1391
1392       wait_for_state(target_class, JV_STATE_LOADED);
1393       bool found = _Jv_getInterfaceMethod (target_class, cls, i,
1394                                            sym.name, signature);
1395
1396       if (found)
1397         {
1398           klass->itable->addresses[index * 2] = cls;
1399           klass->itable->addresses[index * 2 + 1] = (void *)(unsigned long) i;
1400           if (debug_link)
1401             {
1402               fprintf (stderr, "  interfaces[%d] = %p (interface %s@%p : %s(%s))\n",
1403                        index,
1404                        klass->itable->addresses[index * 2],
1405                        (const char*)cls->name->chars(),
1406                        cls,
1407                        (const char*)sym.name->chars(),
1408                        (const char*)signature->chars());
1409               fprintf (stderr, "            [%d] = offset %d\n",
1410                        index + 1,
1411                        (int)(unsigned long)klass->itable->addresses[index * 2 + 1]);
1412             }
1413
1414         }
1415       else
1416         throw new java::lang::IncompatibleClassChangeError;
1417     }
1418
1419 }
1420
1421 // For each catch_record in the list of caught classes, fill in the
1422 // address field.
1423 void
1424 _Jv_Linker::link_exception_table (jclass self)
1425 {
1426   struct _Jv_CatchClass *catch_record = self->catch_classes;
1427   if (!catch_record || catch_record->classname)
1428     return;
1429   catch_record++;
1430   while (catch_record->classname)
1431     {
1432       try
1433         {
1434           jclass target_class
1435             = _Jv_FindClass (catch_record->classname,
1436                              self->getClassLoaderInternal ());
1437           *catch_record->address = target_class;
1438         }
1439       catch (::java::lang::Throwable *t)
1440         {
1441           // FIXME: We need to do something better here.
1442           *catch_record->address = 0;
1443         }
1444       catch_record++;
1445     }
1446   self->catch_classes->classname = (_Jv_Utf8Const *)-1;
1447 }
1448
1449 // Set itable method indexes for members of interface IFACE.
1450 void
1451 _Jv_Linker::layout_interface_methods (jclass iface)
1452 {
1453   if (! iface->isInterface())
1454     return;
1455
1456   // itable indexes start at 1.
1457   // FIXME: Static initalizers currently get a NULL placeholder entry in the
1458   // itable so they are also assigned an index here.
1459   for (int i = 0; i < iface->method_count; i++)
1460     iface->methods[i].index = i + 1;
1461 }
1462
1463 // Prepare virtual method declarations in KLASS, and any superclasses
1464 // as required, by determining their vtable index, setting
1465 // method->index, and finally setting the class's vtable_method_count.
1466 // Must be called with the lock for KLASS held.
1467 void
1468 _Jv_Linker::layout_vtable_methods (jclass klass)
1469 {
1470   if (klass->vtable != NULL || klass->isInterface()
1471       || klass->vtable_method_count != -1)
1472     return;
1473
1474   jclass superclass = klass->getSuperclass();
1475
1476   if (superclass != NULL && superclass->vtable_method_count == -1)
1477     {
1478       JvSynchronize sync (superclass);
1479       layout_vtable_methods (superclass);
1480     }
1481
1482   int index = (superclass == NULL ? 0 : superclass->vtable_method_count);
1483
1484   for (int i = 0; i < klass->method_count; ++i)
1485     {
1486       _Jv_Method *meth = &klass->methods[i];
1487       _Jv_Method *super_meth = NULL;
1488
1489       if (! _Jv_isVirtualMethod (meth))
1490         continue;
1491
1492       if (superclass != NULL)
1493         {
1494           jclass declarer;
1495           super_meth = _Jv_LookupDeclaredMethod (superclass, meth->name,
1496                                                  meth->signature, &declarer);
1497           // See if this method actually overrides the other method
1498           // we've found.
1499           if (super_meth)
1500             {
1501               if (! _Jv_isVirtualMethod (super_meth)
1502                   || ! _Jv_CheckAccess (klass, declarer,
1503                                         super_meth->accflags))
1504                 super_meth = NULL;
1505               else if ((super_meth->accflags
1506                         & java::lang::reflect::Modifier::FINAL) != 0)
1507                 {
1508                   using namespace java::lang;
1509                   StringBuffer *sb = new StringBuffer();
1510                   sb->append(JvNewStringLatin1("method "));
1511                   sb->append(_Jv_GetMethodString(klass, meth));
1512                   sb->append(JvNewStringLatin1(" overrides final method "));
1513                   sb->append(_Jv_GetMethodString(declarer, super_meth));
1514                   throw new VerifyError(sb->toString());
1515                 }
1516               else if (declarer->loader != klass->loader)
1517                 {
1518                   // JVMS 5.4.2.
1519                   check_loading_constraints (meth, klass, declarer);
1520                 }
1521             }
1522         }
1523
1524       if (super_meth)
1525         meth->index = super_meth->index;
1526       else
1527         meth->index = index++;
1528     }
1529
1530   klass->vtable_method_count = index;
1531 }
1532
1533 // Set entries in VTABLE for virtual methods declared in KLASS.
1534 void
1535 _Jv_Linker::set_vtable_entries (jclass klass, _Jv_VTable *vtable)
1536 {
1537   for (int i = klass->method_count - 1; i >= 0; i--)
1538     {
1539       using namespace java::lang::reflect;
1540
1541       _Jv_Method *meth = &klass->methods[i];
1542       if (meth->index == (_Jv_ushort) -1)
1543         continue;
1544       if ((meth->accflags & Modifier::ABSTRACT))
1545         // FIXME: it might be nice to have a libffi trampoline here,
1546         // so we could pass in the method name and other information.
1547         vtable->set_method(meth->index,
1548                            (void *) &_Jv_ThrowAbstractMethodError);
1549       else
1550         vtable->set_method(meth->index, meth->ncode);
1551     }
1552 }
1553
1554 // Allocate and lay out the virtual method table for KLASS.  This will
1555 // also cause vtables to be generated for any non-abstract
1556 // superclasses, and virtual method layout to occur for any abstract
1557 // superclasses.  Must be called with monitor lock for KLASS held.
1558 void
1559 _Jv_Linker::make_vtable (jclass klass)
1560 {
1561   using namespace java::lang::reflect;
1562
1563   // If the vtable exists, or for interface classes, do nothing.  All
1564   // other classes, including abstract classes, need a vtable.
1565   if (klass->vtable != NULL || klass->isInterface())
1566     return;
1567
1568   // Ensure all the `ncode' entries are set.
1569   klass->engine->create_ncode(klass);
1570
1571   // Class must be laid out before we can create a vtable.
1572   if (klass->vtable_method_count == -1)
1573     layout_vtable_methods (klass);
1574
1575   // Allocate the new vtable.
1576   _Jv_VTable *vtable = _Jv_VTable::new_vtable (klass->vtable_method_count);
1577   klass->vtable = vtable;
1578
1579   // Copy the vtable of the closest superclass.
1580   jclass superclass = klass->superclass;
1581   {
1582     JvSynchronize sync (superclass);
1583     make_vtable (superclass);
1584   }
1585   for (int i = 0; i < superclass->vtable_method_count; ++i)
1586     vtable->set_method (i, superclass->vtable->get_method (i));
1587
1588   // Set the class pointer and GC descriptor.
1589   vtable->clas = klass;
1590   vtable->gc_descr = _Jv_BuildGCDescr (klass);
1591
1592   // For each virtual declared in klass, set new vtable entry or
1593   // override an old one.
1594   set_vtable_entries (klass, vtable);
1595
1596   // Note that we don't check for abstract methods here.  We used to,
1597   // but there is a JVMS clarification that indicates that a check
1598   // here would be too eager.  And, a simple test case confirms this.
1599 }
1600
1601 // Lay out the class, allocating space for static fields and computing
1602 // offsets of instance fields.  The class lock must be held by the
1603 // caller.
1604 void
1605 _Jv_Linker::ensure_fields_laid_out (jclass klass)
1606 {
1607   if (klass->size_in_bytes != -1)
1608     return;
1609
1610   // Compute the alignment for this type by searching through the
1611   // superclasses and finding the maximum required alignment.  We
1612   // could consider caching this in the Class.
1613   int max_align = __alignof__ (java::lang::Object);
1614   jclass super = klass->getSuperclass();
1615   while (super != NULL)
1616     {
1617       // Ensure that our super has its super installed before
1618       // recursing.
1619       wait_for_state(super, JV_STATE_LOADING);
1620       ensure_fields_laid_out(super);
1621       int num = JvNumInstanceFields (super);
1622       _Jv_Field *field = JvGetFirstInstanceField (super);
1623       while (num > 0)
1624         {
1625           int field_align = get_alignment_from_class (field->type);
1626           if (field_align > max_align)
1627             max_align = field_align;
1628           ++field;
1629           --num;
1630         }
1631       super = super->getSuperclass();
1632     }
1633
1634   int instance_size;
1635   // This is the size of the 'static' non-reference fields.
1636   int non_reference_size = 0;
1637   // This is the size of the 'static' reference fields.  We count
1638   // these separately to make it simpler for the GC to scan them.
1639   int reference_size = 0;
1640
1641   // Although java.lang.Object is never interpreted, an interface can
1642   // have a null superclass.  Note that we have to lay out an
1643   // interface because it might have static fields.
1644   if (klass->superclass)
1645     instance_size = klass->superclass->size();
1646   else
1647     instance_size = java::lang::Object::class$.size();
1648
1649   klass->engine->allocate_field_initializers (klass);
1650
1651   for (int i = 0; i < klass->field_count; i++)
1652     {
1653       int field_size;
1654       int field_align;
1655
1656       _Jv_Field *field = &klass->fields[i];
1657
1658       if (! field->isRef ())
1659         {
1660           // It is safe to resolve the field here, since it's a
1661           // primitive class, which does not cause loading to happen.
1662           resolve_field (field, klass->loader);
1663           field_size = field->type->size ();
1664           field_align = get_alignment_from_class (field->type);
1665         }
1666       else
1667         {
1668           field_size = sizeof (jobject);
1669           field_align = __alignof__ (jobject);
1670         }
1671
1672       field->bsize = field_size;
1673
1674       if ((field->flags & java::lang::reflect::Modifier::STATIC))
1675         {
1676           if (field->u.addr == NULL)
1677             {
1678               // This computes an offset into a region we'll allocate
1679               // shortly, and then adds this offset to the start
1680               // address.
1681               if (field->isRef())
1682                 {
1683                   reference_size = ROUND (reference_size, field_align);
1684                   field->u.boffset = reference_size;
1685                   reference_size += field_size;
1686                 }
1687               else
1688                 {
1689                   non_reference_size = ROUND (non_reference_size, field_align);
1690                   field->u.boffset = non_reference_size;
1691                   non_reference_size += field_size;
1692                 }
1693             }
1694         }
1695       else
1696         {
1697           instance_size      = ROUND (instance_size, field_align);
1698           field->u.boffset   = instance_size;
1699           instance_size     += field_size;
1700           if (field_align > max_align)
1701             max_align = field_align;
1702         }
1703     }
1704
1705   if (reference_size != 0 || non_reference_size != 0)
1706     klass->engine->allocate_static_fields (klass, reference_size,
1707                                            non_reference_size);
1708
1709   // Set the instance size for the class.  Note that first we round it
1710   // to the alignment required for this object; this keeps us in sync
1711   // with our current ABI.
1712   instance_size = ROUND (instance_size, max_align);
1713   klass->size_in_bytes = instance_size;
1714 }
1715
1716 // This takes the class to state JV_STATE_LINKED.  The class lock must
1717 // be held when calling this.
1718 void
1719 _Jv_Linker::ensure_class_linked (jclass klass)
1720 {
1721   if (klass->state >= JV_STATE_LINKED)
1722     return;
1723
1724   int state = klass->state;
1725   try
1726     {
1727       // Short-circuit, so that mutually dependent classes are ok.
1728       klass->state = JV_STATE_LINKED;
1729
1730       _Jv_Constants *pool = &klass->constants;
1731
1732       // Compiled classes require that their class constants be
1733       // resolved here.  However, interpreted classes need their
1734       // constants to be resolved lazily.  If we resolve an
1735       // interpreted class' constants eagerly, we can end up with
1736       // spurious IllegalAccessErrors when the constant pool contains
1737       // a reference to a class we can't access.  This can validly
1738       // occur in an obscure case involving the InnerClasses
1739       // attribute.
1740       if (! _Jv_IsInterpretedClass (klass))
1741         {
1742           // Resolve class constants first, since other constant pool
1743           // entries may rely on these.
1744           for (int index = 1; index < pool->size; ++index)
1745             {
1746               if (pool->tags[index] == JV_CONSTANT_Class)
1747                 // Lazily resolve the entries.
1748                 resolve_pool_entry (klass, index, true);
1749             }
1750         }
1751
1752       // Resolve the remaining constant pool entries.
1753       for (int index = 1; index < pool->size; ++index)
1754         {
1755           jbyte tags;
1756           _Jv_word data;
1757
1758           tags = read_cpool_entry (&data, pool, index);
1759           if (tags == JV_CONSTANT_String)
1760             {
1761               data.o = _Jv_NewStringUtf8Const (data.utf8);
1762               tags |= JV_CONSTANT_ResolvedFlag;
1763               write_cpool_entry (data, tags, pool, index);
1764             }
1765         }
1766
1767       if (klass->engine->need_resolve_string_fields())
1768         {
1769           jfieldID f = JvGetFirstStaticField (klass);
1770           for (int n = JvNumStaticFields (klass); n > 0; --n)
1771             {
1772               int mod = f->getModifiers ();
1773               // If we have a static String field with a non-null initial
1774               // value, we know it points to a Utf8Const.
1775
1776               // Finds out whether we have to initialize a String without the
1777               // need to resolve the field.
1778               if ((f->isResolved()
1779                    ? (f->type == &java::lang::String::class$)
1780                    : _Jv_equalUtf8Classnames((_Jv_Utf8Const *) f->type,
1781                                              java::lang::String::class$.name))
1782                   && (mod & java::lang::reflect::Modifier::STATIC) != 0)
1783                 {
1784                   jstring *strp = (jstring *) f->u.addr;
1785                   if (*strp)
1786                     *strp = _Jv_NewStringUtf8Const ((_Jv_Utf8Const *) *strp);
1787                 }
1788               f = f->getNextField ();
1789             }
1790         }
1791
1792       klass->notifyAll ();
1793
1794       _Jv_PushClass (klass);
1795     }
1796   catch (java::lang::Throwable *t)
1797     {
1798       klass->state = state;
1799       throw t;
1800     }
1801 }
1802
1803 // This ensures that symbolic superclass and superinterface references
1804 // are resolved for the indicated class.  This must be called with the
1805 // class lock held.
1806 void
1807 _Jv_Linker::ensure_supers_installed (jclass klass)
1808 {
1809   resolve_class_ref (klass, &klass->superclass);
1810   // An interface won't have a superclass.
1811   if (klass->superclass)
1812     wait_for_state (klass->superclass, JV_STATE_LOADING);
1813
1814   for (int i = 0; i < klass->interface_count; ++i)
1815     {
1816       resolve_class_ref (klass, &klass->interfaces[i]);
1817       wait_for_state (klass->interfaces[i], JV_STATE_LOADING);
1818     }
1819 }
1820
1821 // This adds missing `Miranda methods' to a class.
1822 void
1823 _Jv_Linker::add_miranda_methods (jclass base, jclass iface_class)
1824 {
1825   // Note that at this point, all our supers, and the supers of all
1826   // our superclasses and superinterfaces, will have been installed.
1827
1828   for (int i = 0; i < iface_class->interface_count; ++i)
1829     {
1830       jclass interface = iface_class->interfaces[i];
1831
1832       for (int j = 0; j < interface->method_count; ++j)
1833         {
1834           _Jv_Method *meth = &interface->methods[j];
1835           // Don't bother with <clinit>.
1836           if (meth->name->first() == '<')
1837             continue;
1838           _Jv_Method *new_meth = _Jv_LookupDeclaredMethod (base, meth->name,
1839                                                            meth->signature);
1840           if (! new_meth)
1841             {
1842               // We assume that such methods are very unlikely, so we
1843               // just reallocate the method array each time one is
1844               // found.  This greatly simplifies the searching --
1845               // otherwise we have to make sure that each such method
1846               // found is really unique among all superinterfaces.
1847               int new_count = base->method_count + 1;
1848               _Jv_Method *new_m
1849                 = (_Jv_Method *) _Jv_AllocRawObj (sizeof (_Jv_Method)
1850                                                   * new_count);
1851               memcpy (new_m, base->methods,
1852                       sizeof (_Jv_Method) * base->method_count);
1853
1854               // Add new method.
1855               new_m[base->method_count] = *meth;
1856               new_m[base->method_count].index = (_Jv_ushort) -1;
1857               new_m[base->method_count].accflags
1858                 |= java::lang::reflect::Modifier::INVISIBLE;
1859
1860               base->methods = new_m;
1861               base->method_count = new_count;
1862             }
1863         }
1864
1865       wait_for_state (interface, JV_STATE_LOADED);
1866       add_miranda_methods (base, interface);
1867     }
1868 }
1869
1870 // This ensures that the class' method table is "complete".  This must
1871 // be called with the class lock held.
1872 void
1873 _Jv_Linker::ensure_method_table_complete (jclass klass)
1874 {
1875   if (klass->vtable != NULL)
1876     return;
1877
1878   // We need our superclass to have its own Miranda methods installed.
1879   if (! klass->isInterface())
1880     wait_for_state (klass->getSuperclass (), JV_STATE_LOADED);
1881
1882   // A class might have so-called "Miranda methods".  This is a method
1883   // that is declared in an interface and not re-declared in an
1884   // abstract class.  Some compilers don't emit declarations for such
1885   // methods in the class; this will give us problems since we expect
1886   // a declaration for any method requiring a vtable entry.  We handle
1887   // this here by searching for such methods and constructing new
1888   // internal declarations for them.  Note that we do this
1889   // unconditionally, and not just for abstract classes, to correctly
1890   // account for cases where a class is modified to be concrete and
1891   // still incorrectly inherits an abstract method.
1892   int pre_count = klass->method_count;
1893   add_miranda_methods (klass, klass);
1894
1895   // Let the execution engine know that we've added methods.
1896   if (klass->method_count != pre_count)
1897     klass->engine->post_miranda_hook(klass);
1898 }
1899
1900 // Verify a class.  Must be called with class lock held.
1901 void
1902 _Jv_Linker::verify_class (jclass klass)
1903 {
1904   klass->engine->verify(klass);
1905 }
1906
1907 // Check the assertions contained in the type assertion table for KLASS.
1908 // This is the equivilent of bytecode verification for native, BC-ABI code.
1909 void
1910 _Jv_Linker::verify_type_assertions (jclass klass)
1911 {
1912   if (debug_link)
1913     fprintf (stderr, "Evaluating type assertions for %s:\n",
1914              klass->name->chars());
1915
1916   if (klass->assertion_table == NULL)
1917     return;
1918
1919   for (int i = 0;; i++)
1920     {
1921       int assertion_code = klass->assertion_table[i].assertion_code;
1922       _Jv_Utf8Const *op1 = klass->assertion_table[i].op1;
1923       _Jv_Utf8Const *op2 = klass->assertion_table[i].op2;
1924
1925       if (assertion_code == JV_ASSERT_END_OF_TABLE)
1926         return;
1927       else if (assertion_code == JV_ASSERT_TYPES_COMPATIBLE)
1928         {
1929           if (debug_link)
1930             {
1931               fprintf (stderr, "  code=%i, operand A=%s B=%s\n",
1932                        assertion_code, op1->chars(), op2->chars());
1933             }
1934
1935           // The operands are class signatures. op1 is the source,
1936           // op2 is the target.
1937           jclass cl1 = _Jv_FindClassFromSignature (op1->chars(),
1938             klass->getClassLoaderInternal());
1939           jclass cl2 = _Jv_FindClassFromSignature (op2->chars(),
1940             klass->getClassLoaderInternal());
1941
1942           // If the class doesn't exist, ignore the assertion. An exception
1943           // will be thrown later if an attempt is made to actually
1944           // instantiate the class.
1945           if (cl1 == NULL || cl2 == NULL)
1946             continue;
1947
1948           if (! _Jv_IsAssignableFromSlow (cl1, cl2))
1949             {
1950               jstring s = JvNewStringUTF ("Incompatible types: In class ");
1951               s = s->concat (klass->getName());
1952               s = s->concat (JvNewStringUTF (": "));
1953               s = s->concat (cl1->getName());
1954               s = s->concat (JvNewStringUTF (" is not assignable to "));
1955               s = s->concat (cl2->getName());
1956               throw new java::lang::VerifyError (s);
1957             }
1958         }
1959       else if (assertion_code == JV_ASSERT_IS_INSTANTIABLE)
1960         {
1961           // TODO: Implement this.
1962         }
1963       // Unknown assertion codes are ignored, for forwards-compatibility.
1964     }
1965 }
1966
1967 void
1968 _Jv_Linker::print_class_loaded (jclass klass)
1969 {
1970   char *codesource = NULL;
1971   if (klass->protectionDomain != NULL)
1972     {
1973       java::security::CodeSource *cs
1974         = klass->protectionDomain->getCodeSource();
1975       if (cs != NULL)
1976         {
1977           jstring css = cs->toString();
1978           int len = JvGetStringUTFLength(css);
1979           codesource = (char *) _Jv_AllocBytes(len + 1);
1980           JvGetStringUTFRegion(css, 0, css->length(), codesource);
1981           codesource[len] = '\0';
1982         }
1983     }
1984   if (codesource == NULL)
1985     codesource = (char *) "<no code source>";
1986
1987   const char *abi;
1988   if (_Jv_IsInterpretedClass (klass))
1989     abi = "bytecode";
1990   else if (_Jv_IsBinaryCompatibilityABI (klass))
1991     abi = "BC-compiled";
1992   else
1993     abi = "pre-compiled";
1994
1995   fprintf (stderr, "[Loaded (%s) %s from %s]\n", abi, klass->name->chars(),
1996            codesource);
1997 }
1998
1999 // FIXME: mention invariants and stuff.
2000 void
2001 _Jv_Linker::wait_for_state (jclass klass, int state)
2002 {
2003   if (klass->state >= state)
2004     return;
2005
2006   java::lang::Thread *self = java::lang::Thread::currentThread();
2007
2008   {
2009     JvSynchronize sync (klass);
2010
2011     // This is similar to the strategy for class initialization.  If we
2012     // already hold the lock, just leave.
2013     while (klass->state <= state
2014            && klass->thread
2015            && klass->thread != self)
2016       klass->wait ();
2017
2018     java::lang::Thread *save = klass->thread;
2019     klass->thread = self;
2020
2021     // Allocate memory for static fields and constants.
2022     if (GC_base (klass) && klass->fields && ! GC_base (klass->fields))
2023       {
2024         jsize count = klass->field_count;
2025         if (count)
2026           {
2027             _Jv_Field* fields
2028               = (_Jv_Field*) _Jv_AllocRawObj (count * sizeof (_Jv_Field));
2029             memcpy ((void*)fields,
2030                     (void*)klass->fields,
2031                     count * sizeof (_Jv_Field));
2032             klass->fields = fields;
2033           }
2034       }
2035
2036   // Print some debugging info if requested.  Interpreted classes are
2037   // handled in defineclass, so we only need to handle the two
2038   // pre-compiled cases here.
2039   if ((klass->state == JV_STATE_COMPILED
2040           || klass->state == JV_STATE_PRELOADING)
2041       && ! _Jv_IsInterpretedClass (klass))
2042     {
2043       if (gcj::verbose_class_flag)
2044         print_class_loaded (klass);
2045       ++gcj::loadedClasses;
2046     }
2047
2048     try
2049       {
2050         if (state >= JV_STATE_LOADING && klass->state < JV_STATE_LOADING)
2051           {
2052             ensure_supers_installed (klass);
2053             klass->set_state(JV_STATE_LOADING);
2054           }
2055
2056         if (state >= JV_STATE_LOADED && klass->state < JV_STATE_LOADED)
2057           {
2058             ensure_method_table_complete (klass);
2059             klass->set_state(JV_STATE_LOADED);
2060           }
2061
2062         if (state >= JV_STATE_PREPARED && klass->state < JV_STATE_PREPARED)
2063           {
2064             ensure_fields_laid_out (klass);
2065             make_vtable (klass);
2066             layout_interface_methods (klass);
2067             prepare_constant_time_tables (klass);
2068             klass->set_state(JV_STATE_PREPARED);
2069           }
2070
2071         if (state >= JV_STATE_LINKED && klass->state < JV_STATE_LINKED)
2072           {
2073             if (gcj::verifyClasses)
2074               verify_class (klass);
2075
2076             ensure_class_linked (klass);
2077             link_exception_table (klass);
2078             link_symbol_table (klass);
2079             klass->set_state(JV_STATE_LINKED);
2080           }
2081       }
2082     catch (java::lang::Throwable *exc)
2083       {
2084         klass->thread = save;
2085         klass->set_state(JV_STATE_ERROR);
2086         throw exc;
2087       }
2088
2089     klass->thread = save;
2090
2091     if (klass->state == JV_STATE_ERROR)
2092       throw new java::lang::LinkageError;
2093   }
2094
2095 #ifdef INTERPRETER
2096   if (__builtin_expect (klass->state == JV_STATE_LINKED, false)
2097       && state >= JV_STATE_LINKED
2098       && JVMTI_REQUESTED_EVENT (ClassPrepare))
2099     {
2100       JNIEnv *jni_env = _Jv_GetCurrentJNIEnv ();
2101       _Jv_JVMTI_PostEvent (JVMTI_EVENT_CLASS_PREPARE, self, jni_env,
2102                            klass);
2103     }
2104 #endif
2105 }