libjava/java/lang/natClassLoader.cc

   1 // natClassLoader.cc - Implementation of java.lang.ClassLoader native methods.
   2
   3 /* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 /* Author: Kresten Krab Thorup <krab@gnu.org>  */
  12
  13 #include <config.h>
  14
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18
  19 #include <gcj/cni.h>
  20 #include <jvm.h>
  21 #include <execution.h>
  22
  23 #include <java-threads.h>
  24 #include <java-interp.h>
  25
  26 #include <java/lang/Character.h>
  27 #include <java/lang/Thread.h>
  28 #include <java/lang/ClassLoader.h>
  29 #include <java/lang/InternalError.h>
  30 #include <java/lang/IllegalAccessError.h>
  31 #include <java/lang/LinkageError.h>
  32 #include <java/lang/NoClassDefFoundError.h>
  33 #include <java/lang/ClassNotFoundException.h>
  34 #include <java/lang/ClassCircularityError.h>
  35 #include <java/lang/IncompatibleClassChangeError.h>
  36 #include <java/lang/ClassFormatError.h>
  37 #include <java/lang/VirtualMachineError.h>
  38 #include <java/lang/VMClassLoader.h>
  39 #include <java/lang/reflect/Modifier.h>
  40 #include <java/lang/Runtime.h>
  41 #include <java/lang/StringBuffer.h>
  42 #include <java/io/Serializable.h>
  43 #include <java/lang/Cloneable.h>
  44 #include <java/util/HashMap.h>
  45 #include <gnu/gcj/runtime/BootClassLoader.h>
  46 #include <gnu/gcj/runtime/SystemClassLoader.h>
  47
  48 // Size of local hash table.
  49 #define HASH_LEN 1013
  50
  51 // Hash function for Utf8Consts.
  52 #define HASH_UTF(Utf) ((Utf)->hash16() % HASH_LEN)
  53
  54 // This records classes which will be registered with the system class
  55 // loader when it is initialized.
  56 static jclass system_class_list;
  57
  58 // This is used as the value of system_class_list after we have
  59 // initialized the system class loader; it lets us know that we should
  60 // no longer pay attention to the system abi flag.
  61 #define SYSTEM_LOADER_INITIALIZED ((jclass) -1)
  62
  63 static jclass loaded_classes[HASH_LEN];
  64
  65 // This is the root of a linked list of classes
  66 static jclass stack_head;
  67
  68 // While bootstrapping we keep a list of classes we found, so that we
  69 // can register their packages.  There aren't many of these so we
  70 // just keep a small buffer here and abort if we overflow.
  71 #define BOOTSTRAP_CLASS_LIST_SIZE 20
  72 static jclass bootstrap_class_list[BOOTSTRAP_CLASS_LIST_SIZE];
  73 static int bootstrap_index;
  74
  75
  76 \f
  77
  78 jclass
  79 java::lang::ClassLoader::loadClassFromSig(jstring name)
  80 {
  81   int len = _Jv_GetStringUTFLength (name);
  82   char sig[len + 1];
  83   _Jv_GetStringUTFRegion (name, 0, name->length(), sig);
  84   jclass result = _Jv_FindClassFromSignature(sig, this);
  85   if (result == NULL)
  86     throw new ClassNotFoundException(name);
  87   return result;
  88 }
  89
  90 \f
  91
  92 // This tries to find a class in our built-in cache.  This cache is
  93 // used only for classes which are linked in to the executable or
  94 // loaded via dlopen().
  95 jclass
  96 _Jv_FindClassInCache (_Jv_Utf8Const *name)
  97 {
  98   JvSynchronize sync (&java::lang::Class::class$);
  99   jint hash = HASH_UTF (name);
 100
 101   jclass klass;
 102   for (klass = loaded_classes[hash]; klass; klass = klass->next_or_version)
 103     {
 104       if (_Jv_equalUtf8Consts (name, klass->name))
 105         break;
 106     }
 107
 108   return klass;
 109 }
 110
 111 void
 112 _Jv_UnregisterClass (jclass the_class)
 113 {
 114   // This can happen if the class could not be defined properly.
 115   if (! the_class->name)
 116     return;
 117
 118   JvSynchronize sync (&java::lang::Class::class$);
 119   jint hash = HASH_UTF(the_class->name);
 120
 121   jclass *klass = &(loaded_classes[hash]);
 122   for ( ; *klass; klass = &((*klass)->next_or_version))
 123     {
 124       if (*klass == the_class)
 125         {
 126           *klass = (*klass)->next_or_version;
 127           break;
 128         }
 129     }
 130 }
 131
 132 // Register an initiating class loader for a given class.
 133 void
 134 _Jv_RegisterInitiatingLoader (jclass klass, java::lang::ClassLoader *loader)
 135 {
 136   if (! loader)
 137     loader = java::lang::VMClassLoader::bootLoader;
 138   if (! loader)
 139     {
 140       // Very early in the bootstrap process, the Bootstrap classloader may
 141       // not exist yet.
 142       // FIXME: We could maintain a list of these and come back and register
 143       // them later.
 144       return;
 145     }
 146   loader->loadedClasses->put(klass->name->toString(), klass);
 147 }
 148
 149 // If we found an error while defining an interpreted class, we must
 150 // go back and unregister it.
 151 void
 152 _Jv_UnregisterInitiatingLoader (jclass klass, java::lang::ClassLoader *loader)
 153 {
 154   if (! loader)
 155     loader = java::lang::VMClassLoader::bootLoader;
 156   loader->loadedClasses->remove(klass->name->toString());
 157 }
 158
 159
 160 // Class registration.
 161 //
 162 // There are two kinds of functions that register classes.
 163 //
 164 // Type 1:
 165 //
 166 // These take the address of a class that is in an object file.
 167 // Because these classes are not allocated on the heap, It is also
 168 // necessary to register the address of the object for garbage
 169 // collection.  This is used with the "old" C++ ABI and with
 170 // -findirect-dispatch -fno-indirect-classes.
 171 //
 172 // Type 2:
 173 //
 174 // These take an initializer struct, create the class, and return the
 175 // address of the newly created class to their caller.  These are used
 176 // with -findirect-dispatch.
 177 //
 178 // _Jv_RegisterClasses() and _Jv_RegisterClasses_Counted() are
 179 // functions of Type 1, and _Jv_NewClassFromInitializer() and
 180 // _Jv_RegisterNewClasses() are of Type 2.
 181
 182
 183 // Check that the file we're trying to load has been compiled with a
 184 // compatible version of gcj.  In previous versions of libgcj we
 185 // silently failed to register classes of an incompatible ABI version,
 186 // but this was totally bogus.
 187 void
 188 _Jv_CheckABIVersion (unsigned long value)
 189 {
 190   // We are compatible with GCJ 4.0.0 BC-ABI classes. This release used a
 191   // different format for the version ID string.
 192    if (value == OLD_GCJ_40_BC_ABI_VERSION)
 193      return;
 194
 195   // The 20 low-end bits are used for the version number.
 196   unsigned long version = value & 0xfffff;
 197
 198   if (value & FLAG_BINARYCOMPAT_ABI)
 199     {
 200       int abi_rev = version % 100;
 201       int abi_ver = version - abi_rev;
 202       // We are compatible with abi_rev 0 and 1.
 203       if (abi_ver == GCJ_40_BC_ABI_VERSION && abi_rev <= 1)
 204         return;
 205     }
 206   else
 207     {
 208       // C++ ABI
 209       if (version == GCJ_CXX_ABI_VERSION)
 210         return;
 211     }
 212
 213   throw new ::java::lang::ClassFormatError
 214     (JvNewStringLatin1 ("Library compiled with later ABI version than"
 215                         " this version of libgcj supports"));
 216 }
 217
 218 // This function is called many times during startup, before main() is
 219 // run.  At that point in time we know for certain we are running
 220 // single-threaded, so we don't need to lock when adding classes to the
 221 // class chain.  At all other times, the caller should synchronize on
 222 // Class::class$.
 223 void
 224 _Jv_RegisterClasses (const jclass *classes)
 225 {
 226   _Jv_RegisterLibForGc (classes);
 227
 228   for (; *classes; ++classes)
 229     {
 230       jclass klass = *classes;
 231
 232       _Jv_CheckABIVersion ((unsigned long) klass->next_or_version);
 233       (*_Jv_RegisterClassHook) (klass);
 234     }
 235 }
 236
 237 // This is a version of _Jv_RegisterClasses that takes a count.
 238 void
 239 _Jv_RegisterClasses_Counted (const jclass * classes, size_t count)
 240 {
 241   size_t i;
 242
 243   _Jv_RegisterLibForGc (classes);
 244
 245   for (i = 0; i < count; i++)
 246     {
 247       jclass klass = classes[i];
 248
 249       _Jv_CheckABIVersion ((unsigned long) klass->next_or_version);
 250       (*_Jv_RegisterClassHook) (klass);
 251     }
 252 }
 253
 254 // Create a class on the heap from an initializer struct.
 255 inline jclass
 256 _Jv_NewClassFromInitializer (const char *class_initializer)
 257 {
 258   const unsigned long version
 259     = ((unsigned long)
 260        ((::java::lang::Class *)class_initializer)->next_or_version);
 261   _Jv_CheckABIVersion (version);
 262
 263   /* We create an instance of java::lang::Class and copy all of its
 264      fields except the first word (the vtable pointer) from
 265      CLASS_INITIALIZER.  This first word is pre-initialized by
 266      _Jv_AllocObj, and we don't want to overwrite it.  */
 267
 268   jclass new_class
 269     = (jclass)_Jv_AllocObj (sizeof (::java::lang::Class),
 270                             &::java::lang::Class::class$);
 271   const char *src = class_initializer + sizeof (void*);
 272   char *dst = (char*)new_class + sizeof (void*);
 273   size_t len = (::java::lang::Class::initializerSize (version)
 274                 - sizeof (void*));
 275   memcpy (dst, src, len);
 276
 277   new_class->engine = &_Jv_soleIndirectCompiledEngine;
 278
 279   (*_Jv_RegisterClassHook) (new_class);
 280
 281   return new_class;
 282 }
 283
 284 // Called by compiler-generated code at DSO initialization.  CLASSES
 285 // is an array of pairs: the first item of each pair is a pointer to
 286 // the initialized data that is a class initializer in a DSO, and the
 287 // second is a pointer to a class reference.
 288 // _Jv_NewClassFromInitializer() creates the new class (on the Java
 289 // heap) and we write the address of the new class into the address
 290 // pointed to by the second word.
 291 void
 292 _Jv_RegisterNewClasses (char **classes)
 293 {
 294   _Jv_InitGC ();
 295
 296   const char *initializer;
 297
 298   while ((initializer = *classes++))
 299     {
 300       jclass *class_ptr = (jclass *)*classes++;
 301       *class_ptr = _Jv_NewClassFromInitializer (initializer);
 302     }
 303 }
 304
 305 void
 306 _Jv_RegisterClassHookDefault (jclass klass)
 307 {
 308   // This is bogus, but there doesn't seem to be a better place to do
 309   // it.
 310   if (! klass->engine)
 311     klass->engine = &_Jv_soleCompiledEngine;
 312
 313   if (system_class_list != SYSTEM_LOADER_INITIALIZED)
 314     {
 315       unsigned long abi = (unsigned long) klass->next_or_version;
 316       if (! _Jv_ClassForBootstrapLoader (abi))
 317         {
 318           klass->next_or_version = system_class_list;
 319           system_class_list = klass;
 320           return;
 321         }
 322     }
 323
 324   jint hash = HASH_UTF (klass->name);
 325
 326   // If the class is already registered, don't re-register it.
 327   for (jclass check_class = loaded_classes[hash];
 328        check_class != NULL;
 329        check_class = check_class->next_or_version)
 330     {
 331       if (check_class == klass)
 332         {
 333           // If you get this, it means you have the same class in two
 334           // different libraries.
 335 #define TEXT "Duplicate class registration: "
 336           // We size-limit MESSAGE so that you can't trash the stack.
 337           char message[200];
 338           strcpy (message, TEXT);
 339           strncpy (message + sizeof (TEXT) - 1, klass->name->chars(),
 340                    sizeof (message) - sizeof (TEXT));
 341           message[sizeof (message) - 1] = '\0';
 342           if (! gcj::runtimeInitialized)
 343             JvFail (message);
 344           else
 345             {
 346               java::lang::String *str = JvNewStringLatin1 (message);
 347               throw new java::lang::VirtualMachineError (str);
 348             }
 349         }
 350     }
 351
 352   klass->next_or_version = loaded_classes[hash];
 353   loaded_classes[hash] = klass;
 354 }
 355
 356 // A pointer to a function that actually registers a class.
 357 // Normally _Jv_RegisterClassHookDefault, but could be some other function
 358 // that registers the class in e.g. a ClassLoader-local table.
 359 // Should synchronize on Class:class$ while setting/restore this variable.
 360
 361 void (*_Jv_RegisterClassHook) (jclass cl) = _Jv_RegisterClassHookDefault;
 362
 363 void
 364 _Jv_RegisterClass (jclass klass)
 365 {
 366   jclass classes[2];
 367   classes[0] = klass;
 368   classes[1] = NULL;
 369   _Jv_RegisterClasses (classes);
 370 }
 371
 372 // This is used during initialization to register all compiled-in
 373 // classes that are not part of the core with the system class loader.
 374 void
 375 _Jv_CopyClassesToSystemLoader (gnu::gcj::runtime::SystemClassLoader *loader)
 376 {
 377   for (jclass klass = system_class_list;
 378        klass;
 379        klass = klass->next_or_version)
 380     {
 381       klass->loader = loader;
 382       loader->addClass(klass);
 383     }
 384   system_class_list = SYSTEM_LOADER_INITIALIZED;
 385 }
 386
 387 // An internal variant of _Jv_FindClass which simply swallows a
 388 // NoClassDefFoundError or a ClassNotFoundException. This gives the
 389 // caller a chance to evaluate the situation and behave accordingly.
 390 jclass
 391 _Jv_FindClassNoException (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
 392 {
 393   jclass klass;
 394
 395   try
 396     {
 397       klass = _Jv_FindClass(name, loader);
 398     }
 399   catch ( java::lang::NoClassDefFoundError *ncdfe )
 400     {
 401       return NULL;
 402     }
 403   catch ( java::lang::ClassNotFoundException *cnfe )
 404     {
 405       return NULL;
 406     }
 407
 408   return klass;
 409 }
 410
 411 jclass
 412 _Jv_FindClass (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
 413 {
 414   // See if the class was already loaded by this loader.  This handles
 415   // initiating loader checks, as we register classes with their
 416   // initiating loaders.
 417
 418   java::lang::ClassLoader *boot = java::lang::VMClassLoader::bootLoader;
 419   java::lang::ClassLoader *real = loader;
 420   if (! real)
 421     real = boot;
 422   jstring sname = name->toString();
 423   // We might still be bootstrapping the VM, in which case there
 424   // won't be a bootstrap class loader yet.
 425   jclass klass = real ? real->findLoadedClass (sname) : NULL;
 426
 427   if (! klass)
 428     {
 429       if (loader)
 430         {
 431           // Load using a user-defined loader, jvmspec 5.3.2.
 432           // Note that we explicitly must call the single-argument form.
 433           klass = loader->loadClass(sname);
 434
 435           // If "loader" delegated the loadClass operation to another
 436           // loader, explicitly register that it is also an initiating
 437           // loader of the given class.
 438           java::lang::ClassLoader *delegate = (loader == boot
 439                                                ? NULL
 440                                                : loader);
 441           if (klass && klass->getClassLoaderInternal () != delegate)
 442             _Jv_RegisterInitiatingLoader (klass, loader);
 443         }
 444       else if (boot)
 445         {
 446           // Load using the bootstrap loader jvmspec 5.3.1.
 447           klass = java::lang::VMClassLoader::loadClass (sname, false);
 448
 449           // Register that we're an initiating loader.
 450           if (klass)
 451             _Jv_RegisterInitiatingLoader (klass, 0);
 452         }
 453       else
 454         {
 455           // Not even a bootstrap loader, try the built-in cache.
 456           klass = _Jv_FindClassInCache (name);
 457
 458           if (klass)
 459             {
 460               bool found = false;
 461               for (int i = 0; i < bootstrap_index; ++i)
 462                 {
 463                   if (bootstrap_class_list[i] == klass)
 464                     {
 465                       found = true;
 466                       break;
 467                     }
 468                 }
 469               if (! found)
 470                 {
 471                   if (bootstrap_index == BOOTSTRAP_CLASS_LIST_SIZE)
 472                     abort ();
 473                   bootstrap_class_list[bootstrap_index++] = klass;
 474                 }
 475             }
 476         }
 477     }
 478
 479   return klass;
 480 }
 481
 482 void
 483 _Jv_RegisterBootstrapPackages ()
 484 {
 485   for (int i = 0; i < bootstrap_index; ++i)
 486     java::lang::VMClassLoader::definePackageForNative(bootstrap_class_list[i]->getName());
 487 }
 488
 489 jclass
 490 _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
 491               java::lang::ClassLoader *loader)
 492 {
 493   jclass ret = (jclass) _Jv_AllocObject (&java::lang::Class::class$);
 494   ret->name = name;
 495   ret->superclass = superclass;
 496   ret->loader = loader;
 497
 498   _Jv_RegisterInitiatingLoader (ret, loader);
 499
 500   return ret;
 501 }
 502
 503 static _Jv_IDispatchTable *array_idt = NULL;
 504 static jshort array_depth = 0;
 505 static jclass *array_ancestors = NULL;
 506
 507 static jclass interfaces[] =
 508 {
 509   &java::lang::Cloneable::class$,
 510   &java::io::Serializable::class$
 511 };
 512
 513 // Create a class representing an array of ELEMENT and store a pointer to it
 514 // in element->arrayclass. LOADER is the ClassLoader which _initiated_ the
 515 // instantiation of this array. ARRAY_VTABLE is the vtable to use for the new
 516 // array class. This parameter is optional.
 517 void
 518 _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader,
 519                    _Jv_VTable *array_vtable)
 520 {
 521   JvSynchronize sync (element);
 522
 523   _Jv_Utf8Const *array_name;
 524   int len;
 525
 526   if (element->arrayclass)
 527     return;
 528
 529   if (element->isPrimitive())
 530     {
 531       if (element == JvPrimClass (void))
 532         throw new java::lang::ClassNotFoundException ();
 533       len = 3;
 534     }
 535   else
 536     len = element->name->len() + 5;
 537
 538   {
 539     char signature[len];
 540     int index = 0;
 541     signature[index++] = '[';
 542     // Compute name of array class.
 543     if (element->isPrimitive())
 544       {
 545         signature[index++] = (char) element->method_count;
 546       }
 547     else
 548       {
 549         size_t length = element->name->len();
 550         const char *const name = element->name->chars();
 551         if (name[0] != '[')
 552           signature[index++] = 'L';
 553         memcpy (&signature[index], name, length);
 554         index += length;
 555         if (name[0] != '[')
 556           signature[index++] = ';';
 557       }
 558     array_name = _Jv_makeUtf8Const (signature, index);
 559   }
 560
 561   // Create new array class.
 562   jclass array_class = _Jv_NewClass (array_name, &java::lang::Object::class$,
 563                                      element->loader);
 564
 565   // Note that `vtable_method_count' doesn't include the initial
 566   // gc_descr slot.
 567   int dm_count = java::lang::Object::class$.vtable_method_count;
 568
 569   // Create a new vtable by copying Object's vtable.
 570   _Jv_VTable *vtable;
 571   if (array_vtable)
 572     vtable = array_vtable;
 573   else
 574     vtable = _Jv_VTable::new_vtable (dm_count);
 575   vtable->clas = array_class;
 576   vtable->gc_descr = java::lang::Object::class$.vtable->gc_descr;
 577   for (int i = 0; i < dm_count; ++i)
 578     vtable->set_method (i, java::lang::Object::class$.vtable->get_method (i));
 579
 580   array_class->vtable = vtable;
 581   array_class->vtable_method_count
 582     = java::lang::Object::class$.vtable_method_count;
 583
 584   // Stash the pointer to the element type.
 585   array_class->element_type = element;
 586
 587   // Register our interfaces.
 588   array_class->interfaces = interfaces;
 589   array_class->interface_count = sizeof interfaces / sizeof interfaces[0];
 590
 591   // Since all array classes have the same interface dispatch table, we can
 592   // cache one and reuse it. It is not necessary to synchronize this.
 593   if (!array_idt)
 594     {
 595       _Jv_Linker::wait_for_state(array_class, JV_STATE_PREPARED);
 596       array_idt = array_class->idt;
 597       array_depth = array_class->depth;
 598       array_ancestors = array_class->ancestors;
 599     }
 600   else
 601     {
 602       array_class->idt = array_idt;
 603       array_class->depth = array_depth;
 604       array_class->ancestors = array_ancestors;
 605     }
 606
 607   using namespace java::lang::reflect;
 608   {
 609     // Array classes are "abstract final" and inherit accessibility
 610     // from element type, per vmspec 5.3.3.2
 611     _Jv_ushort accflags = (Modifier::FINAL | Modifier::ABSTRACT
 612                            | (element->accflags
 613                               & (Modifier::PUBLIC | Modifier::PROTECTED
 614                                  | Modifier::PRIVATE)));
 615     array_class->accflags = accflags;
 616   }
 617
 618   // An array class has no visible instance fields. "length" is invisible to
 619   // reflection.
 620
 621   // Say this class is initialized and ready to go!
 622   array_class->state = JV_STATE_DONE;
 623
 624   // vmspec, section 5.3.3 describes this
 625   if (element->loader != loader)
 626     _Jv_RegisterInitiatingLoader (array_class, loader);
 627
 628   element->arrayclass = array_class;
 629 }
 630
 631 // These two functions form a stack of classes.   When a class is loaded
 632 // it is pushed onto the stack by the class loader; this is so that
 633 // StackTrace can quickly determine which classes have been loaded.
 634
 635 jclass
 636 _Jv_PopClass (void)
 637 {
 638   JvSynchronize sync (&java::lang::Class::class$);
 639   if (stack_head)
 640     {
 641       jclass tmp = stack_head;
 642       stack_head = tmp->chain;
 643       return tmp;
 644     }
 645   return NULL;
 646 }
 647
 648 void
 649 _Jv_PushClass (jclass k)
 650 {
 651   JvSynchronize sync (&java::lang::Class::class$);
 652   jclass tmp = stack_head;
 653   stack_head = k;
 654   k->chain = tmp;
 655 }