OSDN Git Service

a6b353f2a957158e65fb40226ca0e289e1393ddd
[pf3gnuchains/gcc-fork.git] / libjava / java / lang / natClass.cc
1 // natClass.cc - Implementation of java.lang.Class native methods.
2
3 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
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 #include <config.h>
13
14 #include <limits.h>
15 #include <string.h>
16 #include <stddef.h>
17 #include <stdio.h>
18
19 #pragma implementation "Class.h"
20
21 #include <gcj/cni.h>
22 #include <jvm.h>
23 #include <java-threads.h>
24
25 #include <java/lang/Class.h>
26 #include <java/lang/ClassLoader.h>
27 #include <java/lang/String.h>
28 #include <java/lang/reflect/Modifier.h>
29 #include <java/lang/reflect/Member.h>
30 #include <java/lang/reflect/Method.h>
31 #include <java/lang/reflect/Field.h>
32 #include <java/lang/reflect/Constructor.h>
33 #include <java/lang/AbstractMethodError.h>
34 #include <java/lang/ArrayStoreException.h>
35 #include <java/lang/ClassCastException.h>
36 #include <java/lang/ClassNotFoundException.h>
37 #include <java/lang/ExceptionInInitializerError.h>
38 #include <java/lang/IllegalAccessException.h>
39 #include <java/lang/IllegalAccessError.h>
40 #include <java/lang/IllegalArgumentException.h>
41 #include <java/lang/IncompatibleClassChangeError.h>
42 #include <java/lang/NoSuchFieldError.h>
43 #include <java/lang/ArrayIndexOutOfBoundsException.h>
44 #include <java/lang/InstantiationException.h>
45 #include <java/lang/NoClassDefFoundError.h>
46 #include <java/lang/NoSuchFieldException.h>
47 #include <java/lang/NoSuchMethodError.h>
48 #include <java/lang/NoSuchMethodException.h>
49 #include <java/lang/Thread.h>
50 #include <java/lang/NullPointerException.h>
51 #include <java/lang/RuntimePermission.h>
52 #include <java/lang/System.h>
53 #include <java/lang/SecurityException.h>
54 #include <java/lang/SecurityManager.h>
55 #include <java/lang/StringBuffer.h>
56 #include <java/lang/VMClassLoader.h>
57 #include <gcj/method.h>
58 #include <gnu/gcj/RawData.h>
59 #include <java/lang/VerifyError.h>
60 #include <java/lang/InternalError.h>
61 #include <java/lang/TypeNotPresentException.h>
62 #include <java/lang/Byte.h>
63 #include <java/lang/Short.h>
64 #include <java/lang/Integer.h>
65 #include <java/lang/Float.h>
66 #include <java/lang/Double.h>
67 #include <java/lang/Long.h>
68 #include <java/lang/Character.h>
69 #include <java/lang/Boolean.h>
70 #include <java/lang/annotation/Annotation.h>
71 #include <java/util/HashMap.h>
72 #include <java/util/Map.h>
73 #include <sun/reflect/annotation/AnnotationInvocationHandler.h>
74 #include <java/lang/Enum.h>
75
76 #include <java-cpool.h>
77 #include <java-interp.h>
78 #include <java-assert.h>
79 #include <java-stack.h>
80 #include <execution.h>
81
82 \f
83
84 using namespace gcj;
85
86 jclass
87 java::lang::Class::forName (jstring className, jboolean initialize,
88                             java::lang::ClassLoader *loader)
89 {
90   if (! className)
91     throw new java::lang::NullPointerException;
92
93   jsize length = _Jv_GetStringUTFLength (className);
94   char buffer[length];
95   _Jv_GetStringUTFRegion (className, 0, className->length(), buffer);
96
97   _Jv_Utf8Const *name = _Jv_makeUtf8Const (buffer, length);
98
99   if (! _Jv_VerifyClassName (name))
100     throw new java::lang::ClassNotFoundException (className);
101
102   jclass klass = (buffer[0] == '[' 
103                   ? _Jv_FindClassFromSignature (name->chars(), loader)
104                   : _Jv_FindClass (name, loader));
105
106   if (klass == NULL)
107     throw new java::lang::ClassNotFoundException (className);
108
109   if (initialize)
110     _Jv_InitClass (klass);
111
112   return klass;
113 }
114
115 jclass
116 java::lang::Class::forName (jstring className)
117 {
118   java::lang::ClassLoader *loader = NULL;
119
120   jclass caller = _Jv_StackTrace::GetCallingClass (&Class::class$);
121   if (caller)
122     loader = caller->getClassLoaderInternal();
123
124   return forName (className, true, loader);
125 }
126
127 java::lang::ClassLoader *
128 java::lang::Class::getClassLoader (void)
129 {
130   java::lang::SecurityManager *s = java::lang::System::getSecurityManager();
131   if (s != NULL)
132     {
133       jclass caller = _Jv_StackTrace::GetCallingClass (&Class::class$);
134       return getClassLoader (caller);
135    }
136
137   return loader;
138 }
139
140 java::lang::ClassLoader *
141 java::lang::Class::getClassLoader (jclass caller)
142 {
143   java::lang::SecurityManager *s = java::lang::System::getSecurityManager();
144   if (s != NULL)
145     {
146       ClassLoader *caller_loader = caller->getClassLoaderInternal();
147
148       // If the caller has a non-null class loader, and that loader
149       // is not this class' loader or an ancestor thereof, then do a
150       // security check.
151       if (caller_loader != NULL && ! caller_loader->isAncestorOf(loader))
152         s->checkPermission (new RuntimePermission (JvNewStringLatin1 ("getClassLoader")));
153     }
154
155   return loader;
156 }
157
158 java::lang::reflect::Constructor *
159 java::lang::Class::getConstructor (JArray<jclass> *param_types)
160 {
161   memberAccessCheck(java::lang::reflect::Member::PUBLIC);
162
163   jstring partial_sig = getSignature (param_types, true);
164   jint hash = partial_sig->hashCode ();
165
166   int i = isPrimitive () ? 0 : method_count;
167   while (--i >= 0)
168     {
169       if (_Jv_equalUtf8Consts (methods[i].name, init_name)
170           && _Jv_equal (methods[i].signature, partial_sig, hash))
171         {
172           // Found it.  For getConstructor, the constructor must be
173           // public.
174           using namespace java::lang::reflect;
175           if (! Modifier::isPublic(methods[i].accflags))
176             break;
177           Constructor *cons = new Constructor ();
178           cons->offset = (char *) (&methods[i]) - (char *) methods;
179           cons->declaringClass = this;
180           return cons;
181         }
182     }
183   throw new java::lang::NoSuchMethodException (_Jv_NewStringUtf8Const (init_name));
184 }
185
186 JArray<java::lang::reflect::Constructor *> *
187 java::lang::Class::getDeclaredConstructors (jboolean publicOnly)
188 {
189   int numConstructors = 0;
190   int max = isPrimitive () ? 0 : method_count;
191   int i;
192   for (i = max; --i >= 0; )
193     {
194       _Jv_Method *method = &methods[i];
195       if (method->name == NULL
196           || ! _Jv_equalUtf8Consts (method->name, init_name))
197         continue;
198       if (publicOnly
199           && ! java::lang::reflect::Modifier::isPublic(method->accflags))
200         continue;
201       numConstructors++;
202     }
203   JArray<java::lang::reflect::Constructor *> *result
204     = (JArray<java::lang::reflect::Constructor *> *)
205     JvNewObjectArray (numConstructors,
206                       &java::lang::reflect::Constructor::class$,
207                       NULL);
208   java::lang::reflect::Constructor** cptr = elements (result);
209   for (i = 0;  i < max;  i++)
210     {
211       _Jv_Method *method = &methods[i];
212       if (method->name == NULL
213           || ! _Jv_equalUtf8Consts (method->name, init_name))
214         continue;
215       if (publicOnly
216           && ! java::lang::reflect::Modifier::isPublic(method->accflags))
217         continue;
218       java::lang::reflect::Constructor *cons
219         = new java::lang::reflect::Constructor ();
220       cons->offset = (char *) method - (char *) methods;
221       cons->declaringClass = this;
222       *cptr++ = cons;
223     }
224   return result;
225 }
226
227 java::lang::reflect::Constructor *
228 java::lang::Class::getDeclaredConstructor (JArray<jclass> *param_types)
229 {
230   memberAccessCheck(java::lang::reflect::Member::DECLARED);
231
232   jstring partial_sig = getSignature (param_types, true);
233   jint hash = partial_sig->hashCode ();
234
235   int i = isPrimitive () ? 0 : method_count;
236   while (--i >= 0)
237     {
238       if (_Jv_equalUtf8Consts (methods[i].name, init_name)
239           && _Jv_equal (methods[i].signature, partial_sig, hash))
240         {
241           // Found it.
242           using namespace java::lang::reflect;
243           Constructor *cons = new Constructor ();
244           cons->offset = (char *) (&methods[i]) - (char *) methods;
245           cons->declaringClass = this;
246           return cons;
247         }
248     }
249   throw new java::lang::NoSuchMethodException (_Jv_NewStringUtf8Const (init_name));
250 }
251
252 java::lang::reflect::Field *
253 java::lang::Class::getField (jstring name, jint hash)
254 {
255   java::lang::reflect::Field* rfield;
256   for (int i = 0;  i < field_count;  i++)
257     {
258       _Jv_Field *field = &fields[i];
259       if (! _Jv_equal (field->name, name, hash))
260         continue;
261       if (! (field->getModifiers() & java::lang::reflect::Modifier::PUBLIC))
262         continue;
263       rfield = new java::lang::reflect::Field ();
264       rfield->offset = (char*) field - (char*) fields;
265       rfield->declaringClass = this;
266       rfield->name = name;
267       return rfield;
268     }
269   jclass superclass = getSuperclass();
270   if (superclass == NULL)
271     return NULL;
272   rfield = superclass->getField(name, hash);
273   for (int i = 0; i < interface_count && rfield == NULL; ++i)
274     rfield = interfaces[i]->getField (name, hash);
275   return rfield;
276 }
277
278 java::lang::reflect::Field *
279 java::lang::Class::getDeclaredField (jstring name)
280 {
281   memberAccessCheck(java::lang::reflect::Member::DECLARED);
282   int hash = name->hashCode();
283   for (int i = 0;  i < field_count;  i++)
284     {
285       _Jv_Field *field = &fields[i];
286       if (! _Jv_equal (field->name, name, hash))
287         continue;
288       java::lang::reflect::Field* rfield = new java::lang::reflect::Field ();
289       rfield->offset = (char*) field - (char*) fields;
290       rfield->declaringClass = this;
291       rfield->name = name;
292       return rfield;
293     }
294   throw new java::lang::NoSuchFieldException (name);
295 }
296
297 JArray<java::lang::reflect::Field *> *
298 java::lang::Class::getDeclaredFields (jboolean public_only)
299 {
300   int size;
301   if (public_only)
302     {
303       size = 0;
304       for (int i = 0; i < field_count; ++i)
305         {
306           _Jv_Field *field = &fields[i];
307           if ((field->flags & java::lang::reflect::Modifier::PUBLIC))
308             ++size;
309         }
310     }
311   else
312     size = field_count;
313
314   JArray<java::lang::reflect::Field *> *result
315     = (JArray<java::lang::reflect::Field *> *)
316     JvNewObjectArray (size, &java::lang::reflect::Field::class$, NULL);
317   java::lang::reflect::Field** fptr = elements (result);
318   for (int i = 0;  i < field_count;  i++)
319     {
320       _Jv_Field *field = &fields[i];
321       if (public_only
322           && ! (field->flags & java::lang::reflect::Modifier::PUBLIC))
323         continue;
324       java::lang::reflect::Field* rfield = new java::lang::reflect::Field ();
325       rfield->offset = (char*) field - (char*) fields;
326       rfield->declaringClass = this;
327       *fptr++ = rfield;
328     }
329   return result;
330 }
331
332 void
333 java::lang::Class::getSignature (java::lang::StringBuffer *buffer)
334 {
335   if (isPrimitive())
336     buffer->append((jchar) method_count);
337   else
338     {
339       jstring name = getName();
340       if (name->charAt(0) != '[')
341         buffer->append((jchar) 'L');
342       buffer->append(name);
343       if (name->charAt(0) != '[')
344         buffer->append((jchar) ';');
345     }
346 }
347
348 // This doesn't have to be native.  It is an implementation detail
349 // only called from the C++ code, though, so maybe this is clearer.
350 jstring
351 java::lang::Class::getSignature (JArray<jclass> *param_types,
352                                  jboolean is_constructor)
353 {
354   java::lang::StringBuffer *buf = new java::lang::StringBuffer ();
355   buf->append((jchar) '(');
356   // A NULL param_types means "no parameters".
357   if (param_types != NULL)
358     {
359       jclass *v = elements (param_types);
360       for (int i = 0; i < param_types->length; ++i)
361         v[i]->getSignature(buf);
362     }
363   buf->append((jchar) ')');
364   if (is_constructor)
365     buf->append((jchar) 'V');
366   return buf->toString();
367 }
368
369 java::lang::reflect::Method *
370 java::lang::Class::_getDeclaredMethod (jstring name,
371                                        JArray<jclass> *param_types)
372 {
373   jstring partial_sig = getSignature (param_types, false);
374   jint p_len = partial_sig->length();
375   _Jv_Utf8Const *utf_name = _Jv_makeUtf8Const (name);
376   int i = isPrimitive () ? 0 : method_count;
377   while (--i >= 0)
378     {
379       if (_Jv_equalUtf8Consts (methods[i].name, utf_name)
380           && _Jv_equaln (methods[i].signature, partial_sig, p_len)
381           && (methods[i].accflags
382               & java::lang::reflect::Modifier::INVISIBLE) == 0)
383         {
384           // Found it.
385           using namespace java::lang::reflect;
386           Method *rmethod = new Method ();
387           rmethod->offset = (char*) (&methods[i]) - (char*) methods;
388           rmethod->declaringClass = this;
389           return rmethod;
390         }
391     }
392   return NULL;
393 }
394
395 JArray<java::lang::reflect::Method *> *
396 java::lang::Class::getDeclaredMethods (void)
397 {
398   memberAccessCheck(java::lang::reflect::Member::DECLARED);
399
400   int numMethods = 0;
401   int max = isPrimitive () ? 0 : method_count;
402   int i;
403   for (i = max; --i >= 0; )
404     {
405       _Jv_Method *method = &methods[i];
406       if (method->name == NULL
407           || _Jv_equalUtf8Consts (method->name, clinit_name)
408           || _Jv_equalUtf8Consts (method->name, init_name)
409           || _Jv_equalUtf8Consts (method->name, finit_name)
410           || (methods[i].accflags
411               & java::lang::reflect::Modifier::INVISIBLE) != 0)
412         continue;
413       numMethods++;
414     }
415   JArray<java::lang::reflect::Method *> *result
416     = (JArray<java::lang::reflect::Method *> *)
417     JvNewObjectArray (numMethods, &java::lang::reflect::Method::class$, NULL);
418   java::lang::reflect::Method** mptr = elements (result);
419   for (i = 0;  i < max;  i++)
420     {
421       _Jv_Method *method = &methods[i];
422       if (method->name == NULL
423           || _Jv_equalUtf8Consts (method->name, clinit_name)
424           || _Jv_equalUtf8Consts (method->name, init_name)
425           || _Jv_equalUtf8Consts (method->name, finit_name)
426           || (methods[i].accflags
427               & java::lang::reflect::Modifier::INVISIBLE) != 0)
428         continue;
429       java::lang::reflect::Method* rmethod
430         = new java::lang::reflect::Method ();
431       rmethod->offset = (char*) method - (char*) methods;
432       rmethod->declaringClass = this;
433       *mptr++ = rmethod;
434     }
435   return result;
436 }
437
438 jstring
439 java::lang::Class::getName (void)
440 {
441   return name->toString();
442 }
443
444 JArray<jclass> *
445 java::lang::Class::getInterfaces (void)
446 {
447   jobjectArray r = JvNewObjectArray (interface_count, getClass (), NULL);
448   jobject *data = elements (r);
449   for (int i = 0; i < interface_count; ++i)
450     {
451       typedef unsigned int uaddr __attribute__ ((mode (pointer)));
452       data[i] = interfaces[i];
453       if ((uaddr)data[i] < (uaddr)constants.size)
454         fprintf (stderr, "ERROR !!!\n");
455     }
456   return reinterpret_cast<JArray<jclass> *> (r);
457 }
458
459 java::lang::reflect::Method *
460 java::lang::Class::_getMethod (jstring name, JArray<jclass> *param_types)
461 {
462   jstring partial_sig = getSignature (param_types, false);
463   jint p_len = partial_sig->length();
464   _Jv_Utf8Const *utf_name = _Jv_makeUtf8Const (name);
465
466    for (Class *klass = this; klass; klass = klass->getSuperclass())
467     {
468       int i = klass->isPrimitive () ? 0 : klass->method_count;
469       while (--i >= 0)
470         {
471           if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name)
472               && _Jv_equaln (klass->methods[i].signature, partial_sig, p_len)
473               && (klass->methods[i].accflags
474                   & java::lang::reflect::Modifier::INVISIBLE) == 0)
475             {
476               // Found it.
477               using namespace java::lang::reflect;
478
479               // Method must be public.
480               if (! Modifier::isPublic (klass->methods[i].accflags))
481                 break;
482
483               Method *rmethod = new Method ();
484               rmethod->offset = ((char *) (&klass->methods[i])
485                                  - (char *) klass->methods);
486               rmethod->declaringClass = klass;
487               return rmethod;
488             }
489         }
490     }
491
492   // If we haven't found a match, and this class is an interface, then
493   // check all the superinterfaces.
494   if (isInterface())
495     {
496       for (int i = 0; i < interface_count; ++i)
497         {
498           using namespace java::lang::reflect;
499           Method *rmethod = interfaces[i]->_getMethod (name, param_types);
500           if (rmethod != NULL)
501             return rmethod;
502         }
503     }
504
505   return NULL;
506 }
507
508 // This is a very slow implementation, since it re-scans all the
509 // methods we've already listed to make sure we haven't duplicated a
510 // method.  It also over-estimates the required size, so we have to
511 // shrink the result array later.
512 jint
513 java::lang::Class::_getMethods (JArray<java::lang::reflect::Method *> *result,
514                                 jint offset)
515 {
516   jint count = 0;
517
518   // First examine all local methods
519   for (int i = isPrimitive () ? 0 : method_count; --i >= 0; )
520     {
521       _Jv_Method *method = &methods[i];
522       if (method->name == NULL
523           || _Jv_equalUtf8Consts (method->name, clinit_name)
524           || _Jv_equalUtf8Consts (method->name, init_name)
525           || _Jv_equalUtf8Consts (method->name, finit_name)
526           || (method->accflags
527               & java::lang::reflect::Modifier::INVISIBLE) != 0)
528         continue;
529       // Only want public methods.
530       if (! java::lang::reflect::Modifier::isPublic (method->accflags))
531         continue;
532
533       // This is where we over-count the slots required if we aren't
534       // filling the result for real.
535       if (result != NULL)
536         {
537           jboolean add = true;
538           java::lang::reflect::Method **mp = elements (result);
539           // If we already have a method with this name and signature,
540           // then ignore this one.  This can happen with virtual
541           // methods.
542           for (int j = 0; j < offset; ++j)
543             {
544               _Jv_Method *meth_2 = _Jv_FromReflectedMethod (mp[j]);
545               if (_Jv_equalUtf8Consts (method->name, meth_2->name)
546                   && _Jv_equalUtf8Consts (method->signature,
547                                           meth_2->signature))
548                 {
549                   add = false;
550                   break;
551                 }
552             }
553           if (! add)
554             continue;
555         }
556
557       if (result != NULL)
558         {
559           using namespace java::lang::reflect;
560           Method *rmethod = new Method ();
561           rmethod->offset = (char *) method - (char *) methods;
562           rmethod->declaringClass = this;
563           Method **mp = elements (result);
564           mp[offset + count] = rmethod;
565         }
566       ++count;
567     }
568   offset += count;
569
570   // Now examine superclasses.
571   if (getSuperclass () != NULL)
572     {
573       jint s_count = getSuperclass()->_getMethods (result, offset);
574       offset += s_count;
575       count += s_count;
576     }
577
578   // Finally, examine interfaces.
579   for (int i = 0; i < interface_count; ++i)
580     {
581       int f_count = interfaces[i]->_getMethods (result, offset);
582       count += f_count;
583       offset += f_count;
584     }
585
586   return count;
587 }
588
589 JArray<java::lang::reflect::Method *> *
590 java::lang::Class::getMethods (void)
591 {
592   using namespace java::lang::reflect;
593
594   memberAccessCheck(Member::PUBLIC);
595
596   // This will overestimate the size we need.
597   jint count = _getMethods (NULL, 0);
598
599   JArray<Method *> *result
600     = ((JArray<Method *> *) JvNewObjectArray (count,
601                                               &Method::class$,
602                                               NULL));
603
604   // When filling the array for real, we get the actual count.  Then
605   // we resize the array.
606   jint real_count = _getMethods (result, 0);
607
608   if (real_count != count)
609     {
610       JArray<Method *> *r2
611         = ((JArray<Method *> *) JvNewObjectArray (real_count,
612                                                   &Method::class$,
613                                                   NULL));
614       
615       Method **destp = elements (r2);
616       Method **srcp = elements (result);
617
618       for (int i = 0; i < real_count; ++i)
619         *destp++ = *srcp++;
620
621       result = r2;
622     }
623
624   return result;
625 }
626
627 jboolean
628 java::lang::Class::isAssignableFrom (jclass klass)
629 {
630   // Arguments may not have been initialized, given ".class" syntax.
631   // This ensures we can at least look at their superclasses.
632   _Jv_Linker::wait_for_state (this, JV_STATE_LOADING);
633   _Jv_Linker::wait_for_state (klass, JV_STATE_LOADING);
634   return _Jv_IsAssignableFrom (klass, this);
635 }
636
637 jboolean
638 java::lang::Class::isInstance (jobject obj)
639 {
640   if (! obj)
641     return false;
642   return _Jv_IsAssignableFrom (JV_CLASS (obj), this);
643 }
644
645 jobject
646 java::lang::Class::newInstance (void)
647 {
648   memberAccessCheck(java::lang::reflect::Member::PUBLIC);
649
650   if (isPrimitive ()
651       || isInterface ()
652       || isArray ()
653       || java::lang::reflect::Modifier::isAbstract(accflags))
654     throw new java::lang::InstantiationException (getName ());
655
656   _Jv_InitClass (this);
657
658   _Jv_Method *meth = _Jv_GetMethodLocal (this, init_name, void_signature);
659   if (! meth)
660     throw new java::lang::InstantiationException (getName());
661
662   jobject r = _Jv_AllocObject (this);
663   ((void (*) (jobject)) meth->ncode) (r);
664   return r;
665 }
666
667 void
668 java::lang::Class::finalize (void)
669 {
670   engine->unregister(this);
671 }
672
673 void
674 _Jv_ClosureList::releaseClosures (_Jv_ClosureList **closures)
675 {
676   if (!closures)
677     return;
678
679   while (_Jv_ClosureList *current = *closures)
680     {
681       *closures = current->next;
682       ffi_closure_free (current->ptr);
683     }
684 }
685
686 void
687 _Jv_ClosureList::registerClosure (jclass klass, void *ptr)
688 {
689   _Jv_ClosureList **closures = klass->engine->get_closure_list (klass);
690   this->ptr = ptr;
691   this->next = *closures;
692   *closures = this;
693 }
694
695 // This implements the initialization process for a class.  From Spec
696 // section 12.4.2.
697 void
698 java::lang::Class::initializeClass (void)
699 {
700   // Short-circuit to avoid needless locking (expression includes
701   // JV_STATE_PHANTOM and JV_STATE_DONE).
702   if (state >= JV_STATE_PHANTOM)
703     return;
704
705   // Step 1.  We introduce a new scope so we can synchronize more
706   // easily.
707   {
708     JvSynchronize sync (this);
709
710     if (state < JV_STATE_LINKED)
711       {
712         try
713           {
714             _Jv_Linker::wait_for_state(this, JV_STATE_LINKED);
715           }
716         catch (java::lang::SecurityException *x)
717           {
718             throw x;
719           }
720         catch (java::lang::Throwable *x)
721           {
722             // Turn into a NoClassDefFoundError.
723             java::lang::NoClassDefFoundError *result
724               = new java::lang::NoClassDefFoundError(getName());
725             result->initCause(x);
726             throw result;
727           }
728       }
729
730     // Step 2.
731     java::lang::Thread *self = java::lang::Thread::currentThread();
732     self = (java::lang::Thread *) ((long) self | 1);
733     while (state == JV_STATE_IN_PROGRESS && thread && thread != self)
734       wait ();
735
736     // Steps 3 &  4.
737     if (state == JV_STATE_DONE || state == JV_STATE_IN_PROGRESS)
738       return;
739
740     // Step 5.
741     if (state == JV_STATE_ERROR)
742       throw new java::lang::NoClassDefFoundError (getName());
743
744     // Step 6.
745     thread = self;
746     _Jv_Linker::wait_for_state (this, JV_STATE_LINKED);
747     state = JV_STATE_IN_PROGRESS;
748   }
749
750   // Step 7.
751   if (! isInterface () && superclass)
752     {
753       try
754         {
755           _Jv_InitClass (superclass);
756         }
757       catch (java::lang::SecurityException *x)
758         {
759           throw x;
760         }
761       catch (java::lang::Throwable *except)
762         {
763           // Caught an exception.
764           JvSynchronize sync (this);
765           state = JV_STATE_ERROR;
766           notifyAll ();
767           throw except;
768         }
769     }
770
771   // Steps 8, 9, 10, 11.
772   try
773     {
774       _Jv_Method *meth = _Jv_GetMethodLocal (this, clinit_name,
775                                              void_signature);
776       if (meth)
777         ((void (*) (void)) meth->ncode) ();
778     }
779   catch (java::lang::SecurityException *x)
780     {
781       throw x;
782     }
783   catch (java::lang::Throwable *except)
784     {
785       if (! java::lang::Error::class$.isInstance(except))
786         {
787           try
788             {
789               except = new ExceptionInInitializerError (except);
790             }
791           catch (java::lang::Throwable *t)
792             {
793               except = t;
794             }
795         }
796
797       JvSynchronize sync (this);
798       state = JV_STATE_ERROR;
799       notifyAll ();
800       throw except;
801     }
802
803   JvSynchronize sync (this);
804   state = JV_STATE_DONE;
805   notifyAll ();
806 }
807
808 // Only used by serialization
809 java::lang::reflect::Field *
810 java::lang::Class::getPrivateField (jstring name)
811 {
812   int hash = name->hashCode ();
813
814   java::lang::reflect::Field* rfield;
815   for (int i = 0;  i < field_count;  i++)
816     {
817       _Jv_Field *field = &fields[i];
818       if (! _Jv_equal (field->name, name, hash))
819         continue;
820       rfield = new java::lang::reflect::Field ();
821       rfield->offset = (char*) field - (char*) fields;
822       rfield->declaringClass = this;
823       rfield->name = name;
824       return rfield;
825     }
826   jclass superclass = getSuperclass();
827   if (superclass == NULL)
828     return NULL;
829   rfield = superclass->getPrivateField(name);
830   for (int i = 0; i < interface_count && rfield == NULL; ++i)
831     rfield = interfaces[i]->getPrivateField (name);
832   return rfield;
833 }
834
835 // Only used by serialization
836 java::lang::reflect::Method *
837 java::lang::Class::getPrivateMethod (jstring name, JArray<jclass> *param_types)
838 {
839   jstring partial_sig = getSignature (param_types, false);
840   jint p_len = partial_sig->length();
841   _Jv_Utf8Const *utf_name = _Jv_makeUtf8Const (name);
842   for (Class *klass = this; klass; klass = klass->getSuperclass())
843     {
844       int i = klass->isPrimitive () ? 0 : klass->method_count;
845       while (--i >= 0)
846         {
847           if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name)
848               && _Jv_equaln (klass->methods[i].signature, partial_sig, p_len))
849             {
850               // Found it.
851               using namespace java::lang::reflect;
852
853               Method *rmethod = new Method ();
854               rmethod->offset = ((char *) (&klass->methods[i])
855                                  - (char *) klass->methods);
856               rmethod->declaringClass = klass;
857               return rmethod;
858             }
859         }
860     }
861   throw new java::lang::NoSuchMethodException (name);
862 }
863
864 // Private accessor method for Java code to retrieve the protection domain.
865 java::security::ProtectionDomain *
866 java::lang::Class::getProtectionDomain0 ()
867 {
868   return protectionDomain;
869 }
870
871 JArray<jobject> *
872 java::lang::Class::getSigners()
873 {
874   return hack_signers;
875 }
876
877 void
878 java::lang::Class::setSigners(JArray<jobject> *s)
879 {
880   hack_signers = s;
881 }
882
883 \f
884
885 static unsigned char
886 read_u1 (unsigned char *&p)
887 {
888   return *p++;
889 }
890
891 static unsigned char
892 read_u1 (unsigned char *&p, unsigned char *next)
893 {
894   if (next - p < 1)
895     throw new java::lang::InternalError();
896   return *p++;
897 }
898
899 static unsigned int
900 read_u2 (unsigned char *&p)
901 {
902   unsigned int b1 = *p++;
903   unsigned int b2 = *p++;
904   return (b1 << 8) | b2;
905 }
906
907 static unsigned int
908 read_u2 (unsigned char *&p, unsigned char *next)
909 {
910   if (next - p < 2)
911     throw new java::lang::InternalError();
912   return read_u2 (p);
913 }
914
915 static int
916 read_4 (unsigned char *&p)
917 {
918   int b1 = *p++;
919   int b2 = *p++;
920   int b3 = *p++;
921   int b4 = *p++;
922   return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
923 }
924
925 jstring
926 java::lang::Class::getReflectionSignature (jint /*jv_attr_type*/ type,
927                                            jint obj_index)
928 {
929   // We just re-parse the bytecode for this data each time.  If
930   // necessary we can cache results, but I suspect this is not
931   // performance sensitive.
932   unsigned char *bytes = reflection_data;
933   if (bytes == NULL)
934     return NULL;
935   while (true)
936     {
937       int kind = read_u1 (bytes);
938       if (kind == JV_DONE_ATTR)
939         return NULL;
940       int len = read_4 (bytes);
941       unsigned char *next = bytes + len;
942       if (kind != type)
943         {
944           bytes = next;
945           continue;
946         }
947       if (type != JV_CLASS_ATTR)
948         {
949           unsigned short index = read_u2 (bytes, next);
950           if (index != obj_index)
951             {
952               bytes = next;
953               continue;
954             }
955         }
956       int nt = read_u1 (bytes, next);
957       if (nt != JV_SIGNATURE_KIND)
958         {
959           bytes = next;
960           continue;
961         }
962       unsigned int cpool_idx = read_u2 (bytes, next);
963       if (cpool_idx >= (unsigned int) constants.size
964           || constants.tags[cpool_idx] != JV_CONSTANT_Utf8)
965         {
966           // We just ignore errors for now.  It isn't clear what is
967           // best to do here, as an encoding error here means a bug
968           // either in the compiler or in defineclass.cc.
969           return NULL;
970         }
971       return _Jv_NewStringUtf8Const (constants.data[cpool_idx].utf8);
972     }
973 }
974
975 jstring
976 java::lang::Class::getReflectionSignature (::java::lang::reflect::Constructor *c)
977 {
978   _Jv_Method *meth = _Jv_FromReflectedConstructor (c);
979   unsigned short meth_index = meth - methods;
980   return getReflectionSignature (JV_METHOD_ATTR, meth_index);
981 }
982
983 jstring
984 java::lang::Class::getReflectionSignature (::java::lang::reflect::Method *m)
985 {
986   _Jv_Method *meth = _Jv_FromReflectedMethod (m);
987   unsigned short meth_index = meth - methods;
988   return getReflectionSignature (JV_METHOD_ATTR, meth_index);
989 }
990
991 jstring
992 java::lang::Class::getReflectionSignature (::java::lang::reflect::Field *f)
993 {
994   _Jv_Field *fld = _Jv_FromReflectedField (f);
995   unsigned short fld_index = fld - fields;
996   return getReflectionSignature (JV_FIELD_ATTR, fld_index);
997 }
998
999 jstring
1000 java::lang::Class::getClassSignature()
1001 {
1002   return getReflectionSignature (JV_CLASS_ATTR, 0);
1003 }
1004
1005 jint
1006 java::lang::Class::getEnclosingMethodData()
1007 {
1008   unsigned char *bytes = reflection_data;
1009   if (bytes == NULL)
1010     return 0;
1011   while (true)
1012     {
1013       int kind = read_u1 (bytes);
1014       if (kind == JV_DONE_ATTR)
1015         return 0;
1016       int len = read_4 (bytes);
1017       unsigned char *next = bytes + len;
1018       if (kind != JV_CLASS_ATTR)
1019         {
1020           bytes = next;
1021           continue;
1022         }
1023       int type = read_u1 (bytes, next);
1024       if (type != JV_ENCLOSING_METHOD_KIND)
1025         {
1026           bytes = next;
1027           continue;
1028         }
1029       int class_index = read_u2 (bytes, next);
1030       int method_index = read_u2 (bytes, next);
1031       _Jv_word result;
1032       _Jv_storeIndexes (&result, class_index, method_index);
1033       return result.i;
1034     }
1035 }
1036
1037 jclass
1038 java::lang::Class::getEnclosingClass()
1039 {
1040   _Jv_word indexes;
1041   indexes.i = getEnclosingMethodData();
1042   if (indexes.i == 0)
1043     return NULL;
1044   _Jv_ushort class_index, method_index;
1045   _Jv_loadIndexes (&indexes, class_index, method_index);
1046   return _Jv_Linker::resolve_pool_entry (this, class_index).clazz;
1047 }
1048
1049 ::java::lang::reflect::Method *
1050 java::lang::Class::getEnclosingMethod()
1051 {
1052   _Jv_word indexes;
1053   indexes.i = getEnclosingMethodData();
1054   if (indexes.i == 0)
1055     return NULL;
1056   _Jv_ushort class_index, method_index;
1057   _Jv_loadIndexes (&indexes, class_index, method_index);
1058   jclass found_class;
1059   _Jv_Method *method = _Jv_Linker::resolve_method_entry (this, found_class,
1060                                                          class_index,
1061                                                          method_index,
1062                                                          false, false);
1063   using namespace java::lang::reflect;
1064   Method *rmethod = new Method ();
1065   rmethod->offset = (char *) method - (char *) found_class->methods;
1066   rmethod->declaringClass = found_class;
1067   return rmethod;
1068 }
1069
1070 ::java::lang::reflect::Constructor *
1071 java::lang::Class::getEnclosingConstructor()
1072 {
1073   _Jv_word indexes;
1074   indexes.i = getEnclosingMethodData();
1075   if (indexes.i == 0)
1076     return NULL;
1077   _Jv_ushort class_index, method_index;
1078   _Jv_loadIndexes (&indexes, class_index, method_index);
1079   jclass found_class;
1080   _Jv_Method *method = _Jv_Linker::resolve_method_entry (this, found_class,
1081                                                          class_index,
1082                                                          method_index,
1083                                                          false, false);
1084   using namespace java::lang::reflect;
1085   Constructor *cons = new Constructor ();
1086   cons->offset = (char *) method - (char *) found_class->methods;
1087   cons->declaringClass = this;
1088   return cons;
1089 }
1090
1091 static void
1092 check_constant (_Jv_Constants *pool, jint cpool_index, jint type)
1093 {
1094   if (cpool_index <= 0 || cpool_index >= pool->size)
1095     throw new InternalError(JvNewStringLatin1("invalid constant pool index"));
1096   if ((pool->tags[cpool_index] & 
1097         ~(JV_CONSTANT_ResolvedFlag|JV_CONSTANT_LazyFlag)) != type)
1098     {
1099       ::java::lang::StringBuffer *sb = new ::java::lang::StringBuffer();
1100       sb->append(JvNewStringLatin1("expected pool constant "));
1101       sb->append(type);
1102       sb->append(JvNewStringLatin1(" but got "));
1103       sb->append(jint (pool->tags[cpool_index]));
1104       throw new InternalError(sb->toString());
1105     }
1106 }
1107
1108 // Forward declaration
1109 static ::java::lang::annotation::Annotation *
1110 parseAnnotation(jclass klass, _Jv_Constants *pool,
1111                 unsigned char *&bytes, unsigned char *last);
1112
1113 static jobject
1114 parseAnnotationElement(jclass klass, _Jv_Constants *pool,
1115                        unsigned char *&bytes, unsigned char *last)
1116 {
1117   int tag = read_u1 (bytes, last);
1118   jobject result;
1119   switch (tag)
1120     {
1121     case 'B':
1122       {
1123         int cindex = read_u2 (bytes, last);
1124         check_constant (pool, cindex, JV_CONSTANT_Integer);
1125         result = Byte::valueOf (pool->data[cindex].i);
1126       }
1127       break;
1128     case 'C':
1129       {
1130         int cindex = read_u2 (bytes, last);
1131         check_constant (pool, cindex, JV_CONSTANT_Integer);
1132         result = Character::valueOf (pool->data[cindex].i);
1133       }
1134       break;
1135     case 'S':
1136       {
1137         int cindex = read_u2 (bytes, last);
1138         check_constant (pool, cindex, JV_CONSTANT_Integer);
1139         result = Short::valueOf (pool->data[cindex].i);
1140       }
1141       break;
1142     case 'Z':
1143       {
1144         int cindex = read_u2 (bytes, last);
1145         check_constant (pool, cindex, JV_CONSTANT_Integer);
1146         result = Boolean::valueOf (jboolean (pool->data[cindex].i));
1147       }
1148       break;
1149     case 'I':
1150       {
1151         int cindex = read_u2 (bytes, last);
1152         check_constant (pool, cindex, JV_CONSTANT_Integer);
1153         result = Integer::valueOf (pool->data[cindex].i);
1154       }
1155       break;
1156     case 'D':
1157       {
1158         int cindex = read_u2 (bytes, last);
1159         check_constant (pool, cindex, JV_CONSTANT_Double);
1160         _Jv_word2 word;
1161         memcpy (&word, &pool->data[cindex], 2 * sizeof (_Jv_word));
1162         result = Double::valueOf (word.d);
1163       }
1164       break;
1165     case 'F':
1166       {
1167         int cindex = read_u2 (bytes, last);
1168         check_constant (pool, cindex, JV_CONSTANT_Float);
1169         result = Float::valueOf (pool->data[cindex].f);
1170       }
1171       break;
1172     case 'J':
1173       {
1174         int cindex = read_u2 (bytes, last);
1175         check_constant (pool, cindex, JV_CONSTANT_Long);
1176         _Jv_word2 word;
1177         memcpy (&word, &pool->data[cindex], 2 * sizeof (_Jv_word));
1178         result = Long::valueOf (word.l);
1179       }
1180       break;
1181     case 's':
1182       {
1183         int cindex = read_u2 (bytes, last);
1184         // Despite what the JVM spec says, compilers generate a Utf8
1185         // constant here, not a String.
1186         check_constant (pool, cindex, JV_CONSTANT_Utf8);
1187         result = pool->data[cindex].utf8->toString();
1188       }
1189       break;
1190     case 'e':
1191       {
1192         int type_name_index = read_u2 (bytes, last);
1193         check_constant (pool, type_name_index, JV_CONSTANT_Utf8);
1194         int const_name_index = read_u2 (bytes, last);
1195         check_constant (pool, const_name_index, JV_CONSTANT_Utf8);
1196
1197         _Jv_Utf8Const *u_name = pool->data[type_name_index].utf8;
1198         _Jv_Utf8Const *e_name = pool->data[const_name_index].utf8;
1199
1200         // FIXME: throw correct exceptions at the correct times.
1201         jclass e_class = _Jv_FindClassFromSignature(u_name->chars(),
1202                                                     klass->getClassLoaderInternal());
1203         result = ::java::lang::Enum::valueOf(e_class, e_name->toString());
1204       }
1205       break;
1206     case 'c':
1207       {
1208         int cindex = read_u2 (bytes, last);
1209         check_constant (pool, cindex, JV_CONSTANT_Utf8);
1210         _Jv_Utf8Const *u_name = pool->data[cindex].utf8;
1211         jclass anno_class
1212           = _Jv_FindClassFromSignatureNoException(u_name->chars(),
1213                                                   klass->getClassLoaderInternal());
1214         // FIXME: not correct: we should lazily do this when trying to
1215         // read the element.  This means that
1216         // AnnotationInvocationHandler needs to have a special case.
1217         if (! anno_class)
1218           // FIXME: original exception...
1219           throw new TypeNotPresentException(u_name->toString(), NULL);
1220         result = anno_class;
1221       }
1222       break;
1223     case '@':
1224       result = parseAnnotation (klass, pool, bytes, last);
1225       break;
1226     case '[':
1227       {
1228         int n_array_elts = read_u2 (bytes, last);
1229         jobjectArray aresult = _Jv_NewObjectArray (n_array_elts,
1230                                                    &Object::class$, NULL);
1231         jobject *elts = elements (aresult);
1232         for (int i = 0; i < n_array_elts; ++i)
1233           elts[i] = parseAnnotationElement(klass, pool, bytes, last);
1234         result = aresult;
1235       }
1236       break;
1237     default:
1238       throw new java::lang::InternalError();
1239     }
1240   return result;
1241 }
1242
1243 static ::java::lang::annotation::Annotation *
1244 parseAnnotation(jclass klass, _Jv_Constants *pool,
1245                 unsigned char *&bytes, unsigned char *last)
1246 {
1247   int type_index = read_u2 (bytes, last);
1248   check_constant (pool, type_index, JV_CONSTANT_Utf8);
1249
1250   _Jv_Utf8Const *u_name = pool->data[type_index].utf8;
1251   jclass anno_class = _Jv_FindClassFromSignatureNoException(u_name->chars(),
1252                                                             klass->getClassLoaderInternal());
1253   // FIXME: what to do if anno_class==NULL?
1254
1255   ::java::util::HashMap *hmap = new ::java::util::HashMap();
1256   int npairs = read_u2 (bytes, last);
1257   for (int i = 0; i < npairs; ++i)
1258     {
1259       int name_index = read_u2 (bytes, last);
1260       check_constant (pool, name_index, JV_CONSTANT_Utf8);
1261       jstring name = _Jv_NewStringUtf8Const (pool->data[name_index].utf8);
1262       jobject value = parseAnnotationElement (klass, pool, bytes, last);
1263       // FIXME: any checks needed for name?
1264       hmap->put(name, value);
1265     }
1266   using namespace ::sun::reflect::annotation;
1267   return AnnotationInvocationHandler::create (anno_class,
1268                                               (::java::util::Map *) hmap);
1269 }
1270
1271 static jobjectArray
1272 parseAnnotations(jclass klass, _Jv_Constants *pool,
1273                  unsigned char *&bytes, unsigned char *last)
1274 {
1275   int num = read_u2 (bytes, last);
1276   jobjectArray result = _Jv_NewObjectArray (num,
1277                                             &::java::lang::annotation::Annotation::class$,
1278                                             NULL);
1279   jobject *elts = elements (result);
1280   for (int i = 0; i < num; ++i)
1281     elts[i] = parseAnnotation(klass, pool, bytes, last);
1282   return result;
1283 }
1284
1285 static jobjectArray
1286 parseParameterAnnotations(jclass klass, _Jv_Constants *pool,
1287                           unsigned char *&bytes, unsigned char *last)
1288 {
1289   jclass anno = &::java::lang::annotation::Annotation::class$;
1290   jclass annoary = _Jv_GetArrayClass (anno, anno->getClassLoaderInternal());
1291
1292   // FIXME: something should check the number of params versus the
1293   // method
1294   int n_params = read_u1 (bytes, last);
1295   jobjectArray result = _Jv_NewObjectArray (n_params, annoary, NULL);
1296   jobject *elts = elements (result);
1297   for (int i = 0; i < n_params; ++i)
1298     elts[i] = parseAnnotations(klass, pool, bytes, last);
1299   return result;
1300 }
1301
1302 jobject
1303 java::lang::Class::getMethodDefaultValue(::java::lang::reflect::Method *meth)
1304 {
1305   // FIXME: could cache the value here...
1306
1307   unsigned char *bytes = reflection_data;
1308   if (bytes == NULL)
1309     return 0;
1310
1311   unsigned short meth_index = _Jv_FromReflectedMethod (meth) - methods;
1312
1313   while (true)
1314     {
1315       int type = read_u1 (bytes);
1316       if (type == JV_DONE_ATTR)
1317         return NULL;
1318       int len = read_4 (bytes);
1319       unsigned char *next = bytes + len;
1320       if (type != JV_METHOD_ATTR)
1321         {
1322           bytes = next;
1323           continue;
1324         }
1325       int kind = read_u1 (bytes, next);
1326       if (kind != JV_ANNOTATION_DEFAULT_KIND)
1327         {
1328           bytes = next;
1329           continue;
1330         }
1331       int index = read_u2 (bytes, next);
1332       if (meth_index != index)
1333         {
1334           bytes = next;
1335           continue;
1336         }
1337
1338       // FIXME: could cache here.  If we do then we have to clone any
1339       // array result.
1340       return parseAnnotationElement(this, &this->constants, bytes, next);
1341     }
1342 }
1343
1344 jobjectArray
1345 java::lang::Class::getDeclaredAnnotations(jint /* jv_attr_type */ member_type,
1346                                           jint member_index,
1347                                           jint /* jv_attr_kind */ kind_req)
1348 {
1349   using namespace java::lang::annotation;
1350   jobjectArray result;
1351
1352   unsigned char *bytes = reflection_data;
1353   if (bytes == NULL)
1354     return 0;
1355
1356   if (loader == NULL)
1357     loader = (ClassLoader *)VMClassLoader::bootLoader;
1358
1359   result = (loader->getDeclaredAnnotations
1360             (this, member_type, member_index, kind_req));
1361   if (result)
1362     return result;
1363
1364   for (;;)
1365     {
1366       int type = read_u1 (bytes);
1367       if (type == JV_DONE_ATTR)
1368         return NULL;
1369       int len = read_4 (bytes);
1370       unsigned char *next = bytes + len;
1371       if (type != member_type)
1372         {
1373           bytes = next;
1374           continue;
1375         }
1376       int kind = read_u1 (bytes, next);
1377       if (kind != kind_req)
1378         {
1379           bytes = next;
1380           continue;
1381         }
1382       if (member_type != JV_CLASS_ATTR)
1383         {
1384           int index = read_u2 (bytes, next);
1385           if (member_index != index)
1386             {
1387               bytes = next;
1388               continue;
1389             }
1390         }
1391
1392       if (kind_req == JV_PARAMETER_ANNOTATIONS_KIND)
1393         result = ((parseParameterAnnotations 
1394                    (this, &this->constants, bytes, next)));
1395       else
1396         result = ((parseAnnotations (this, &this->constants, bytes, next)));
1397       break;
1398     }
1399
1400   return (loader->putDeclaredAnnotations
1401           (this, member_type, member_index, kind_req, result));
1402 }
1403
1404 jobjectArray
1405 java::lang::Class::getDeclaredAnnotations(::java::lang::reflect::Method *meth,
1406                                           jboolean is_param)
1407 {
1408   unsigned short meth_index = _Jv_FromReflectedMethod (meth) - methods;
1409   return getDeclaredAnnotations(JV_METHOD_ATTR, meth_index,
1410                                 (is_param
1411                                  ? JV_PARAMETER_ANNOTATIONS_KIND
1412                                  : JV_ANNOTATIONS_KIND));
1413 }
1414
1415 jobjectArray
1416 java::lang::Class::getDeclaredAnnotations(::java::lang::reflect::Constructor *cons,
1417                                           jboolean is_param)
1418 {
1419   unsigned short meth_index = _Jv_FromReflectedConstructor (cons) - methods;
1420   return getDeclaredAnnotations(JV_METHOD_ATTR, meth_index,
1421                                 (is_param
1422                                  ? JV_PARAMETER_ANNOTATIONS_KIND
1423                                  : JV_ANNOTATIONS_KIND));
1424 }
1425
1426 jobjectArray
1427 java::lang::Class::getDeclaredAnnotations(::java::lang::reflect::Field *fld)
1428 {
1429   unsigned short field_index = _Jv_FromReflectedField (fld) - fields;
1430   return getDeclaredAnnotations(JV_FIELD_ATTR, field_index,
1431                                 JV_ANNOTATIONS_KIND);
1432 }
1433
1434 JArray< ::java::lang::annotation::Annotation *> *
1435 java::lang::Class::getDeclaredAnnotationsInternal()
1436 {
1437   return (JArray< ::java::lang::annotation::Annotation *> *) getDeclaredAnnotations(JV_CLASS_ATTR, 0, JV_ANNOTATIONS_KIND);
1438 }
1439
1440 static jclass
1441 resolve_class_constant (jclass klass, _Jv_Constants *pool, int cpool_index)
1442 {
1443   check_constant (pool, cpool_index, JV_CONSTANT_Class);
1444   // FIXME: what is the correct thing to do with an exception here?
1445   return _Jv_Linker::resolve_pool_entry (klass, cpool_index, false).clazz;
1446 }
1447
1448 jint
1449 java::lang::Class::findInnerClassAttribute()
1450 {
1451   unsigned char *bytes = reflection_data;
1452   if (bytes == NULL)
1453     return -1;
1454   while (true)
1455     {
1456       int type = read_u1 (bytes);
1457       if (type == JV_DONE_ATTR)
1458         break;
1459       // After the type but before the length.
1460       unsigned char *save = bytes;
1461       int len = read_4 (bytes);
1462       unsigned char *next = bytes + len;
1463       if (type != JV_CLASS_ATTR)
1464         {
1465           bytes = next;
1466           continue;
1467         }
1468       int kind = read_u1 (bytes, next);
1469       if (kind != JV_INNER_CLASSES_KIND)
1470         {
1471           bytes = next;
1472           continue;
1473         }
1474       return save - reflection_data;
1475     }
1476   return -1;
1477 }
1478
1479 jint
1480 java::lang::Class::findDeclaredClasses(JArray<jclass> *result,
1481                                        jboolean publicOnly,
1482                                        jint offset)
1483 {
1484   unsigned char *bytes = reflection_data + offset;
1485   int len = read_4 (bytes);
1486   unsigned char *next = bytes + len;
1487   // Skip a byte.
1488   read_u1 (bytes, next);
1489   int n_classes = read_u2 (bytes, next);
1490   int count = 0;
1491   for (int i = 0; i < n_classes; ++i)
1492     {
1493       int inner_class_index = read_u2 (bytes, next);
1494       int outer_class_index = read_u2 (bytes, next);
1495       /*int inner_name_index = */ read_u2 (bytes, next);
1496       int inner_flags = read_u2 (bytes, next);
1497
1498       if (inner_class_index == 0 || outer_class_index == 0)
1499         continue;
1500       if (resolve_class_constant (this, &constants, outer_class_index) == this)
1501         {
1502           jclass inner = resolve_class_constant (this, &constants,
1503                                                  inner_class_index);
1504           if (! publicOnly
1505               || ((inner_flags
1506                    & java::lang::reflect::Modifier::PUBLIC) != 0))
1507             {
1508               if (result)
1509                 {
1510                   jclass *elts = elements (result);
1511                   elts[count] = inner;
1512                 }
1513               ++count;
1514             }
1515         }
1516     }
1517
1518   return count;
1519 }
1520
1521 JArray<jclass> *
1522 java::lang::Class::getDeclaredClasses (jboolean publicOnly)
1523 {
1524   int offset = findInnerClassAttribute();
1525   int count;
1526   if (offset == -1)
1527     {
1528       // No InnerClasses attribute, so no declared classes.
1529       count = 0;
1530     }
1531   else
1532     count = findDeclaredClasses(NULL, publicOnly, offset);
1533   JArray<jclass> *result
1534     = (JArray<jclass> *) JvNewObjectArray (count, &java::lang::Class::class$,
1535                                            NULL);
1536   if (count > 0)
1537     findDeclaredClasses(result, publicOnly, offset);
1538   return result;
1539 }
1540
1541 jclass
1542 java::lang::Class::getDeclaringClass (void)
1543 {
1544   int offset = findInnerClassAttribute();
1545   if (offset == -1)
1546     return NULL;
1547
1548   unsigned char *bytes = reflection_data + offset;
1549   int len = read_4 (bytes);
1550   unsigned char *next = bytes + len;
1551   // Skip a byte.
1552   read_u1 (bytes, next);
1553   int n_classes = read_u2 (bytes, next);
1554   for (int i = 0; i < n_classes; ++i)
1555     {
1556       int inner_class_index = read_u2 (bytes, next);
1557       int outer_class_index = read_u2 (bytes, next);
1558       /*int inner_name_index = */read_u2 (bytes, next);
1559       /*int inner_flags = */read_u2 (bytes, next);
1560
1561       if (inner_class_index == 0 || outer_class_index == 0)
1562         continue;
1563       if (resolve_class_constant (this, &constants, inner_class_index) == this)
1564         return resolve_class_constant (this, &constants, outer_class_index);
1565     }
1566
1567   return NULL;
1568 }
1569
1570 jboolean
1571 java::lang::Class::isAnonymousClass()
1572 {
1573   int offset = findInnerClassAttribute();
1574   if (offset == -1)
1575     return false;
1576
1577   unsigned char *bytes = reflection_data + offset;
1578   int len = read_4 (bytes);
1579   unsigned char *next = bytes + len;
1580   // Skip a byte.
1581   read_u1 (bytes, next);
1582   int n_classes = read_u2 (bytes, next);
1583   for (int i = 0; i < n_classes; ++i)
1584     {
1585       int inner_class_index = read_u2 (bytes, next);
1586       /*int outer_class_index = */read_u2 (bytes, next);
1587       int inner_name_index = read_u2 (bytes, next);
1588       /*int inner_flags = */read_u2 (bytes, next);
1589
1590       if (inner_class_index == 0)
1591         continue;
1592       if (resolve_class_constant (this, &constants, inner_class_index) == this)
1593         return inner_name_index == 0;
1594     }
1595
1596   return false;
1597 }
1598
1599 jboolean
1600 java::lang::Class::isLocalClass()
1601 {
1602   _Jv_word indexes;
1603   indexes.i = getEnclosingMethodData();
1604   return indexes.i != 0;
1605 }
1606
1607 jboolean
1608 java::lang::Class::isMemberClass()
1609 {
1610   // FIXME: is this correct?
1611   return !isLocalClass() && getDeclaringClass() != NULL;
1612 }
1613
1614 \f
1615
1616 //
1617 // Some class-related convenience functions.
1618 //
1619
1620 // Find a method declared in the class.  If it is not declared locally
1621 // (or if it is inherited), return NULL.
1622 _Jv_Method *
1623 _Jv_GetMethodLocal (jclass klass, _Jv_Utf8Const *name,
1624                     _Jv_Utf8Const *signature)
1625 {
1626   for (int i = 0; i < klass->method_count; ++i)
1627     {
1628       if (_Jv_equalUtf8Consts (name, klass->methods[i].name)
1629           && _Jv_equalUtf8Consts (signature, klass->methods[i].signature))
1630         return &klass->methods[i];
1631     }
1632   return NULL;
1633 }
1634
1635 _Jv_Method *
1636 _Jv_LookupDeclaredMethod (jclass klass, _Jv_Utf8Const *name,
1637                           _Jv_Utf8Const *signature,
1638                           jclass *declarer_result)
1639 {
1640   for (; klass; klass = klass->getSuperclass())
1641     {
1642       _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature);
1643
1644       if (meth)
1645         {
1646           if (declarer_result)
1647             *declarer_result = klass;
1648           return meth;
1649         }
1650     }
1651
1652   return NULL;
1653 }
1654
1655 java::lang::reflect::Method *
1656 _Jv_GetReflectedMethod (jclass klass, _Jv_Utf8Const *name,
1657                        _Jv_Utf8Const *signature)
1658 {
1659   for (; klass; klass = klass->getSuperclass())
1660     {
1661       _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature);
1662       if (meth)
1663         {
1664           using namespace java::lang::reflect;
1665           Method *rmethod = new Method ();
1666           rmethod->offset = (char*) meth - (char*) klass->methods;
1667           rmethod->declaringClass = klass;
1668           return rmethod;
1669         }
1670     }
1671   
1672   return NULL;
1673 }
1674
1675 #ifdef HAVE_TLS
1676
1677 // NOTE: MCACHE_SIZE should be a power of 2 minus one.
1678 #define MCACHE_SIZE 31
1679
1680 struct _Jv_mcache
1681 {
1682   jclass klass;
1683   _Jv_Method *method;
1684 };
1685
1686 static __thread _Jv_mcache *method_cache;
1687 #endif // HAVE_TLS
1688
1689 static void *
1690 _Jv_FindMethodInCache (jclass klass MAYBE_UNUSED,
1691                        _Jv_Utf8Const *name MAYBE_UNUSED,
1692                        _Jv_Utf8Const *signature MAYBE_UNUSED)
1693 {
1694 #ifdef HAVE_TLS
1695   _Jv_mcache *cache = method_cache;
1696   if (cache)
1697     {
1698       int index = name->hash16 () & MCACHE_SIZE;
1699       _Jv_mcache *mc = &cache[index];
1700       _Jv_Method *m = mc->method;
1701
1702       if (mc->klass == klass
1703           && _Jv_equalUtf8Consts (m->name, name)
1704           && _Jv_equalUtf8Consts (m->signature, signature))
1705         return mc->method->ncode;
1706     }
1707 #endif // HAVE_TLS
1708   return NULL;
1709 }
1710
1711 static void
1712 _Jv_AddMethodToCache (jclass klass MAYBE_UNUSED,
1713                       _Jv_Method *method MAYBE_UNUSED)
1714 {
1715 #ifdef HAVE_TLS
1716   if (method_cache == NULL)
1717     method_cache = (_Jv_mcache *) _Jv_MallocUnchecked((MCACHE_SIZE + 1)
1718                                                       * sizeof (_Jv_mcache));
1719   // If the allocation failed, just keep going.
1720   if (method_cache != NULL)
1721     {
1722       int index = method->name->hash16 () & MCACHE_SIZE;
1723       method_cache[index].method = method;
1724       method_cache[index].klass = klass;
1725     }
1726 #endif // HAVE_TLS
1727 }
1728
1729 // Free this thread's method cache.  We explicitly manage this memory
1730 // as the GC does not yet know how to scan TLS on all platforms.
1731 void
1732 _Jv_FreeMethodCache ()
1733 {
1734 #ifdef HAVE_TLS
1735   if (method_cache != NULL)
1736     {
1737       _Jv_Free(method_cache);
1738       method_cache = NULL;
1739     }
1740 #endif // HAVE_TLS
1741 }
1742
1743 void *
1744 _Jv_LookupInterfaceMethod (jclass klass, _Jv_Utf8Const *name,
1745                            _Jv_Utf8Const *signature)
1746 {
1747   using namespace java::lang::reflect;
1748
1749   void *ncode = _Jv_FindMethodInCache (klass, name, signature);
1750   if (ncode != 0)
1751     return ncode;
1752
1753   for (; klass; klass = klass->getSuperclass())
1754     {
1755       _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature);
1756       if (! meth)
1757         continue;
1758
1759       if (Modifier::isStatic(meth->accflags))
1760         throw new java::lang::IncompatibleClassChangeError
1761           (_Jv_GetMethodString (klass, meth));
1762       if (Modifier::isAbstract(meth->accflags))
1763         throw new java::lang::AbstractMethodError
1764           (_Jv_GetMethodString (klass, meth));
1765       if (! Modifier::isPublic(meth->accflags))
1766         throw new java::lang::IllegalAccessError
1767           (_Jv_GetMethodString (klass, meth));
1768
1769       _Jv_AddMethodToCache (klass, meth);
1770
1771       return meth->ncode;
1772     }
1773   throw new java::lang::IncompatibleClassChangeError;
1774 }
1775
1776 // Fast interface method lookup by index.
1777 void *
1778 _Jv_LookupInterfaceMethodIdx (jclass klass, jclass iface, int method_idx)
1779 {
1780   _Jv_IDispatchTable *cldt = klass->idt;
1781   int idx = iface->ioffsets[cldt->iindex] + method_idx;
1782   return cldt->itable[idx];
1783 }
1784
1785 jboolean
1786 _Jv_IsAssignableFrom (jclass source, jclass target)
1787 {
1788   if (source == target)
1789     return true;
1790
1791   // If target is array, so must source be.  
1792   while (target->isArray ())
1793     {
1794       if (! source->isArray())
1795         return false;
1796       target = target->getComponentType();
1797       source = source->getComponentType();
1798     }
1799
1800   if (target->isInterface())
1801     {
1802       // Abstract classes have no IDT, and IDTs provide no way to check
1803       // two interfaces for assignability.
1804       if (__builtin_expect 
1805           (source->idt == NULL || source->isInterface(), false))
1806         return _Jv_InterfaceAssignableFrom (source, target);
1807
1808       _Jv_IDispatchTable *cl_idt = source->idt;
1809
1810       if (__builtin_expect ((target->ioffsets == NULL), false))
1811         return false; // No class implementing TARGET has been loaded.    
1812       jshort cl_iindex = cl_idt->iindex;
1813       if (cl_iindex < target->ioffsets[0])
1814         {
1815           jshort offset = target->ioffsets[cl_iindex];
1816           if (offset != -1 && offset < cl_idt->itable_length
1817               && cl_idt->itable[offset] == target)
1818             return true;
1819         }
1820       return false;
1821     }
1822
1823   // Primitive TYPE classes are only assignable to themselves.
1824   if (__builtin_expect (target->isPrimitive() || source->isPrimitive(), false))
1825     return false;
1826
1827   if (target == &java::lang::Object::class$)
1828     return true;
1829   else if (source->ancestors == NULL || target->ancestors == NULL)
1830     {
1831       // We need this case when either SOURCE or TARGET has not has
1832       // its constant-time tables prepared.
1833
1834       // At this point we know that TARGET can't be Object, so it is
1835       // safe to use that as the termination point.
1836       while (source && source != &java::lang::Object::class$)
1837         {
1838           if (source == target)
1839             return true;
1840           source = source->getSuperclass();
1841         }
1842     }
1843   else if (source->depth >= target->depth
1844            && source->ancestors[source->depth - target->depth] == target)
1845     return true;
1846
1847   return false;
1848 }
1849
1850 // Interface type checking, the slow way. Returns TRUE if IFACE is a 
1851 // superinterface of SOURCE. This is used when SOURCE is also an interface,
1852 // or a class with no interface dispatch table.
1853 jboolean
1854 _Jv_InterfaceAssignableFrom (jclass source, jclass iface)
1855 {
1856   for (int i = 0; i < source->interface_count; i++)
1857     {
1858       jclass interface = source->interfaces[i];
1859       if (iface == interface
1860           || _Jv_InterfaceAssignableFrom (interface, iface))
1861         return true;      
1862     }
1863     
1864   if (!source->isInterface()
1865       && source->superclass 
1866       && _Jv_InterfaceAssignableFrom (source->superclass, iface))
1867     return true;
1868         
1869   return false;
1870 }
1871
1872 jboolean
1873 _Jv_IsInstanceOf(jobject obj, jclass cl)
1874 {
1875   if (__builtin_expect (!obj, false))
1876     return false;
1877   return _Jv_IsAssignableFrom (JV_CLASS (obj), cl);
1878 }
1879
1880 void *
1881 _Jv_CheckCast (jclass c, jobject obj)
1882 {
1883   if (__builtin_expect 
1884       (obj != NULL && ! _Jv_IsAssignableFrom(JV_CLASS (obj), c), false))
1885     throw new java::lang::ClassCastException
1886       ((new java::lang::StringBuffer
1887         (obj->getClass()->getName()))->append
1888        (JvNewStringUTF(" cannot be cast to "))->append
1889        (c->getName())->toString());
1890
1891   return obj;
1892 }
1893
1894 void
1895 _Jv_CheckArrayStore (jobject arr, jobject obj)
1896 {
1897   if (obj)
1898     {
1899       JvAssert (arr != NULL);
1900       jclass elt_class = (JV_CLASS (arr))->getComponentType();
1901       if (elt_class == &java::lang::Object::class$)
1902         return;
1903       jclass obj_class = JV_CLASS (obj);
1904       if (__builtin_expect 
1905           (! _Jv_IsAssignableFrom (obj_class, elt_class), false))
1906         throw new java::lang::ArrayStoreException
1907                 ((new java::lang::StringBuffer
1908                  (JvNewStringUTF("Cannot store ")))->append
1909                  (obj_class->getName())->append
1910                  (JvNewStringUTF(" in array of type "))->append
1911                  (elt_class->getName())->toString());
1912     }
1913 }
1914
1915 jboolean
1916 _Jv_IsAssignableFromSlow (jclass source, jclass target)
1917 {
1918   // First, strip arrays.
1919   while (target->isArray ())
1920     {
1921       // If target is array, source must be as well.
1922       if (! source->isArray ())
1923        return false;
1924       target = target->getComponentType ();
1925       source = source->getComponentType ();
1926     }
1927
1928   // Quick success.
1929   if (target == &java::lang::Object::class$)
1930     return true;
1931
1932   // Ensure that the classes have their supers installed.
1933   _Jv_Linker::wait_for_state (source, JV_STATE_LOADING);
1934   _Jv_Linker::wait_for_state (target, JV_STATE_LOADING);
1935
1936   do
1937     {
1938       if (source == target)
1939        return true;
1940
1941       if (target->isPrimitive () || source->isPrimitive ())
1942        return false;
1943
1944       if (target->isInterface ())
1945        {
1946          for (int i = 0; i < source->interface_count; ++i)
1947            {
1948              // We use a recursive call because we also need to
1949              // check superinterfaces.
1950              if (_Jv_IsAssignableFromSlow (source->getInterface (i), target))
1951                return true;
1952            }
1953        }
1954       source = source->getSuperclass ();
1955     }
1956   while (source != NULL);
1957
1958   return false;
1959 }
1960
1961 // Lookup an interface method by name.  This is very similar to
1962 // purpose to _getMethod, but the interfaces are quite different.  It
1963 // might be a good idea for _getMethod to call this function.
1964 //
1965 // Return true of the method is found, with the class in FOUND_CLASS
1966 // and the index in INDEX.
1967 bool
1968 _Jv_getInterfaceMethod (jclass search_class, jclass &found_class, int &index,
1969                         const _Jv_Utf8Const *utf_name,  
1970                         const _Jv_Utf8Const *utf_sig)
1971 {
1972    for (jclass klass = search_class; klass; klass = klass->getSuperclass())
1973     {
1974       // FIXME: Throw an exception?
1975       if (!klass->isInterface ())
1976         return false;
1977       
1978       int max = klass->method_count;
1979       int offset = 0;
1980       for (int i = 0; i < max; ++i)
1981         {
1982           // Skip <clinit> here, as it will not be in the IDT.
1983           if (klass->methods[i].name->first() == '<')
1984             continue;
1985
1986           if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name)
1987               && _Jv_equalUtf8Consts (klass->methods[i].signature, utf_sig))
1988             {
1989               // Found it.
1990               using namespace java::lang::reflect;
1991
1992               // FIXME: Method must be public.  Throw an exception?
1993               if (! Modifier::isPublic (klass->methods[i].accflags))
1994                 break;
1995
1996               found_class = klass;
1997               // Interface method indexes count from 1.
1998               index = offset + 1;
1999               return true;
2000             }
2001
2002           ++offset;
2003         }
2004     }
2005
2006   // If we haven't found a match, and this class is an interface, then
2007   // check all the superinterfaces.
2008   if (search_class->isInterface())
2009     {
2010       for (int i = 0; i < search_class->interface_count; ++i)
2011         {
2012           using namespace java::lang::reflect;
2013           bool found = _Jv_getInterfaceMethod (search_class->interfaces[i], 
2014                                                found_class, index,
2015                                                utf_name, utf_sig);
2016           if (found)
2017             return true;
2018         }
2019     }
2020
2021   return false;
2022 }
2023
2024 #ifdef INTERPRETER
2025 _Jv_MethodBase *
2026 _Jv_FindInterpreterMethod (jclass klass, jmethodID desired_method)
2027 {
2028   using namespace java::lang::reflect;
2029
2030   _Jv_InterpClass *iclass
2031     = reinterpret_cast<_Jv_InterpClass *> (klass->aux_info);
2032   _Jv_MethodBase **imethods = _Jv_GetFirstMethod (iclass);
2033
2034   for (int i = 0; i < JvNumMethods (klass); ++i)
2035     {
2036       _Jv_MethodBase *imeth = imethods[i];
2037       if (imeth->get_method () == desired_method)
2038         return imeth;
2039     }
2040
2041   return NULL;
2042 }
2043 #endif
2044
2045 // Return Utf8 name of a class. This function is here for code that
2046 // can't access klass->name directly.
2047 _Jv_Utf8Const*
2048 _Jv_GetClassNameUtf8 (jclass klass)
2049 {
2050   return klass->name;
2051 }
2052
2053 jclass
2054 _Jv_GetMethodDeclaringClass (jmethodID method)
2055 {
2056   _Jv_StackTrace::UpdateNCodeMap ();
2057   jobject obj = reinterpret_cast<jobject> (method->ncode);
2058   return reinterpret_cast<jclass> (_Jv_StackTrace::ncodeMap->get (obj));
2059 }
2060
2061 jbyte
2062 _Jv_GetClassState (jclass klass)
2063 {
2064   return klass->state;
2065 }
2066
2067 jstring
2068 _Jv_GetInterpClassSourceFile (jclass klass)
2069 {
2070   if (_Jv_IsInterpretedClass (klass))
2071     {
2072       _Jv_InterpClass *iclass =
2073         reinterpret_cast<_Jv_InterpClass *> (klass->aux_info);
2074       return iclass->source_file_name;
2075     }
2076
2077   return NULL;
2078 }