OSDN Git Service

2006-04-25 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 // This function is called many times during startup, before main() is
160 // run.  At that point in time we know for certain we are running 
161 // single-threaded, so we don't need to lock when adding classes to the 
162 // class chain.  At all other times, the caller should synchronize on
163 // Class::class$.
164 void
165 _Jv_RegisterClasses (const jclass *classes)
166 {
167   _Jv_RegisterLibForGc (classes);
168
169   for (; *classes; ++classes)
170     {
171       jclass klass = *classes;
172
173       if (_Jv_CheckABIVersion ((unsigned long) klass->next_or_version))
174         (*_Jv_RegisterClassHook) (klass);
175     }
176 }
177
178 // This is a version of _Jv_RegisterClasses that takes a count.
179 void
180 _Jv_RegisterClasses_Counted (const jclass * classes, size_t count)
181 {
182   size_t i;
183
184   _Jv_RegisterLibForGc (classes);
185
186   for (i = 0; i < count; i++)
187     {
188       jclass klass = classes[i];
189
190       if (_Jv_CheckABIVersion ((unsigned long) klass->next_or_version))
191         (*_Jv_RegisterClassHook) (klass);
192     }
193 }
194
195 // Create a class on the heap from an initializer struct.
196 jclass
197 _Jv_NewClassFromInitializer (const jclass class_initializer)
198 {
199   jclass new_class = (jclass)_Jv_AllocObj (sizeof *new_class,
200                                            &java::lang::Class::class$);  
201   memcpy ((void*)new_class, (void*)class_initializer, sizeof *new_class);
202
203   if (_Jv_CheckABIVersion ((unsigned long) new_class->next_or_version))
204     (*_Jv_RegisterClassHook) (new_class);
205   
206   return new_class;
207 }
208
209 // Called by compiler-generated code at DSO initialization.  CLASSES
210 // is an array of pairs: the first item of each pair is a pointer to
211 // the initialized data that is a class initializer in a DSO, and the
212 // second is a pointer to a class reference.
213 // _Jv_NewClassFromInitializer() creates the new class (on the Java
214 // heap) and we write the address of the new class into the address
215 // pointed to by the second word.
216 void
217 _Jv_RegisterNewClasses (void **classes)
218 {
219   _Jv_InitGC ();
220
221   jclass initializer;
222
223   while ((initializer = (jclass)*classes++))
224     {
225       jclass *class_ptr = (jclass *)*classes++;
226       *class_ptr = _Jv_NewClassFromInitializer (initializer);
227     }      
228 }
229   
230 void
231 _Jv_RegisterClassHookDefault (jclass klass)
232 {
233   // This is bogus, but there doesn't seem to be a better place to do
234   // it.
235   if (! klass->engine)
236     klass->engine = &_Jv_soleCompiledEngine;
237
238   if (system_class_list != SYSTEM_LOADER_INITIALIZED)
239     {
240       unsigned long abi = (unsigned long) klass->next_or_version;
241       if (! _Jv_ClassForBootstrapLoader (abi))
242         {
243           klass->next_or_version = system_class_list;
244           system_class_list = klass;
245           return;
246         }
247     }
248
249   jint hash = HASH_UTF (klass->name);
250
251   // If the class is already registered, don't re-register it.
252   for (jclass check_class = loaded_classes[hash];
253        check_class != NULL;
254        check_class = check_class->next_or_version)
255     {
256       if (check_class == klass)
257         {
258           // If you get this, it means you have the same class in two
259           // different libraries.
260 #define TEXT "Duplicate class registration: "
261           // We size-limit MESSAGE so that you can't trash the stack.
262           char message[200];
263           strcpy (message, TEXT);
264           strncpy (message + sizeof (TEXT) - 1, klass->name->chars(),
265                    sizeof (message) - sizeof (TEXT));
266           message[sizeof (message) - 1] = '\0';
267           if (! gcj::runtimeInitialized)
268             JvFail (message);
269           else
270             {
271               java::lang::String *str = JvNewStringLatin1 (message);
272               throw new java::lang::VirtualMachineError (str);
273             }
274         }
275     }
276
277   klass->next_or_version = loaded_classes[hash];
278   loaded_classes[hash] = klass;
279 }
280
281 // A pointer to a function that actually registers a class.
282 // Normally _Jv_RegisterClassHookDefault, but could be some other function
283 // that registers the class in e.g. a ClassLoader-local table.
284 // Should synchronize on Class:class$ while setting/restore this variable.
285
286 void (*_Jv_RegisterClassHook) (jclass cl) = _Jv_RegisterClassHookDefault;
287
288 void
289 _Jv_RegisterClass (jclass klass)
290 {
291   jclass classes[2];
292   classes[0] = klass;
293   classes[1] = NULL;
294   _Jv_RegisterClasses (classes);
295 }
296
297 // This is used during initialization to register all compiled-in
298 // classes that are not part of the core with the system class loader.
299 void
300 _Jv_CopyClassesToSystemLoader (gnu::gcj::runtime::SystemClassLoader *loader)
301 {
302   for (jclass klass = system_class_list;
303        klass;
304        klass = klass->next_or_version)
305     {
306       klass->loader = loader;
307       loader->addClass(klass);
308     }
309   system_class_list = SYSTEM_LOADER_INITIALIZED;
310 }
311
312 // An internal variant of _Jv_FindClass which simply swallows a
313 // NoClassDefFoundError or a ClassNotFoundException. This gives the
314 // caller a chance to evaluate the situation and behave accordingly.
315 jclass
316 _Jv_FindClassNoException (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
317 {
318   jclass klass;
319
320   try
321     {
322       klass = _Jv_FindClass(name, loader);
323     }
324   catch ( java::lang::NoClassDefFoundError *ncdfe )
325     {
326       return NULL;
327     }
328   catch ( java::lang::ClassNotFoundException *cnfe )
329     {
330       return NULL;
331     }
332
333   return klass;
334 }
335
336 jclass
337 _Jv_FindClass (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
338 {
339   // See if the class was already loaded by this loader.  This handles
340   // initiating loader checks, as we register classes with their
341   // initiating loaders.
342
343   java::lang::ClassLoader *boot = java::lang::VMClassLoader::bootLoader;
344   java::lang::ClassLoader *real = loader;
345   if (! real)
346     real = boot;
347   jstring sname = name->toString();
348   // We might still be bootstrapping the VM, in which case there
349   // won't be a bootstrap class loader yet.
350   jclass klass = real ? real->findLoadedClass (sname) : NULL;
351
352   if (! klass)
353     {
354       if (loader)
355         {
356           // Load using a user-defined loader, jvmspec 5.3.2.
357           // Note that we explicitly must call the single-argument form.
358           klass = loader->loadClass(sname);
359
360           // If "loader" delegated the loadClass operation to another
361           // loader, explicitly register that it is also an initiating
362           // loader of the given class.
363           java::lang::ClassLoader *delegate = (loader == boot
364                                                ? NULL
365                                                : loader);
366           if (klass && klass->getClassLoaderInternal () != delegate)
367             _Jv_RegisterInitiatingLoader (klass, loader);
368         }
369       else if (boot)
370         {
371           // Load using the bootstrap loader jvmspec 5.3.1.
372           klass = java::lang::VMClassLoader::loadClass (sname, false); 
373
374           // Register that we're an initiating loader.
375           if (klass)
376             _Jv_RegisterInitiatingLoader (klass, 0);
377         }
378       else
379         {
380           // Not even a bootstrap loader, try the built-in cache.
381           klass = _Jv_FindClassInCache (name);
382
383           if (klass)
384             {
385               bool found = false;
386               for (int i = 0; i < bootstrap_index; ++i)
387                 {
388                   if (bootstrap_class_list[i] == klass)
389                     {
390                       found = true;
391                       break;
392                     }
393                 }
394               if (! found)
395                 {
396                   if (bootstrap_index == BOOTSTRAP_CLASS_LIST_SIZE)
397                     abort ();
398                   bootstrap_class_list[bootstrap_index++] = klass;
399                 }
400             }
401         }
402     }
403
404   return klass;
405 }
406
407 void
408 _Jv_RegisterBootstrapPackages ()
409 {
410   for (int i = 0; i < bootstrap_index; ++i)
411     java::lang::VMClassLoader::definePackageForNative(bootstrap_class_list[i]->getName());
412 }
413
414 jclass
415 _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
416               java::lang::ClassLoader *loader)
417 {
418   jclass ret = (jclass) _Jv_AllocObject (&java::lang::Class::class$);
419   ret->name = name;
420   ret->superclass = superclass;
421   ret->loader = loader;
422
423   _Jv_RegisterInitiatingLoader (ret, loader);
424
425   return ret;
426 }
427
428 static _Jv_IDispatchTable *array_idt = NULL;
429 static jshort array_depth = 0;
430 static jclass *array_ancestors = NULL;
431
432 static jclass interfaces[] =
433 {
434   &java::lang::Cloneable::class$,
435   &java::io::Serializable::class$
436 };
437
438 // Create a class representing an array of ELEMENT and store a pointer to it
439 // in element->arrayclass. LOADER is the ClassLoader which _initiated_ the 
440 // instantiation of this array. ARRAY_VTABLE is the vtable to use for the new 
441 // array class. This parameter is optional.
442 void
443 _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader,
444                    _Jv_VTable *array_vtable)
445 {
446   JvSynchronize sync (element);
447
448   _Jv_Utf8Const *array_name;
449   int len;
450
451   if (element->arrayclass)
452     return;
453
454   if (element->isPrimitive())
455     {
456       if (element == JvPrimClass (void))
457         throw new java::lang::ClassNotFoundException ();
458       len = 3;
459     }
460   else
461     len = element->name->len() + 5;
462
463   {
464     char signature[len];
465     int index = 0;
466     signature[index++] = '[';
467     // Compute name of array class.
468     if (element->isPrimitive())
469       {
470         signature[index++] = (char) element->method_count;
471       }
472     else
473       {
474         size_t length = element->name->len();
475         const char *const name = element->name->chars();
476         if (name[0] != '[')
477           signature[index++] = 'L';
478         memcpy (&signature[index], name, length);
479         index += length;
480         if (name[0] != '[')
481           signature[index++] = ';';
482       }      
483     array_name = _Jv_makeUtf8Const (signature, index);
484   }
485
486   // Create new array class.
487   jclass array_class = _Jv_NewClass (array_name, &java::lang::Object::class$,
488                                      element->loader);
489
490   // Note that `vtable_method_count' doesn't include the initial
491   // gc_descr slot.
492   int dm_count = java::lang::Object::class$.vtable_method_count;
493
494   // Create a new vtable by copying Object's vtable.
495   _Jv_VTable *vtable;
496   if (array_vtable)
497     vtable = array_vtable;
498   else
499     vtable = _Jv_VTable::new_vtable (dm_count);
500   vtable->clas = array_class;
501   vtable->gc_descr = java::lang::Object::class$.vtable->gc_descr;
502   for (int i = 0; i < dm_count; ++i)
503     vtable->set_method (i, java::lang::Object::class$.vtable->get_method (i));
504
505   array_class->vtable = vtable;
506   array_class->vtable_method_count
507     = java::lang::Object::class$.vtable_method_count;
508
509   // Stash the pointer to the element type.
510   array_class->element_type = element;
511
512   // Register our interfaces.
513   array_class->interfaces = interfaces;
514   array_class->interface_count = sizeof interfaces / sizeof interfaces[0];
515
516   // Since all array classes have the same interface dispatch table, we can 
517   // cache one and reuse it. It is not necessary to synchronize this.
518   if (!array_idt)
519     {
520       _Jv_Linker::wait_for_state(array_class, JV_STATE_PREPARED);
521       array_idt = array_class->idt;
522       array_depth = array_class->depth;
523       array_ancestors = array_class->ancestors;
524     }
525   else
526     {
527       array_class->idt = array_idt;
528       array_class->depth = array_depth;
529       array_class->ancestors = array_ancestors;
530     }
531
532   using namespace java::lang::reflect;
533   {
534     // Array classes are "abstract final" and inherit accessibility
535     // from element type, per vmspec 5.3.3.2
536     _Jv_ushort accflags = (Modifier::FINAL | Modifier::ABSTRACT
537                            | (element->accflags
538                               & (Modifier::PUBLIC | Modifier::PROTECTED
539                                  | Modifier::PRIVATE)));
540     array_class->accflags = accflags;
541   }
542
543   // An array class has no visible instance fields. "length" is invisible to 
544   // reflection.
545
546   // Say this class is initialized and ready to go!
547   array_class->state = JV_STATE_DONE;
548
549   // vmspec, section 5.3.3 describes this
550   if (element->loader != loader)
551     _Jv_RegisterInitiatingLoader (array_class, loader);
552
553   element->arrayclass = array_class;
554 }
555
556 // These two functions form a stack of classes.   When a class is loaded
557 // it is pushed onto the stack by the class loader; this is so that
558 // StackTrace can quickly determine which classes have been loaded.
559
560 jclass
561 _Jv_PopClass (void)
562 {
563   JvSynchronize sync (&java::lang::Class::class$);
564   if (stack_head)
565     {
566       jclass tmp = stack_head;
567       stack_head = tmp->chain;
568       return tmp;
569     }
570   return NULL;
571 }
572
573 void
574 _Jv_PushClass (jclass k)
575 {
576   JvSynchronize sync (&java::lang::Class::class$);
577   jclass tmp = stack_head;
578   stack_head = k;
579   k->chain = tmp;
580 }