1 // link.cc - Code for linking and resolving classes and pool entries.
3 /* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation
5 This file is part of libgcj.
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
11 /* Author: Kresten Krab Thorup <krab@gnu.org> */
18 #include <java-interp.h>
24 #include <java-cpool.h>
25 #include <execution.h>
26 #include <java/lang/Class.h>
27 #include <java/lang/String.h>
28 #include <java/lang/StringBuffer.h>
29 #include <java/lang/Thread.h>
30 #include <java/lang/InternalError.h>
31 #include <java/lang/VirtualMachineError.h>
32 #include <java/lang/VerifyError.h>
33 #include <java/lang/NoSuchFieldError.h>
34 #include <java/lang/NoSuchMethodError.h>
35 #include <java/lang/ClassFormatError.h>
36 #include <java/lang/IllegalAccessError.h>
37 #include <java/lang/InternalError.h>
38 #include <java/lang/AbstractMethodError.h>
39 #include <java/lang/NoClassDefFoundError.h>
40 #include <java/lang/IncompatibleClassChangeError.h>
41 #include <java/lang/VerifyError.h>
42 #include <java/lang/VMClassLoader.h>
43 #include <java/lang/reflect/Modifier.h>
44 #include <java/security/CodeSource.h>
48 typedef unsigned int uaddr __attribute__ ((mode (pointer)));
57 #define ALIGNOF(TYPE) (offsetof (aligner<TYPE>, field))
59 // This returns the alignment of a type as it would appear in a
60 // structure. This can be different from the alignment of the type
61 // itself. For instance on x86 double is 8-aligned but struct{double}
64 _Jv_Linker::get_alignment_from_class (jclass klass)
66 if (klass == JvPrimClass (byte))
67 return ALIGNOF (jbyte);
68 else if (klass == JvPrimClass (short))
69 return ALIGNOF (jshort);
70 else if (klass == JvPrimClass (int))
71 return ALIGNOF (jint);
72 else if (klass == JvPrimClass (long))
73 return ALIGNOF (jlong);
74 else if (klass == JvPrimClass (boolean))
75 return ALIGNOF (jboolean);
76 else if (klass == JvPrimClass (char))
77 return ALIGNOF (jchar);
78 else if (klass == JvPrimClass (float))
79 return ALIGNOF (jfloat);
80 else if (klass == JvPrimClass (double))
81 return ALIGNOF (jdouble);
83 return ALIGNOF (jobject);
87 _Jv_Linker::resolve_field (_Jv_Field *field, java::lang::ClassLoader *loader)
89 if (! field->isResolved ())
91 _Jv_Utf8Const *sig = (_Jv_Utf8Const *) field->type;
92 jclass type = _Jv_FindClassFromSignature (sig->chars(), loader);
94 throw new java::lang::NoClassDefFoundError(field->name->toString());
96 field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
100 // A helper for find_field that knows how to recursively search
101 // superclasses and interfaces.
103 _Jv_Linker::find_field_helper (jclass search, _Jv_Utf8Const *name,
104 _Jv_Utf8Const *type_name, jclass type,
109 // From 5.4.3.2. First search class itself.
110 for (int i = 0; i < search->field_count; ++i)
112 _Jv_Field *field = &search->fields[i];
113 if (! _Jv_equalUtf8Consts (field->name, name))
116 // Checks for the odd situation where we were able to retrieve the
117 // field's class from signature but the resolution of the field itself
118 // failed which means a different class was resolved.
123 resolve_field (field, search->loader);
125 catch (java::lang::Throwable *exc)
127 java::lang::LinkageError *le = new java::lang::LinkageError
129 ("field type mismatch with different loaders"));
137 // Note that we compare type names and not types. This is
138 // bizarre, but we do it because we want to find a field
139 // (and terminate the search) if it has the correct
140 // descriptor -- but then later reject it if the class
141 // loader check results in different classes. We can't just
142 // pass in the descriptor and check that way, because when
143 // the field is already resolved there is no easy way to
144 // find its descriptor again.
145 if ( (field->isResolved () ?
146 _Jv_equalUtf8Classnames (type_name, field->type->name) :
147 _Jv_equalUtf8Classnames (
148 type_name, (_Jv_Utf8Const *) field->type)) )
155 // Next search direct interfaces.
156 for (int i = 0; i < search->interface_count; ++i)
158 _Jv_Field *result = find_field_helper (search->interfaces[i], name,
159 type_name, type, declarer);
164 // Now search superclass.
165 search = search->superclass;
172 _Jv_Linker::has_field_p (jclass search, _Jv_Utf8Const *field_name)
174 for (int i = 0; i < search->field_count; ++i)
176 _Jv_Field *field = &search->fields[i];
177 if (_Jv_equalUtf8Consts (field->name, field_name))
184 // KLASS is the class that is requesting the field.
185 // OWNER is the class in which the field should be found.
186 // FIELD_TYPE_NAME is the type descriptor for the field.
187 // Fill FOUND_CLASS with the address of the class in which the field
188 // is actually declared.
189 // This function does the class loader type checks, and
190 // also access checks. Returns the field, or throws an
191 // exception on error.
193 _Jv_Linker::find_field (jclass klass, jclass owner,
195 _Jv_Utf8Const *field_name,
196 _Jv_Utf8Const *field_type_name)
198 // FIXME: this allocates a _Jv_Utf8Const each time. We should make
200 // Note: This call will resolve the primitive type names ("Z", "B", ...) to
201 // their Java counterparts ("boolean", "byte", ...) if accessed via
202 // field_type->name later. Using these variants of the type name is in turn
203 // important for the find_field_helper function. However if the class
204 // resolution failed then we can only use the already given type name.
206 = _Jv_FindClassFromSignatureNoException (field_type_name->chars(),
210 = find_field_helper (owner, field_name,
214 field_type, found_class);
218 java::lang::StringBuffer *sb = new java::lang::StringBuffer();
219 sb->append(JvNewStringLatin1("field "));
220 sb->append(owner->getName());
221 sb->append(JvNewStringLatin1("."));
222 sb->append(_Jv_NewStringUTF(field_name->chars()));
223 sb->append(JvNewStringLatin1(" was not found."));
224 throw new java::lang::NoSuchFieldError (sb->toString());
227 // Accept it when the field's class could not be resolved.
228 if (field_type == NULL)
229 // Silently ignore that we were not able to retrieve the type to make it
230 // possible to run code which does not access this field.
233 if (_Jv_CheckAccess (klass, *found_class, the_field->flags))
235 // Note that the field returned by find_field_helper is always
236 // resolved. There's no point checking class loaders here,
237 // since we already did the work to look up all the types.
238 // FIXME: being lazy here would be nice.
239 if (the_field->type != field_type)
240 throw new java::lang::LinkageError
242 ("field type mismatch with different loaders"));
246 java::lang::StringBuffer *sb
247 = new java::lang::StringBuffer ();
248 sb->append(klass->getName());
249 sb->append(JvNewStringLatin1(": "));
250 sb->append((*found_class)->getName());
251 sb->append(JvNewStringLatin1("."));
252 sb->append(_Jv_NewStringUtf8Const (field_name));
253 throw new java::lang::IllegalAccessError(sb->toString());
260 _Jv_Linker::resolve_pool_entry (jclass klass, int index, bool lazy)
262 using namespace java::lang::reflect;
264 _Jv_Constants *pool = &klass->constants;
266 if ((pool->tags[index] & JV_CONSTANT_ResolvedFlag) != 0)
267 return pool->data[index];
269 switch (pool->tags[index])
271 case JV_CONSTANT_Class:
273 _Jv_Utf8Const *name = pool->data[index].utf8;
276 if (name->first() == '[')
277 found = _Jv_FindClassFromSignatureNoException (name->chars(),
280 found = _Jv_FindClassNoException (name, klass->loader);
282 // If the class could not be loaded a phantom class is created. Any
283 // function that deals with such a class but cannot do something useful
284 // with it should just throw a NoClassDefFoundError with the class'
289 found = _Jv_NewClass(name, NULL, NULL);
290 found->state = JV_STATE_PHANTOM;
291 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
292 pool->data[index].clazz = found;
296 throw new java::lang::NoClassDefFoundError (name->toString());
298 // Check accessibility, but first strip array types as
299 // _Jv_ClassNameSamePackage can't handle arrays.
302 check && check->isArray();
303 check = check->getComponentType())
305 if ((found->accflags & Modifier::PUBLIC) == Modifier::PUBLIC
306 || (_Jv_ClassNameSamePackage (check->name,
309 pool->data[index].clazz = found;
310 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
314 java::lang::StringBuffer *sb = new java::lang::StringBuffer ();
315 sb->append(klass->getName());
316 sb->append(JvNewStringLatin1(" can't access class "));
317 sb->append(found->getName());
318 throw new java::lang::IllegalAccessError(sb->toString());
323 case JV_CONSTANT_String:
326 str = _Jv_NewStringUtf8Const (pool->data[index].utf8);
327 pool->data[index].o = str;
328 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
332 case JV_CONSTANT_Fieldref:
334 _Jv_ushort class_index, name_and_type_index;
335 _Jv_loadIndexes (&pool->data[index],
337 name_and_type_index);
338 jclass owner = (resolve_pool_entry (klass, class_index, true)).clazz;
340 // If a phantom class was resolved our field reference is
341 // unusable because of the missing class.
342 if (owner->state == JV_STATE_PHANTOM)
343 throw new java::lang::NoClassDefFoundError(owner->getName());
346 _Jv_InitClass (owner);
348 _Jv_ushort name_index, type_index;
349 _Jv_loadIndexes (&pool->data[name_and_type_index],
353 _Jv_Utf8Const *field_name = pool->data[name_index].utf8;
354 _Jv_Utf8Const *field_type_name = pool->data[type_index].utf8;
356 jclass found_class = 0;
357 _Jv_Field *the_field = find_field (klass, owner,
361 if (owner != found_class)
362 _Jv_InitClass (found_class);
363 pool->data[index].field = the_field;
364 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
368 case JV_CONSTANT_Methodref:
369 case JV_CONSTANT_InterfaceMethodref:
371 _Jv_ushort class_index, name_and_type_index;
372 _Jv_loadIndexes (&pool->data[index],
374 name_and_type_index);
375 jclass owner = (resolve_pool_entry (klass, class_index)).clazz;
378 _Jv_InitClass (owner);
380 _Jv_ushort name_index, type_index;
381 _Jv_loadIndexes (&pool->data[name_and_type_index],
385 _Jv_Utf8Const *method_name = pool->data[name_index].utf8;
386 _Jv_Utf8Const *method_signature = pool->data[type_index].utf8;
388 _Jv_Method *the_method = 0;
389 jclass found_class = 0;
391 // We're going to cache a pointer to the _Jv_Method object
392 // when we find it. So, to ensure this doesn't get moved from
393 // beneath us, we first put all the needed Miranda methods
394 // into the target class.
395 wait_for_state (klass, JV_STATE_LOADED);
397 // First search the class itself.
398 the_method = search_method_in_class (owner, klass,
399 method_name, method_signature);
404 goto end_of_method_search;
407 // If we are resolving an interface method, search the
408 // interface's superinterfaces (A superinterface is not an
409 // interface's superclass - a superinterface is implemented by
411 if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref)
416 ifaces.list = (jclass *) _Jv_Malloc (ifaces.len
417 * sizeof (jclass *));
419 get_interfaces (owner, &ifaces);
421 for (int i = 0; i < ifaces.count; i++)
423 jclass cls = ifaces.list[i];
424 the_method = search_method_in_class (cls, klass, method_name,
433 _Jv_Free (ifaces.list);
436 goto end_of_method_search;
439 // Finally, search superclasses.
440 for (jclass cls = owner->getSuperclass (); cls != 0;
441 cls = cls->getSuperclass ())
443 the_method = search_method_in_class (cls, klass, method_name,
452 end_of_method_search:
454 // FIXME: if (cls->loader != klass->loader), then we
455 // must actually check that the types of arguments
456 // correspond. That is, for each argument type, and
457 // the return type, doing _Jv_FindClassFromSignature
458 // with either loader should produce the same result,
459 // i.e., exactly the same jclass object. JVMS 5.4.3.3
463 java::lang::StringBuffer *sb = new java::lang::StringBuffer();
464 sb->append(JvNewStringLatin1("method "));
465 sb->append(owner->getName());
466 sb->append(JvNewStringLatin1("."));
467 sb->append(_Jv_NewStringUTF(method_name->chars()));
468 sb->append(JvNewStringLatin1(" with signature "));
469 sb->append(_Jv_NewStringUTF(method_signature->chars()));
470 sb->append(JvNewStringLatin1(" was not found."));
471 throw new java::lang::NoSuchMethodError (sb->toString());
474 int vtable_index = -1;
475 if (pool->tags[index] != JV_CONSTANT_InterfaceMethodref)
476 vtable_index = (jshort)the_method->index;
478 pool->data[index].rmethod
479 = klass->engine->resolve_method(the_method,
481 ((the_method->accflags
482 & Modifier::STATIC) != 0),
484 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
488 return pool->data[index];
491 // This function is used to lazily locate superclasses and
492 // superinterfaces. This must be called with the class lock held.
494 _Jv_Linker::resolve_class_ref (jclass klass, jclass *classref)
496 jclass ret = *classref;
498 // If superclass looks like a constant pool entry, resolve it now.
499 if (ret && (uaddr) ret < (uaddr) klass->constants.size)
501 if (klass->state < JV_STATE_LINKED)
503 _Jv_Utf8Const *name = klass->constants.data[(uaddr) *classref].utf8;
504 ret = _Jv_FindClass (name, klass->loader);
507 throw new java::lang::NoClassDefFoundError (name->toString());
511 ret = klass->constants.data[(uaddr) classref].clazz;
516 // Find a method declared in the cls that is referenced from klass and
517 // perform access checks.
519 _Jv_Linker::search_method_in_class (jclass cls, jclass klass,
520 _Jv_Utf8Const *method_name,
521 _Jv_Utf8Const *method_signature)
523 using namespace java::lang::reflect;
525 for (int i = 0; i < cls->method_count; i++)
527 _Jv_Method *method = &cls->methods[i];
528 if ( (!_Jv_equalUtf8Consts (method->name,
530 || (!_Jv_equalUtf8Consts (method->signature,
534 if (_Jv_CheckAccess (klass, cls, method->accflags))
538 java::lang::StringBuffer *sb = new java::lang::StringBuffer();
539 sb->append(klass->getName());
540 sb->append(JvNewStringLatin1(": "));
541 sb->append(cls->getName());
542 sb->append(JvNewStringLatin1("."));
543 sb->append(_Jv_NewStringUTF(method_name->chars()));
544 sb->append(_Jv_NewStringUTF(method_signature->chars()));
545 throw new java::lang::IllegalAccessError (sb->toString());
552 #define INITIAL_IOFFSETS_LEN 4
553 #define INITIAL_IFACES_LEN 4
555 static _Jv_IDispatchTable null_idt = { {SHRT_MAX, 0, NULL} };
557 // Generate tables for constant-time assignment testing and interface
558 // method lookup. This implements the technique described by Per Bothner
559 // <per@bothner.com> on the java-discuss mailing list on 1999-09-02:
560 // http://gcc.gnu.org/ml/java/1999-q3/msg00377.html
562 _Jv_Linker::prepare_constant_time_tables (jclass klass)
564 if (klass->isPrimitive () || klass->isInterface ())
567 // Short-circuit in case we've been called already.
568 if ((klass->idt != NULL) || klass->depth != 0)
571 // Calculate the class depth and ancestor table. The depth of a class
572 // is how many "extends" it is removed from Object. Thus the depth of
573 // java.lang.Object is 0, but the depth of java.io.FilterOutputStream
574 // is 2. Depth is defined for all regular and array classes, but not
575 // interfaces or primitive types.
577 jclass klass0 = klass;
578 jboolean has_interfaces = 0;
579 while (klass0 != &java::lang::Object::class$)
581 has_interfaces += klass0->interface_count;
582 klass0 = klass0->superclass;
586 // We do class member testing in constant time by using a small table
587 // of all the ancestor classes within each class. The first element is
588 // a pointer to the current class, and the rest are pointers to the
589 // classes ancestors, ordered from the current class down by decreasing
590 // depth. We do not include java.lang.Object in the table of ancestors,
591 // since it is redundant.
593 // FIXME: _Jv_AllocBytes
594 klass->ancestors = (jclass *) _Jv_Malloc (klass->depth
597 for (int index = 0; index < klass->depth; index++)
599 klass->ancestors[index] = klass0;
600 klass0 = klass0->superclass;
603 if ((klass->accflags & java::lang::reflect::Modifier::ABSTRACT) != 0)
606 // Optimization: If class implements no interfaces, use a common
607 // predefined interface table.
610 klass->idt = &null_idt;
614 // FIXME: _Jv_AllocBytes
616 (_Jv_IDispatchTable *) _Jv_Malloc (sizeof (_Jv_IDispatchTable));
620 ifaces.len = INITIAL_IFACES_LEN;
621 ifaces.list = (jclass *) _Jv_Malloc (ifaces.len * sizeof (jclass *));
623 int itable_size = get_interfaces (klass, &ifaces);
625 if (ifaces.count > 0)
627 klass->idt->cls.itable =
628 // FIXME: _Jv_AllocBytes
629 (void **) _Jv_Malloc (itable_size * sizeof (void *));
630 klass->idt->cls.itable_length = itable_size;
632 jshort *itable_offsets =
633 (jshort *) _Jv_Malloc (ifaces.count * sizeof (jshort));
635 generate_itable (klass, &ifaces, itable_offsets);
637 jshort cls_iindex = find_iindex (ifaces.list, itable_offsets,
640 for (int i = 0; i < ifaces.count; i++)
642 ifaces.list[i]->idt->iface.ioffsets[cls_iindex] =
646 klass->idt->cls.iindex = cls_iindex;
648 _Jv_Free (ifaces.list);
649 _Jv_Free (itable_offsets);
653 klass->idt->cls.iindex = SHRT_MAX;
657 // Return index of item in list, or -1 if item is not present.
659 _Jv_Linker::indexof (void *item, void **list, jshort list_len)
661 for (int i=0; i < list_len; i++)
669 // Find all unique interfaces directly or indirectly implemented by klass.
670 // Returns the size of the interface dispatch table (itable) for klass, which
671 // is the number of unique interfaces plus the total number of methods that
672 // those interfaces declare. May extend ifaces if required.
674 _Jv_Linker::get_interfaces (jclass klass, _Jv_ifaces *ifaces)
678 for (int i = 0; i < klass->interface_count; i++)
680 jclass iface = klass->interfaces[i];
682 /* Make sure interface is linked. */
683 wait_for_state(iface, JV_STATE_LINKED);
685 if (indexof (iface, (void **) ifaces->list, ifaces->count) == -1)
687 if (ifaces->count + 1 >= ifaces->len)
689 /* Resize ifaces list */
690 ifaces->len = ifaces->len * 2;
692 = (jclass *) _Jv_Realloc (ifaces->list,
693 ifaces->len * sizeof(jclass));
695 ifaces->list[ifaces->count] = iface;
698 result += get_interfaces (klass->interfaces[i], ifaces);
702 if (klass->isInterface())
703 result += klass->method_count + 1;
704 else if (klass->superclass)
705 result += get_interfaces (klass->superclass, ifaces);
709 // Fill out itable in klass, resolving method declarations in each ifaces.
710 // itable_offsets is filled out with the position of each iface in itable,
711 // such that itable[itable_offsets[n]] == ifaces.list[n].
713 _Jv_Linker::generate_itable (jclass klass, _Jv_ifaces *ifaces,
714 jshort *itable_offsets)
716 void **itable = klass->idt->cls.itable;
717 jshort itable_pos = 0;
719 for (int i = 0; i < ifaces->count; i++)
721 jclass iface = ifaces->list[i];
722 itable_offsets[i] = itable_pos;
723 itable_pos = append_partial_itable (klass, iface, itable, itable_pos);
725 /* Create interface dispatch table for iface */
726 if (iface->idt == NULL)
728 // FIXME: _Jv_AllocBytes
730 = (_Jv_IDispatchTable *) _Jv_Malloc (sizeof (_Jv_IDispatchTable));
732 // The first element of ioffsets is its length (itself included).
733 // FIXME: _Jv_AllocBytes
734 jshort *ioffsets = (jshort *) _Jv_Malloc (INITIAL_IOFFSETS_LEN
736 ioffsets[0] = INITIAL_IOFFSETS_LEN;
737 for (int i = 1; i < INITIAL_IOFFSETS_LEN; i++)
740 iface->idt->iface.ioffsets = ioffsets;
745 // Format method name for use in error messages.
747 _Jv_GetMethodString (jclass klass, _Jv_Method *meth,
750 using namespace java::lang;
751 StringBuffer *buf = new StringBuffer (klass->name->toString());
752 buf->append (jchar ('.'));
753 buf->append (meth->name->toString());
754 buf->append ((jchar) ' ');
755 buf->append (meth->signature->toString());
758 buf->append(JvNewStringLatin1(" in "));
759 buf->append(derived->name->toString());
761 return buf->toString();
765 _Jv_ThrowNoSuchMethodError ()
767 throw new java::lang::NoSuchMethodError;
771 // A function whose invocation is prepared using libffi. It gets called
772 // whenever a static method of a missing class is invoked. The data argument
773 // holds a reference to a String denoting the missing class.
774 // The prepared function call is stored in a class' atable.
776 _Jv_ThrowNoClassDefFoundErrorTrampoline(ffi_cif *,
781 throw new java::lang::NoClassDefFoundError(
782 _Jv_NewStringUtf8Const( (_Jv_Utf8Const *) data));
785 // A variant of the NoClassDefFoundError throwing method that can
786 // be used without libffi.
788 _Jv_ThrowNoClassDefFoundError()
790 throw new java::lang::NoClassDefFoundError();
794 // Throw a NoSuchFieldError. Called by compiler-generated code when
795 // an otable entry is zero. OTABLE_INDEX is the index in the caller's
796 // otable that refers to the missing field. This index may be used to
797 // print diagnostic information about the field.
799 _Jv_ThrowNoSuchFieldError (int /* otable_index */)
801 throw new java::lang::NoSuchFieldError;
804 // This is put in empty vtable slots.
806 _Jv_ThrowAbstractMethodError ()
808 throw new java::lang::AbstractMethodError();
811 // Each superinterface of a class (i.e. each interface that the class
812 // directly or indirectly implements) has a corresponding "Partial
813 // Interface Dispatch Table" whose size is (number of methods + 1) words.
814 // The first word is a pointer to the interface (i.e. the java.lang.Class
815 // instance for that interface). The remaining words are pointers to the
816 // actual methods that implement the methods declared in the interface,
817 // in order of declaration.
819 // Append partial interface dispatch table for "iface" to "itable", at
820 // position itable_pos.
821 // Returns the offset at which the next partial ITable should be appended.
823 _Jv_Linker::append_partial_itable (jclass klass, jclass iface,
824 void **itable, jshort pos)
826 using namespace java::lang::reflect;
828 itable[pos++] = (void *) iface;
831 for (int j=0; j < iface->method_count; j++)
834 for (jclass cl = klass; cl; cl = cl->getSuperclass())
836 meth = _Jv_GetMethodLocal (cl, iface->methods[j].name,
837 iface->methods[j].signature);
843 if (meth && (meth->name->first() == '<'))
845 // leave a placeholder in the itable for hidden init methods.
850 if ((meth->accflags & Modifier::STATIC) != 0)
851 throw new java::lang::IncompatibleClassChangeError
852 (_Jv_GetMethodString (klass, meth));
853 if ((meth->accflags & Modifier::PUBLIC) == 0)
854 throw new java::lang::IllegalAccessError
855 (_Jv_GetMethodString (klass, meth));
857 if ((meth->accflags & Modifier::ABSTRACT) != 0)
858 itable[pos] = (void *) &_Jv_ThrowAbstractMethodError;
860 itable[pos] = meth->ncode;
864 // The method doesn't exist in klass. Binary compatibility rules
865 // permit this, so we delay the error until runtime using a pointer
866 // to a method which throws an exception.
867 itable[pos] = (void *) _Jv_ThrowNoSuchMethodError;
875 static _Jv_Mutex_t iindex_mutex;
876 static bool iindex_mutex_initialized = false;
878 // We need to find the correct offset in the Class Interface Dispatch
879 // Table for a given interface. Once we have that, invoking an interface
880 // method just requires combining the Method's index in the interface
881 // (known at compile time) to get the correct method. Doing a type test
882 // (cast or instanceof) is the same problem: Once we have a possible Partial
883 // Interface Dispatch Table, we just compare the first element to see if it
884 // matches the desired interface. So how can we find the correct offset?
885 // Our solution is to keep a vector of candiate offsets in each interface
886 // (idt->iface.ioffsets), and in each class we have an index
887 // (idt->cls.iindex) used to select the correct offset from ioffsets.
889 // Calculate and return iindex for a new class.
890 // ifaces is a vector of num interfaces that the class implements.
891 // offsets[j] is the offset in the interface dispatch table for the
892 // interface corresponding to ifaces[j].
893 // May extend the interface ioffsets if required.
895 _Jv_Linker::find_iindex (jclass *ifaces, jshort *offsets, jshort num)
900 // Acquire a global lock to prevent itable corruption in case of multiple
901 // classes that implement an intersecting set of interfaces being linked
902 // simultaneously. We can assume that the mutex will be initialized
904 if (! iindex_mutex_initialized)
906 _Jv_MutexInit (&iindex_mutex);
907 iindex_mutex_initialized = true;
910 _Jv_MutexLock (&iindex_mutex);
912 for (i=1;; i++) /* each potential position in ioffsets */
914 for (j=0;; j++) /* each iface */
918 if (i >= ifaces[j]->idt->iface.ioffsets[0])
920 int ioffset = ifaces[j]->idt->iface.ioffsets[i];
921 /* We can potentially share this position with another class. */
922 if (ioffset >= 0 && ioffset != offsets[j])
923 break; /* Nope. Try next i. */
927 for (j = 0; j < num; j++)
929 int len = ifaces[j]->idt->iface.ioffsets[0];
933 int newlen = 2 * len;
936 jshort *old_ioffsets = ifaces[j]->idt->iface.ioffsets;
937 // FIXME: _Jv_AllocBytes
938 jshort *new_ioffsets = (jshort *) _Jv_Malloc (newlen
940 memcpy (&new_ioffsets[1], &old_ioffsets[1],
941 (len - 1) * sizeof (jshort));
942 new_ioffsets[0] = newlen;
945 new_ioffsets[len++] = -1;
947 ifaces[j]->idt->iface.ioffsets = new_ioffsets;
949 ifaces[j]->idt->iface.ioffsets[i] = offsets[j];
952 _Jv_MutexUnlock (&iindex_mutex);
959 _Jv_Linker::create_error_method (_Jv_Utf8Const *class_name)
962 // TODO: The following structs/objects are heap allocated are
963 // unreachable by the garbage collector:
966 ffi_closure *closure = (ffi_closure *) _Jv_Malloc( sizeof( ffi_closure ));
967 ffi_cif *cif = (ffi_cif *) _Jv_Malloc( sizeof( ffi_cif ));
969 // Pretends that we want to call a void (*) (void) function via
971 ffi_type **arg_types = (ffi_type **) _Jv_Malloc( sizeof( ffi_type * ));
972 arg_types[0] = &ffi_type_void;
974 // Initializes the cif and the closure. If that worked the closure is
975 // returned and can be used as a function pointer in a class' atable.
977 cif, FFI_DEFAULT_ABI, 1, &ffi_type_void, arg_types) == FFI_OK
978 && (ffi_prep_closure (
979 closure, cif, _Jv_ThrowNoClassDefFoundErrorTrampoline,
980 class_name) == FFI_OK))
986 java::lang::StringBuffer *buffer = new java::lang::StringBuffer();
988 JvNewStringLatin1("Error setting up FFI closure"
989 " for static method of missing class: "));
991 buffer->append (_Jv_NewStringUtf8Const(class_name));
993 throw new java::lang::InternalError(buffer->toString());
996 // Codepath for platforms which do not support (or want) libffi.
997 // You have to accept that it is impossible to provide the name
998 // of the missing class then.
999 return _Jv_ThrowNoClassDefFoundError;
1003 // Functions for indirect dispatch (symbolic virtual binding) support.
1005 // There are three tables, atable otable and itable. atable is an
1006 // array of addresses, and otable is an array of offsets, and these
1007 // are used for static and virtual members respectively. itable is an
1008 // array of pairs {address, index} where each address is a pointer to
1011 // {a,o,i}table_syms is an array of _Jv_MethodSymbols. Each such
1012 // symbol is a tuple of {classname, member name, signature}.
1014 // Set this to true to enable debugging of indirect dispatch tables/linking.
1015 static bool debug_link = false;
1017 // link_symbol_table() scans these two arrays and fills in the
1018 // corresponding atable and otable with the addresses of static
1019 // members and the offsets of virtual members.
1021 // The offset (in bytes) for each resolved method or field is placed
1022 // at the corresponding position in the virtual method offset table
1025 // The same otable and atable may be shared by many classes.
1027 // This must be called while holding the class lock.
1030 _Jv_Linker::link_symbol_table (jclass klass)
1033 _Jv_MethodSymbol sym;
1034 if (klass->otable == NULL
1035 || klass->otable->state != 0)
1038 klass->otable->state = 1;
1041 fprintf (stderr, "Fixing up otable in %s:\n", klass->name->chars());
1043 (sym = klass->otable_syms[index]).class_name != NULL;
1046 jclass target_class = _Jv_FindClass (sym.class_name, klass->loader);
1047 _Jv_Method *meth = NULL;
1049 _Jv_Utf8Const *signature = sym.signature;
1051 if (target_class == NULL)
1052 throw new java::lang::NoClassDefFoundError
1053 (_Jv_NewStringUTF (sym.class_name->chars()));
1055 // We're looking for a field or a method, and we can tell
1056 // which is needed by looking at the signature.
1057 if (signature->first() == '(' && signature->len() >= 2)
1059 // Looks like someone is trying to invoke an interface method
1060 if (target_class->isInterface())
1062 using namespace java::lang;
1063 StringBuffer *sb = new StringBuffer();
1064 sb->append(JvNewStringLatin1("found interface "));
1065 sb->append(target_class->getName());
1066 sb->append(JvNewStringLatin1(" when searching for a class"));
1067 throw new VerifyError(sb->toString());
1070 // If the target class does not have a vtable_method_count yet,
1071 // then we can't tell the offsets for its methods, so we must lay
1073 wait_for_state(target_class, JV_STATE_PREPARED);
1075 meth = _Jv_LookupDeclaredMethod(target_class, sym.name,
1078 // Every class has a throwNoSuchMethodErrorIndex method that
1079 // it inherits from java.lang.Object. Find its vtable
1081 static int throwNoSuchMethodErrorIndex;
1082 if (throwNoSuchMethodErrorIndex == 0)
1085 = _Jv_makeUtf8Const ("throwNoSuchMethodError",
1086 strlen ("throwNoSuchMethodError"));
1088 = _Jv_LookupDeclaredMethod (&java::lang::Object::class$,
1089 name, gcj::void_signature);
1090 throwNoSuchMethodErrorIndex
1091 = _Jv_VTable::idx_to_offset (meth->index);
1094 // If we don't find a nonstatic method, insert the
1095 // vtable index of Object.throwNoSuchMethodError().
1096 // This defers the missing method error until an attempt
1097 // is made to execute it.
1102 offset = _Jv_VTable::idx_to_offset (meth->index);
1104 offset = throwNoSuchMethodErrorIndex;
1107 JvFail ("Bad method index");
1108 JvAssert (meth->index < target_class->vtable_method_count);
1110 klass->otable->offsets[index] = offset;
1114 fprintf (stderr, " offsets[%d] = %d (class %s@%p : %s(%s))\n",
1116 (int)klass->otable->offsets[index],
1117 (const char*)target_class->name->chars(),
1119 (const char*)sym.name->chars(),
1120 (const char*)signature->chars());
1126 wait_for_state(target_class, JV_STATE_PREPARED);
1128 _Jv_Field *the_field = NULL;
1131 the_field = find_field (klass, target_class, &found_class,
1132 sym.name, sym.signature);
1133 if ((the_field->flags & java::lang::reflect::Modifier::STATIC))
1134 throw new java::lang::IncompatibleClassChangeError;
1136 klass->otable->offsets[index] = the_field->u.boffset;
1138 catch (java::lang::NoSuchFieldError *err)
1140 klass->otable->offsets[index] = 0;
1146 if (klass->atable == NULL || klass->atable->state != 0)
1149 klass->atable->state = 1;
1152 (sym = klass->atable_syms[index]).class_name != NULL;
1155 jclass target_class =
1156 _Jv_FindClassNoException (sym.class_name, klass->loader);
1158 _Jv_Method *meth = NULL;
1159 _Jv_Utf8Const *signature = sym.signature;
1161 // ??? Setting this pointer to null will at least get us a
1162 // NullPointerException
1163 klass->atable->addresses[index] = NULL;
1165 // If the target class is missing we prepare a function call
1166 // that throws a NoClassDefFoundError and store the address of
1167 // that newly prepare method in the atable. The user can run
1168 // code in classes where the missing class is part of the
1169 // execution environment as long as it is never referenced.
1170 if (target_class == NULL)
1171 klass->atable->addresses[index] = create_error_method(sym.class_name);
1172 // We're looking for a static field or a static method, and we
1173 // can tell which is needed by looking at the signature.
1174 else if (signature->first() == '(' && signature->len() >= 2)
1176 // If the target class does not have a vtable_method_count yet,
1177 // then we can't tell the offsets for its methods, so we must lay
1179 wait_for_state (target_class, JV_STATE_PREPARED);
1181 // Interface methods cannot have bodies.
1182 if (target_class->isInterface())
1184 using namespace java::lang;
1185 StringBuffer *sb = new StringBuffer();
1186 sb->append(JvNewStringLatin1("class "));
1187 sb->append(target_class->getName());
1188 sb->append(JvNewStringLatin1(" is an interface: "
1190 throw new VerifyError(sb->toString());
1193 meth = _Jv_LookupDeclaredMethod(target_class, sym.name,
1198 if (meth->ncode) // Maybe abstract?
1200 klass->atable->addresses[index] = meth->ncode;
1202 fprintf (stderr, " addresses[%d] = %p (class %s@%p : %s(%s))\n",
1204 &klass->atable->addresses[index],
1205 (const char*)target_class->name->chars(),
1207 (const char*)sym.name->chars(),
1208 (const char*)signature->chars());
1212 klass->atable->addresses[index]
1213 = create_error_method(sym.class_name);
1218 // Try fields only if the target class exists.
1219 if ( target_class != NULL )
1221 wait_for_state(target_class, JV_STATE_PREPARED);
1223 _Jv_Field *the_field = find_field (klass, target_class, &found_class,
1224 sym.name, sym.signature);
1225 if ((the_field->flags & java::lang::reflect::Modifier::STATIC))
1226 klass->atable->addresses[index] = the_field->u.addr;
1228 throw new java::lang::IncompatibleClassChangeError;
1233 if (klass->itable == NULL
1234 || klass->itable->state != 0)
1237 klass->itable->state = 1;
1240 (sym = klass->itable_syms[index]).class_name != NULL;
1243 jclass target_class = _Jv_FindClass (sym.class_name, klass->loader);
1244 _Jv_Utf8Const *signature = sym.signature;
1249 wait_for_state(target_class, JV_STATE_LOADED);
1250 bool found = _Jv_getInterfaceMethod (target_class, cls, i,
1251 sym.name, sym.signature);
1255 klass->itable->addresses[index * 2] = cls;
1256 klass->itable->addresses[index * 2 + 1] = (void *)(unsigned long) i;
1259 fprintf (stderr, " interfaces[%d] = %p (interface %s@%p : %s(%s))\n",
1261 klass->itable->addresses[index * 2],
1262 (const char*)cls->name->chars(),
1264 (const char*)sym.name->chars(),
1265 (const char*)signature->chars());
1266 fprintf (stderr, " [%d] = offset %d\n",
1268 (int)(unsigned long)klass->itable->addresses[index * 2 + 1]);
1273 throw new java::lang::IncompatibleClassChangeError;
1278 // For each catch_record in the list of caught classes, fill in the
1281 _Jv_Linker::link_exception_table (jclass self)
1283 struct _Jv_CatchClass *catch_record = self->catch_classes;
1284 if (!catch_record || catch_record->classname)
1287 while (catch_record->classname)
1292 = _Jv_FindClass (catch_record->classname,
1293 self->getClassLoaderInternal ());
1294 *catch_record->address = target_class;
1296 catch (::java::lang::Throwable *t)
1298 // FIXME: We need to do something better here.
1299 *catch_record->address = 0;
1303 self->catch_classes->classname = (_Jv_Utf8Const *)-1;
1306 // Set itable method indexes for members of interface IFACE.
1308 _Jv_Linker::layout_interface_methods (jclass iface)
1310 if (! iface->isInterface())
1313 // itable indexes start at 1.
1314 // FIXME: Static initalizers currently get a NULL placeholder entry in the
1315 // itable so they are also assigned an index here.
1316 for (int i = 0; i < iface->method_count; i++)
1317 iface->methods[i].index = i + 1;
1320 // Prepare virtual method declarations in KLASS, and any superclasses
1321 // as required, by determining their vtable index, setting
1322 // method->index, and finally setting the class's vtable_method_count.
1323 // Must be called with the lock for KLASS held.
1325 _Jv_Linker::layout_vtable_methods (jclass klass)
1327 if (klass->vtable != NULL || klass->isInterface()
1328 || klass->vtable_method_count != -1)
1331 jclass superclass = klass->getSuperclass();
1333 if (superclass != NULL && superclass->vtable_method_count == -1)
1335 JvSynchronize sync (superclass);
1336 layout_vtable_methods (superclass);
1339 int index = (superclass == NULL ? 0 : superclass->vtable_method_count);
1341 for (int i = 0; i < klass->method_count; ++i)
1343 _Jv_Method *meth = &klass->methods[i];
1344 _Jv_Method *super_meth = NULL;
1346 if (! _Jv_isVirtualMethod (meth))
1349 if (superclass != NULL)
1352 super_meth = _Jv_LookupDeclaredMethod (superclass, meth->name,
1353 meth->signature, &declarer);
1354 // See if this method actually overrides the other method
1358 if (! _Jv_isVirtualMethod (super_meth)
1359 || ! _Jv_CheckAccess (klass, declarer,
1360 super_meth->accflags))
1362 else if ((super_meth->accflags
1363 & java::lang::reflect::Modifier::FINAL) != 0)
1365 using namespace java::lang;
1366 StringBuffer *sb = new StringBuffer();
1367 sb->append(JvNewStringLatin1("method "));
1368 sb->append(_Jv_GetMethodString(klass, meth));
1369 sb->append(JvNewStringLatin1(" overrides final method "));
1370 sb->append(_Jv_GetMethodString(declarer, super_meth));
1371 throw new VerifyError(sb->toString());
1377 meth->index = super_meth->index;
1379 meth->index = index++;
1382 klass->vtable_method_count = index;
1385 // Set entries in VTABLE for virtual methods declared in KLASS.
1387 _Jv_Linker::set_vtable_entries (jclass klass, _Jv_VTable *vtable)
1389 for (int i = klass->method_count - 1; i >= 0; i--)
1391 using namespace java::lang::reflect;
1393 _Jv_Method *meth = &klass->methods[i];
1394 if (meth->index == (_Jv_ushort) -1)
1396 if ((meth->accflags & Modifier::ABSTRACT))
1397 // FIXME: it might be nice to have a libffi trampoline here,
1398 // so we could pass in the method name and other information.
1399 vtable->set_method(meth->index,
1400 (void *) &_Jv_ThrowAbstractMethodError);
1402 vtable->set_method(meth->index, meth->ncode);
1406 // Allocate and lay out the virtual method table for KLASS. This will
1407 // also cause vtables to be generated for any non-abstract
1408 // superclasses, and virtual method layout to occur for any abstract
1409 // superclasses. Must be called with monitor lock for KLASS held.
1411 _Jv_Linker::make_vtable (jclass klass)
1413 using namespace java::lang::reflect;
1415 // If the vtable exists, or for interface classes, do nothing. All
1416 // other classes, including abstract classes, need a vtable.
1417 if (klass->vtable != NULL || klass->isInterface())
1420 // Ensure all the `ncode' entries are set.
1421 klass->engine->create_ncode(klass);
1423 // Class must be laid out before we can create a vtable.
1424 if (klass->vtable_method_count == -1)
1425 layout_vtable_methods (klass);
1427 // Allocate the new vtable.
1428 _Jv_VTable *vtable = _Jv_VTable::new_vtable (klass->vtable_method_count);
1429 klass->vtable = vtable;
1431 // Copy the vtable of the closest superclass.
1432 jclass superclass = klass->superclass;
1434 JvSynchronize sync (superclass);
1435 make_vtable (superclass);
1437 for (int i = 0; i < superclass->vtable_method_count; ++i)
1438 vtable->set_method (i, superclass->vtable->get_method (i));
1440 // Set the class pointer and GC descriptor.
1441 vtable->clas = klass;
1442 vtable->gc_descr = _Jv_BuildGCDescr (klass);
1444 // For each virtual declared in klass, set new vtable entry or
1445 // override an old one.
1446 set_vtable_entries (klass, vtable);
1448 // Note that we don't check for abstract methods here. We used to,
1449 // but there is a JVMS clarification that indicates that a check
1450 // here would be too eager. And, a simple test case confirms this.
1453 // Lay out the class, allocating space for static fields and computing
1454 // offsets of instance fields. The class lock must be held by the
1457 _Jv_Linker::ensure_fields_laid_out (jclass klass)
1459 if (klass->size_in_bytes != -1)
1462 // Compute the alignment for this type by searching through the
1463 // superclasses and finding the maximum required alignment. We
1464 // could consider caching this in the Class.
1465 int max_align = __alignof__ (java::lang::Object);
1466 jclass super = klass->getSuperclass();
1467 while (super != NULL)
1469 // Ensure that our super has its super installed before
1471 wait_for_state(super, JV_STATE_LOADING);
1472 ensure_fields_laid_out(super);
1473 int num = JvNumInstanceFields (super);
1474 _Jv_Field *field = JvGetFirstInstanceField (super);
1477 int field_align = get_alignment_from_class (field->type);
1478 if (field_align > max_align)
1479 max_align = field_align;
1483 super = super->getSuperclass();
1487 int static_size = 0;
1489 // Although java.lang.Object is never interpreted, an interface can
1490 // have a null superclass. Note that we have to lay out an
1491 // interface because it might have static fields.
1492 if (klass->superclass)
1493 instance_size = klass->superclass->size();
1495 instance_size = java::lang::Object::class$.size();
1497 for (int i = 0; i < klass->field_count; i++)
1502 _Jv_Field *field = &klass->fields[i];
1504 if (! field->isRef ())
1506 // It is safe to resolve the field here, since it's a
1507 // primitive class, which does not cause loading to happen.
1508 resolve_field (field, klass->loader);
1510 field_size = field->type->size ();
1511 field_align = get_alignment_from_class (field->type);
1515 field_size = sizeof (jobject);
1516 field_align = __alignof__ (jobject);
1519 field->bsize = field_size;
1521 if ((field->flags & java::lang::reflect::Modifier::STATIC))
1523 if (field->u.addr == NULL)
1525 // This computes an offset into a region we'll allocate
1526 // shortly, and then add this offset to the start
1528 static_size = ROUND (static_size, field_align);
1529 field->u.boffset = static_size;
1530 static_size += field_size;
1535 instance_size = ROUND (instance_size, field_align);
1536 field->u.boffset = instance_size;
1537 instance_size += field_size;
1538 if (field_align > max_align)
1539 max_align = field_align;
1543 if (static_size != 0)
1544 klass->engine->allocate_static_fields (klass, static_size);
1546 // Set the instance size for the class. Note that first we round it
1547 // to the alignment required for this object; this keeps us in sync
1548 // with our current ABI.
1549 instance_size = ROUND (instance_size, max_align);
1550 klass->size_in_bytes = instance_size;
1553 // This takes the class to state JV_STATE_LINKED. The class lock must
1554 // be held when calling this.
1556 _Jv_Linker::ensure_class_linked (jclass klass)
1558 if (klass->state >= JV_STATE_LINKED)
1561 int state = klass->state;
1564 // Short-circuit, so that mutually dependent classes are ok.
1565 klass->state = JV_STATE_LINKED;
1567 _Jv_Constants *pool = &klass->constants;
1569 // Compiled classes require that their class constants be
1570 // resolved here. However, interpreted classes need their
1571 // constants to be resolved lazily. If we resolve an
1572 // interpreted class' constants eagerly, we can end up with
1573 // spurious IllegalAccessErrors when the constant pool contains
1574 // a reference to a class we can't access. This can validly
1575 // occur in an obscure case involving the InnerClasses
1577 if (! _Jv_IsInterpretedClass (klass))
1579 // Resolve class constants first, since other constant pool
1580 // entries may rely on these.
1581 for (int index = 1; index < pool->size; ++index)
1583 if (pool->tags[index] == JV_CONSTANT_Class)
1584 // Lazily resolve the entries.
1585 resolve_pool_entry (klass, index, true);
1589 #if 0 // Should be redundant now
1590 // If superclass looks like a constant pool entry,
1592 if ((uaddr) klass->superclass < (uaddr) pool->size)
1593 klass->superclass = pool->data[(uaddr) klass->superclass].clazz;
1595 // Likewise for interfaces.
1596 for (int i = 0; i < klass->interface_count; i++)
1598 if ((uaddr) klass->interfaces[i] < (uaddr) pool->size)
1599 klass->interfaces[i]
1600 = pool->data[(uaddr) klass->interfaces[i]].clazz;
1604 // Resolve the remaining constant pool entries.
1605 for (int index = 1; index < pool->size; ++index)
1607 if (pool->tags[index] == JV_CONSTANT_String)
1611 str = _Jv_NewStringUtf8Const (pool->data[index].utf8);
1612 pool->data[index].o = str;
1613 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
1617 if (klass->engine->need_resolve_string_fields())
1619 jfieldID f = JvGetFirstStaticField (klass);
1620 for (int n = JvNumStaticFields (klass); n > 0; --n)
1622 int mod = f->getModifiers ();
1623 // If we have a static String field with a non-null initial
1624 // value, we know it points to a Utf8Const.
1626 // Finds out whether we have to initialize a String without the
1627 // need to resolve the field.
1628 if ((f->isResolved()
1629 ? (f->type == &java::lang::String::class$)
1630 : _Jv_equalUtf8Classnames((_Jv_Utf8Const *) f->type,
1631 java::lang::String::class$.name))
1632 && (mod & java::lang::reflect::Modifier::STATIC) != 0)
1634 jstring *strp = (jstring *) f->u.addr;
1636 *strp = _Jv_NewStringUtf8Const ((_Jv_Utf8Const *) *strp);
1638 f = f->getNextField ();
1642 klass->notifyAll ();
1644 _Jv_PushClass (klass);
1646 catch (java::lang::Throwable *t)
1648 klass->state = state;
1653 // This ensures that symbolic superclass and superinterface references
1654 // are resolved for the indicated class. This must be called with the
1657 _Jv_Linker::ensure_supers_installed (jclass klass)
1659 resolve_class_ref (klass, &klass->superclass);
1660 // An interface won't have a superclass.
1661 if (klass->superclass)
1662 wait_for_state (klass->superclass, JV_STATE_LOADING);
1664 for (int i = 0; i < klass->interface_count; ++i)
1666 resolve_class_ref (klass, &klass->interfaces[i]);
1667 wait_for_state (klass->interfaces[i], JV_STATE_LOADING);
1671 // This adds missing `Miranda methods' to a class.
1673 _Jv_Linker::add_miranda_methods (jclass base, jclass iface_class)
1675 // Note that at this point, all our supers, and the supers of all
1676 // our superclasses and superinterfaces, will have been installed.
1678 for (int i = 0; i < iface_class->interface_count; ++i)
1680 jclass interface = iface_class->interfaces[i];
1682 for (int j = 0; j < interface->method_count; ++j)
1684 _Jv_Method *meth = &interface->methods[j];
1685 // Don't bother with <clinit>.
1686 if (meth->name->first() == '<')
1688 _Jv_Method *new_meth = _Jv_LookupDeclaredMethod (base, meth->name,
1692 // We assume that such methods are very unlikely, so we
1693 // just reallocate the method array each time one is
1694 // found. This greatly simplifies the searching --
1695 // otherwise we have to make sure that each such method
1696 // found is really unique among all superinterfaces.
1697 int new_count = base->method_count + 1;
1699 = (_Jv_Method *) _Jv_AllocBytes (sizeof (_Jv_Method)
1701 memcpy (new_m, base->methods,
1702 sizeof (_Jv_Method) * base->method_count);
1705 new_m[base->method_count] = *meth;
1706 new_m[base->method_count].index = (_Jv_ushort) -1;
1707 new_m[base->method_count].accflags
1708 |= java::lang::reflect::Modifier::INVISIBLE;
1710 base->methods = new_m;
1711 base->method_count = new_count;
1715 wait_for_state (interface, JV_STATE_LOADED);
1716 add_miranda_methods (base, interface);
1720 // This ensures that the class' method table is "complete". This must
1721 // be called with the class lock held.
1723 _Jv_Linker::ensure_method_table_complete (jclass klass)
1725 if (klass->vtable != NULL)
1728 // We need our superclass to have its own Miranda methods installed.
1729 if (! klass->isInterface())
1730 wait_for_state (klass->getSuperclass (), JV_STATE_LOADED);
1732 // A class might have so-called "Miranda methods". This is a method
1733 // that is declared in an interface and not re-declared in an
1734 // abstract class. Some compilers don't emit declarations for such
1735 // methods in the class; this will give us problems since we expect
1736 // a declaration for any method requiring a vtable entry. We handle
1737 // this here by searching for such methods and constructing new
1738 // internal declarations for them. Note that we do this
1739 // unconditionally, and not just for abstract classes, to correctly
1740 // account for cases where a class is modified to be concrete and
1741 // still incorrectly inherits an abstract method.
1742 int pre_count = klass->method_count;
1743 add_miranda_methods (klass, klass);
1745 // Let the execution engine know that we've added methods.
1746 if (klass->method_count != pre_count)
1747 klass->engine->post_miranda_hook(klass);
1750 // Verify a class. Must be called with class lock held.
1752 _Jv_Linker::verify_class (jclass klass)
1754 klass->engine->verify(klass);
1757 // Check the assertions contained in the type assertion table for KLASS.
1758 // This is the equivilent of bytecode verification for native, BC-ABI code.
1760 _Jv_Linker::verify_type_assertions (jclass klass)
1763 fprintf (stderr, "Evaluating type assertions for %s:\n",
1764 klass->name->chars());
1766 if (klass->assertion_table == NULL)
1769 for (int i = 0;; i++)
1771 int assertion_code = klass->assertion_table[i].assertion_code;
1772 _Jv_Utf8Const *op1 = klass->assertion_table[i].op1;
1773 _Jv_Utf8Const *op2 = klass->assertion_table[i].op2;
1775 if (assertion_code == JV_ASSERT_END_OF_TABLE)
1777 else if (assertion_code == JV_ASSERT_TYPES_COMPATIBLE)
1781 fprintf (stderr, " code=%i, operand A=%s B=%s\n",
1782 assertion_code, op1->chars(), op2->chars());
1785 // The operands are class signatures. op1 is the source,
1786 // op2 is the target.
1787 jclass cl1 = _Jv_FindClassFromSignature (op1->chars(),
1788 klass->getClassLoaderInternal());
1789 jclass cl2 = _Jv_FindClassFromSignature (op2->chars(),
1790 klass->getClassLoaderInternal());
1792 // If the class doesn't exist, ignore the assertion. An exception
1793 // will be thrown later if an attempt is made to actually
1794 // instantiate the class.
1795 if (cl1 == NULL || cl2 == NULL)
1798 if (! _Jv_IsAssignableFromSlow (cl1, cl2))
1800 jstring s = JvNewStringUTF ("Incompatible types: In class ");
1801 s = s->concat (klass->getName());
1802 s = s->concat (JvNewStringUTF (": "));
1803 s = s->concat (cl1->getName());
1804 s = s->concat (JvNewStringUTF (" is not assignable to "));
1805 s = s->concat (cl2->getName());
1806 throw new java::lang::VerifyError (s);
1809 else if (assertion_code == JV_ASSERT_IS_INSTANTIABLE)
1811 // TODO: Implement this.
1813 // Unknown assertion codes are ignored, for forwards-compatibility.
1818 _Jv_Linker::print_class_loaded (jclass klass)
1820 char *codesource = NULL;
1821 if (klass->protectionDomain != NULL)
1823 java::security::CodeSource *cs
1824 = klass->protectionDomain->getCodeSource();
1827 jstring css = cs->toString();
1828 int len = JvGetStringUTFLength(css);
1829 codesource = (char *) _Jv_AllocBytes(len + 1);
1830 JvGetStringUTFRegion(css, 0, css->length(), codesource);
1831 codesource[len] = '\0';
1834 if (codesource == NULL)
1835 codesource = "<no code source>";
1838 if (_Jv_IsInterpretedClass (klass))
1840 else if (_Jv_IsBinaryCompatibilityABI (klass))
1841 abi = "BC-compiled";
1843 abi = "pre-compiled";
1845 fprintf (stderr, "[Loaded (%s) %s from %s]\n", abi, klass->name->chars(),
1849 // FIXME: mention invariants and stuff.
1851 _Jv_Linker::wait_for_state (jclass klass, int state)
1853 if (klass->state >= state)
1856 JvSynchronize sync (klass);
1858 // This is similar to the strategy for class initialization. If we
1859 // already hold the lock, just leave.
1860 java::lang::Thread *self = java::lang::Thread::currentThread();
1861 while (klass->state <= state
1863 && klass->thread != self)
1866 java::lang::Thread *save = klass->thread;
1867 klass->thread = self;
1869 // Print some debugging info if requested. Interpreted classes are
1870 // handled in defineclass, so we only need to handle the two
1871 // pre-compiled cases here.
1872 if (gcj::verbose_class_flag
1873 && (klass->state == JV_STATE_COMPILED
1874 || klass->state == JV_STATE_PRELOADING)
1875 && ! _Jv_IsInterpretedClass (klass))
1876 print_class_loaded (klass);
1880 if (state >= JV_STATE_LOADING && klass->state < JV_STATE_LOADING)
1882 ensure_supers_installed (klass);
1883 klass->set_state(JV_STATE_LOADING);
1886 if (state >= JV_STATE_LOADED && klass->state < JV_STATE_LOADED)
1888 ensure_method_table_complete (klass);
1889 klass->set_state(JV_STATE_LOADED);
1892 if (state >= JV_STATE_PREPARED && klass->state < JV_STATE_PREPARED)
1894 ensure_fields_laid_out (klass);
1895 make_vtable (klass);
1896 layout_interface_methods (klass);
1897 prepare_constant_time_tables (klass);
1898 klass->set_state(JV_STATE_PREPARED);
1901 if (state >= JV_STATE_LINKED && klass->state < JV_STATE_LINKED)
1903 if (gcj::verifyClasses)
1904 verify_class (klass);
1906 ensure_class_linked (klass);
1907 link_exception_table (klass);
1908 link_symbol_table (klass);
1909 klass->set_state(JV_STATE_LINKED);
1912 catch (java::lang::Throwable *exc)
1914 klass->thread = save;
1915 klass->set_state(JV_STATE_ERROR);
1919 klass->thread = save;
1921 if (klass->state == JV_STATE_ERROR)
1922 throw new java::lang::LinkageError;