OSDN Git Service

2007-05-31 Andrew Haley <aph@redhat.com>
[pf3gnuchains/gcc-fork.git] / 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       // If we've loaded a library that uses the C++ ABI, and this
213       // library is an incompatible version, then we're dead.  There's
214       // no point throwing an exception: that will crash.
215       JvFail ("gcj linkage error.\n"
216               "Incorrect library ABI version detected.  Aborting.\n");
217     }
218
219   throw new ::java::lang::ClassFormatError
220     (JvNewStringLatin1 ("Library compiled with later ABI version than"
221                         " this version of libgcj supports"));
222 }
223
224 // This function is called many times during startup, before main() is
225 // run.  At that point in time we know for certain we are running 
226 // single-threaded, so we don't need to lock when adding classes to the 
227 // class chain.  At all other times, the caller should synchronize on
228 // Class::class$.
229 void
230 _Jv_RegisterClasses (const jclass *classes)
231 {
232   _Jv_RegisterLibForGc (classes);
233
234   for (; *classes; ++classes)
235     {
236       jclass klass = *classes;
237
238       _Jv_CheckABIVersion ((unsigned long) klass->next_or_version);
239       (*_Jv_RegisterClassHook) (klass);
240     }
241 }
242
243 // This is a version of _Jv_RegisterClasses that takes a count.
244 void
245 _Jv_RegisterClasses_Counted (const jclass * classes, size_t count)
246 {
247   size_t i;
248
249   _Jv_RegisterLibForGc (classes);
250
251   for (i = 0; i < count; i++)
252     {
253       jclass klass = classes[i];
254
255       _Jv_CheckABIVersion ((unsigned long) klass->next_or_version);
256       (*_Jv_RegisterClassHook) (klass);
257     }
258 }
259
260 // Create a class on the heap from an initializer struct.
261 inline jclass
262 _Jv_NewClassFromInitializer (const char *class_initializer)
263 {
264   const unsigned long version 
265     = ((unsigned long) 
266        ((::java::lang::Class *)class_initializer)->next_or_version);
267   _Jv_CheckABIVersion (version);
268   
269   /* We create an instance of java::lang::Class and copy all of its
270      fields except the first word (the vtable pointer) from
271      CLASS_INITIALIZER.  This first word is pre-initialized by
272      _Jv_AllocObj, and we don't want to overwrite it.  */
273   
274   jclass new_class
275     = (jclass)_Jv_AllocObj (sizeof (::java::lang::Class),
276                             &::java::lang::Class::class$);
277   const char *src = class_initializer + sizeof (void*);
278   char *dst = (char*)new_class + sizeof (void*);
279   size_t len = (::java::lang::Class::initializerSize (version) 
280                 - sizeof (void*));
281   memcpy (dst, src, len);
282   
283   new_class->engine = &_Jv_soleIndirectCompiledEngine;
284
285   /* FIXME:  Way back before the dawn of time, we overloaded the
286      SYNTHETIC class access modifier to mean INTERPRETED.  This was a
287      Bad Thing, but it didn't matter then because classes were never
288      marked synthetic.  However, it is possible to redeem the
289      situation: _Jv_NewClassFromInitializer is only called from
290      compiled classes, so we clear the INTERPRETED flag.  This is a
291      kludge!  */
292   new_class->accflags &= ~java::lang::reflect::Modifier::INTERPRETED;
293
294   (*_Jv_RegisterClassHook) (new_class);
295   
296   return new_class;
297 }
298
299 // Called by compiler-generated code at DSO initialization.  CLASSES
300 // is an array of pairs: the first item of each pair is a pointer to
301 // the initialized data that is a class initializer in a DSO, and the
302 // second is a pointer to a class reference.
303 // _Jv_NewClassFromInitializer() creates the new class (on the Java
304 // heap) and we write the address of the new class into the address
305 // pointed to by the second word.
306 void
307 _Jv_RegisterNewClasses (char **classes)
308 {
309   _Jv_InitGC ();
310
311   const char *initializer;
312
313   while ((initializer = *classes++))
314     {
315       jclass *class_ptr = (jclass *)*classes++;
316       *class_ptr = _Jv_NewClassFromInitializer (initializer);
317     }      
318 }
319   
320 void
321 _Jv_RegisterClassHookDefault (jclass klass)
322 {
323   // This is bogus, but there doesn't seem to be a better place to do
324   // it.
325   if (! klass->engine)
326     klass->engine = &_Jv_soleCompiledEngine;
327
328   if (system_class_list != SYSTEM_LOADER_INITIALIZED)
329     {
330       unsigned long abi = (unsigned long) klass->next_or_version;
331       if (! _Jv_ClassForBootstrapLoader (abi))
332         {
333           klass->next_or_version = system_class_list;
334           system_class_list = klass;
335           return;
336         }
337     }
338
339   jint hash = HASH_UTF (klass->name);
340
341   // If the class is already registered, don't re-register it.
342   for (jclass check_class = loaded_classes[hash];
343        check_class != NULL;
344        check_class = check_class->next_or_version)
345     {
346       if (check_class == klass)
347         {
348           // If you get this, it means you have the same class in two
349           // different libraries.
350 #define TEXT "Duplicate class registration: "
351           // We size-limit MESSAGE so that you can't trash the stack.
352           char message[200];
353           strcpy (message, TEXT);
354           strncpy (message + sizeof (TEXT) - 1, klass->name->chars(),
355                    sizeof (message) - sizeof (TEXT));
356           message[sizeof (message) - 1] = '\0';
357           if (! gcj::runtimeInitialized)
358             JvFail (message);
359           else
360             {
361               java::lang::String *str = JvNewStringLatin1 (message);
362               throw new java::lang::VirtualMachineError (str);
363             }
364         }
365     }
366
367   klass->next_or_version = loaded_classes[hash];
368   loaded_classes[hash] = klass;
369 }
370
371 // A pointer to a function that actually registers a class.
372 // Normally _Jv_RegisterClassHookDefault, but could be some other function
373 // that registers the class in e.g. a ClassLoader-local table.
374 // Should synchronize on Class:class$ while setting/restore this variable.
375
376 void (*_Jv_RegisterClassHook) (jclass cl) = _Jv_RegisterClassHookDefault;
377
378 void
379 _Jv_RegisterClass (jclass klass)
380 {
381   jclass classes[2];
382   classes[0] = klass;
383   classes[1] = NULL;
384   _Jv_RegisterClasses (classes);
385 }
386
387 // This is used during initialization to register all compiled-in
388 // classes that are not part of the core with the system class loader.
389 void
390 _Jv_CopyClassesToSystemLoader (gnu::gcj::runtime::SystemClassLoader *loader)
391 {
392   for (jclass klass = system_class_list;
393        klass;
394        klass = klass->next_or_version)
395     {
396       klass->loader = loader;
397       loader->addClass(klass);
398     }
399   system_class_list = SYSTEM_LOADER_INITIALIZED;
400 }
401
402 // An internal variant of _Jv_FindClass which simply swallows a
403 // NoClassDefFoundError or a ClassNotFoundException. This gives the
404 // caller a chance to evaluate the situation and behave accordingly.
405 jclass
406 _Jv_FindClassNoException (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
407 {
408   jclass klass;
409
410   try
411     {
412       klass = _Jv_FindClass(name, loader);
413     }
414   catch ( java::lang::NoClassDefFoundError *ncdfe )
415     {
416       return NULL;
417     }
418   catch ( java::lang::ClassNotFoundException *cnfe )
419     {
420       return NULL;
421     }
422
423   return klass;
424 }
425
426 jclass
427 _Jv_FindClass (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
428 {
429   // See if the class was already loaded by this loader.  This handles
430   // initiating loader checks, as we register classes with their
431   // initiating loaders.
432
433   java::lang::ClassLoader *boot = java::lang::VMClassLoader::bootLoader;
434   java::lang::ClassLoader *real = loader;
435   if (! real)
436     real = boot;
437   jstring sname = name->toString();
438   // We might still be bootstrapping the VM, in which case there
439   // won't be a bootstrap class loader yet.
440   jclass klass = real ? real->findLoadedClass (sname) : NULL;
441
442   if (! klass)
443     {
444       if (loader)
445         {
446           // Load using a user-defined loader, jvmspec 5.3.2.
447           // Note that we explicitly must call the single-argument form.
448           klass = loader->loadClass(sname);
449
450           // If "loader" delegated the loadClass operation to another
451           // loader, explicitly register that it is also an initiating
452           // loader of the given class.
453           java::lang::ClassLoader *delegate = (loader == boot
454                                                ? NULL
455                                                : loader);
456           if (klass && klass->getClassLoaderInternal () != delegate)
457             _Jv_RegisterInitiatingLoader (klass, loader);
458         }
459       else if (boot)
460         {
461           // Load using the bootstrap loader jvmspec 5.3.1.
462           klass = java::lang::VMClassLoader::loadClass (sname, false); 
463
464           // Register that we're an initiating loader.
465           if (klass)
466             _Jv_RegisterInitiatingLoader (klass, 0);
467         }
468       else
469         {
470           // Not even a bootstrap loader, try the built-in cache.
471           klass = _Jv_FindClassInCache (name);
472
473           if (klass)
474             {
475               bool found = false;
476               for (int i = 0; i < bootstrap_index; ++i)
477                 {
478                   if (bootstrap_class_list[i] == klass)
479                     {
480                       found = true;
481                       break;
482                     }
483                 }
484               if (! found)
485                 {
486                   if (bootstrap_index == BOOTSTRAP_CLASS_LIST_SIZE)
487                     abort ();
488                   bootstrap_class_list[bootstrap_index++] = klass;
489                 }
490             }
491         }
492     }
493
494   return klass;
495 }
496
497 void
498 _Jv_RegisterBootstrapPackages ()
499 {
500   for (int i = 0; i < bootstrap_index; ++i)
501     java::lang::VMClassLoader::definePackageForNative(bootstrap_class_list[i]->getName());
502 }
503
504 jclass
505 _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
506               java::lang::ClassLoader *loader)
507 {
508   jclass ret = (jclass) _Jv_AllocObject (&java::lang::Class::class$);
509   ret->name = name;
510   ret->superclass = superclass;
511   ret->loader = loader;
512
513   _Jv_RegisterInitiatingLoader (ret, loader);
514
515   return ret;
516 }
517
518 static _Jv_IDispatchTable *array_idt = NULL;
519 static jshort array_depth = 0;
520 static jclass *array_ancestors = NULL;
521
522 static jclass interfaces[] =
523 {
524   &java::lang::Cloneable::class$,
525   &java::io::Serializable::class$
526 };
527
528 // Create a class representing an array of ELEMENT and store a pointer to it
529 // in element->arrayclass. LOADER is the ClassLoader which _initiated_ the 
530 // instantiation of this array. ARRAY_VTABLE is the vtable to use for the new 
531 // array class. This parameter is optional.
532 void
533 _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader,
534                    _Jv_VTable *array_vtable)
535 {
536   JvSynchronize sync (element);
537
538   _Jv_Utf8Const *array_name;
539   int len;
540
541   if (element->arrayclass)
542     return;
543
544   if (element->isPrimitive())
545     {
546       if (element == JvPrimClass (void))
547         throw new java::lang::ClassNotFoundException ();
548       len = 3;
549     }
550   else
551     len = element->name->len() + 5;
552
553   {
554     char signature[len];
555     int index = 0;
556     signature[index++] = '[';
557     // Compute name of array class.
558     if (element->isPrimitive())
559       {
560         signature[index++] = (char) element->method_count;
561       }
562     else
563       {
564         size_t length = element->name->len();
565         const char *const name = element->name->chars();
566         if (name[0] != '[')
567           signature[index++] = 'L';
568         memcpy (&signature[index], name, length);
569         index += length;
570         if (name[0] != '[')
571           signature[index++] = ';';
572       }      
573     array_name = _Jv_makeUtf8Const (signature, index);
574   }
575
576   // Create new array class.
577   jclass array_class = _Jv_NewClass (array_name, &java::lang::Object::class$,
578                                      element->loader);
579
580   // Note that `vtable_method_count' doesn't include the initial
581   // gc_descr slot.
582   int dm_count = java::lang::Object::class$.vtable_method_count;
583
584   // Create a new vtable by copying Object's vtable.
585   _Jv_VTable *vtable;
586   if (array_vtable)
587     vtable = array_vtable;
588   else
589     vtable = _Jv_VTable::new_vtable (dm_count);
590   vtable->clas = array_class;
591   vtable->gc_descr = java::lang::Object::class$.vtable->gc_descr;
592   for (int i = 0; i < dm_count; ++i)
593     vtable->set_method (i, java::lang::Object::class$.vtable->get_method (i));
594
595   array_class->vtable = vtable;
596   array_class->vtable_method_count
597     = java::lang::Object::class$.vtable_method_count;
598
599   // Stash the pointer to the element type.
600   array_class->element_type = element;
601
602   // Register our interfaces.
603   array_class->interfaces = interfaces;
604   array_class->interface_count = sizeof interfaces / sizeof interfaces[0];
605
606   // Since all array classes have the same interface dispatch table, we can 
607   // cache one and reuse it. It is not necessary to synchronize this.
608   if (!array_idt)
609     {
610       _Jv_Linker::wait_for_state(array_class, JV_STATE_PREPARED);
611       array_idt = array_class->idt;
612       array_depth = array_class->depth;
613       array_ancestors = array_class->ancestors;
614     }
615   else
616     {
617       array_class->idt = array_idt;
618       array_class->depth = array_depth;
619       array_class->ancestors = array_ancestors;
620     }
621
622   using namespace java::lang::reflect;
623   {
624     // Array classes are "abstract final" and inherit accessibility
625     // from element type, per vmspec 5.3.3.2
626     _Jv_ushort accflags = (Modifier::FINAL | Modifier::ABSTRACT
627                            | (element->accflags
628                               & (Modifier::PUBLIC | Modifier::PROTECTED
629                                  | Modifier::PRIVATE)));
630     array_class->accflags = accflags;
631   }
632
633   // An array class has no visible instance fields. "length" is invisible to 
634   // reflection.
635
636   // Say this class is initialized and ready to go!
637   array_class->state = JV_STATE_DONE;
638
639   // vmspec, section 5.3.3 describes this
640   if (element->loader != loader)
641     _Jv_RegisterInitiatingLoader (array_class, loader);
642
643   element->arrayclass = array_class;
644 }
645
646 // These two functions form a stack of classes.   When a class is loaded
647 // it is pushed onto the stack by the class loader; this is so that
648 // StackTrace can quickly determine which classes have been loaded.
649
650 jclass
651 _Jv_PopClass (void)
652 {
653   JvSynchronize sync (&java::lang::Class::class$);
654   if (stack_head)
655     {
656       jclass tmp = stack_head;
657       stack_head = tmp->chain;
658       return tmp;
659     }
660   return NULL;
661 }
662
663 void
664 _Jv_PushClass (jclass k)
665 {
666   JvSynchronize sync (&java::lang::Class::class$);
667   jclass tmp = stack_head;
668   stack_head = k;
669   k->chain = tmp;
670 }