1 // resolve.cc - Code for linking and resolving classes and pool entries.
3 /* Copyright (C) 1999, 2000, 2001, 2002, 2003 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> */
16 #include <java-interp.h>
21 #include <java-cpool.h>
22 #include <java/lang/Class.h>
23 #include <java/lang/String.h>
24 #include <java/lang/StringBuffer.h>
25 #include <java/lang/Thread.h>
26 #include <java/lang/InternalError.h>
27 #include <java/lang/VirtualMachineError.h>
28 #include <java/lang/NoSuchFieldError.h>
29 #include <java/lang/NoSuchMethodError.h>
30 #include <java/lang/ClassFormatError.h>
31 #include <java/lang/IllegalAccessError.h>
32 #include <java/lang/AbstractMethodError.h>
33 #include <java/lang/NoClassDefFoundError.h>
34 #include <java/lang/IncompatibleClassChangeError.h>
35 #include <java/lang/reflect/Modifier.h>
40 _Jv_ResolveField (_Jv_Field *field, java::lang::ClassLoader *loader)
42 if (! field->isResolved ())
44 _Jv_Utf8Const *sig = (_Jv_Utf8Const*)field->type;
45 field->type = _Jv_FindClassFromSignature (sig->data, loader);
46 field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
52 static void throw_internal_error (char *msg)
53 __attribute__ ((__noreturn__));
54 static void throw_class_format_error (jstring msg)
55 __attribute__ ((__noreturn__));
56 static void throw_class_format_error (char *msg)
57 __attribute__ ((__noreturn__));
59 static int get_alignment_from_class (jclass);
61 static _Jv_ResolvedMethod*
62 _Jv_BuildResolvedMethod (_Jv_Method*,
68 static void throw_incompatible_class_change_error (jstring msg)
70 throw new java::lang::IncompatibleClassChangeError (msg);
74 _Jv_ResolvePoolEntry (jclass klass, int index)
76 using namespace java::lang::reflect;
78 _Jv_Constants *pool = &klass->constants;
80 if ((pool->tags[index] & JV_CONSTANT_ResolvedFlag) != 0)
81 return pool->data[index];
83 switch (pool->tags[index]) {
84 case JV_CONSTANT_Class:
86 _Jv_Utf8Const *name = pool->data[index].utf8;
89 if (name->data[0] == '[')
90 found = _Jv_FindClassFromSignature (&name->data[0],
93 found = _Jv_FindClass (name, klass->loader);
97 jstring str = _Jv_NewStringUTF (name->data);
98 // This exception is specified in JLS 2nd Ed, section 5.1.
99 throw new java::lang::NoClassDefFoundError (str);
102 if ((found->accflags & Modifier::PUBLIC) == Modifier::PUBLIC
103 || (_Jv_ClassNameSamePackage (found->name,
106 pool->data[index].clazz = found;
107 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
111 throw new java::lang::IllegalAccessError (found->getName());
116 case JV_CONSTANT_String:
119 str = _Jv_NewStringUtf8Const (pool->data[index].utf8);
120 pool->data[index].o = str;
121 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
126 case JV_CONSTANT_Fieldref:
128 _Jv_ushort class_index, name_and_type_index;
129 _Jv_loadIndexes (&pool->data[index],
131 name_and_type_index);
132 jclass owner = (_Jv_ResolvePoolEntry (klass, class_index)).clazz;
135 _Jv_InitClass (owner);
137 _Jv_ushort name_index, type_index;
138 _Jv_loadIndexes (&pool->data[name_and_type_index],
142 _Jv_Utf8Const *field_name = pool->data[name_index].utf8;
143 _Jv_Utf8Const *field_type_name = pool->data[type_index].utf8;
145 // FIXME: The implementation of this function
146 // (_Jv_FindClassFromSignature) will generate an instance of
147 // _Jv_Utf8Const for each call if the field type is a class name
148 // (Lxx.yy.Z;). This may be too expensive to do for each and
149 // every fieldref being resolved. For now, we fix the problem by
150 // only doing it when we have a loader different from the class
151 // declaring the field.
153 jclass field_type = 0;
155 if (owner->loader != klass->loader)
156 field_type = _Jv_FindClassFromSignature (field_type_name->data,
159 _Jv_Field* the_field = 0;
161 for (jclass cls = owner; cls != 0; cls = cls->getSuperclass ())
163 for (int i = 0; i < cls->field_count; i++)
165 _Jv_Field *field = &cls->fields[i];
166 if (! _Jv_equalUtf8Consts (field->name, field_name))
169 // now, check field access.
172 || ((field->flags & Modifier::PUBLIC) != 0)
173 || (((field->flags & Modifier::PROTECTED) != 0)
174 && cls->isAssignableFrom (klass))
175 || (((field->flags & Modifier::PRIVATE) == 0)
176 && _Jv_ClassNameSamePackage (cls->name,
179 /* resove the field using the class' own loader
182 if (!field->isResolved ())
183 _Jv_ResolveField (field, cls->loader);
185 if (field_type != 0 && field->type != field_type)
186 throw new java::lang::LinkageError
188 ("field type mismatch with different loaders"));
191 goto end_of_field_search;
195 throw new java::lang::IllegalAccessError;
203 java::lang::StringBuffer *sb = new java::lang::StringBuffer();
204 sb->append(JvNewStringLatin1("field "));
205 sb->append(owner->getName());
206 sb->append(JvNewStringLatin1("."));
207 sb->append(_Jv_NewStringUTF(field_name->data));
208 sb->append(JvNewStringLatin1(" was not found."));
209 throw_incompatible_class_change_error(sb->toString());
212 pool->data[index].field = the_field;
213 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
217 case JV_CONSTANT_Methodref:
218 case JV_CONSTANT_InterfaceMethodref:
220 _Jv_ushort class_index, name_and_type_index;
221 _Jv_loadIndexes (&pool->data[index],
223 name_and_type_index);
224 jclass owner = (_Jv_ResolvePoolEntry (klass, class_index)).clazz;
227 _Jv_InitClass (owner);
229 _Jv_ushort name_index, type_index;
230 _Jv_loadIndexes (&pool->data[name_and_type_index],
234 _Jv_Utf8Const *method_name = pool->data[name_index].utf8;
235 _Jv_Utf8Const *method_signature = pool->data[type_index].utf8;
237 _Jv_Method *the_method = 0;
238 jclass found_class = 0;
240 // First search the class itself.
241 the_method = _Jv_SearchMethodInClass (owner, klass,
242 method_name, method_signature);
247 goto end_of_method_search;
250 // If we are resolving an interface method, search the
251 // interface's superinterfaces (A superinterface is not an
252 // interface's superclass - a superinterface is implemented by
254 if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref)
259 ifaces.list = (jclass *) _Jv_Malloc (ifaces.len * sizeof (jclass *));
261 _Jv_GetInterfaces (owner, &ifaces);
263 for (int i = 0; i < ifaces.count; i++)
265 jclass cls = ifaces.list[i];
266 the_method = _Jv_SearchMethodInClass (cls, klass, method_name,
275 _Jv_Free (ifaces.list);
278 goto end_of_method_search;
281 // Finally, search superclasses.
282 for (jclass cls = owner->getSuperclass (); cls != 0;
283 cls = cls->getSuperclass ())
285 the_method = _Jv_SearchMethodInClass (cls, klass,
286 method_name, method_signature);
294 end_of_method_search:
296 // FIXME: if (cls->loader != klass->loader), then we
297 // must actually check that the types of arguments
298 // correspond. That is, for each argument type, and
299 // the return type, doing _Jv_FindClassFromSignature
300 // with either loader should produce the same result,
301 // i.e., exactly the same jclass object. JVMS 5.4.3.3
305 java::lang::StringBuffer *sb = new java::lang::StringBuffer();
306 sb->append(JvNewStringLatin1("method "));
307 sb->append(owner->getName());
308 sb->append(JvNewStringLatin1("."));
309 sb->append(_Jv_NewStringUTF(method_name->data));
310 sb->append(JvNewStringLatin1(" was not found."));
311 throw new java::lang::NoSuchMethodError (sb->toString());
314 int vtable_index = -1;
315 if (pool->tags[index] != JV_CONSTANT_InterfaceMethodref)
316 vtable_index = (jshort)the_method->index;
318 pool->data[index].rmethod =
319 _Jv_BuildResolvedMethod(the_method,
321 (the_method->accflags & Modifier::STATIC) != 0,
323 pool->tags[index] |= JV_CONSTANT_ResolvedFlag;
329 return pool->data[index];
332 // Find a method declared in the cls that is referenced from klass and
333 // perform access checks.
335 _Jv_SearchMethodInClass (jclass cls, jclass klass,
336 _Jv_Utf8Const *method_name,
337 _Jv_Utf8Const *method_signature)
339 using namespace java::lang::reflect;
341 for (int i = 0; i < cls->method_count; i++)
343 _Jv_Method *method = &cls->methods[i];
344 if ( (!_Jv_equalUtf8Consts (method->name,
346 || (!_Jv_equalUtf8Consts (method->signature,
351 || ((method->accflags & Modifier::PUBLIC) != 0)
352 || (((method->accflags & Modifier::PROTECTED) != 0)
353 && cls->isAssignableFrom (klass))
354 || (((method->accflags & Modifier::PRIVATE) == 0)
355 && _Jv_ClassNameSamePackage (cls->name,
362 throw new java::lang::IllegalAccessError;
368 // A helper for _Jv_PrepareClass. This adds missing `Miranda methods'
371 _Jv_PrepareMissingMethods (jclass base2, jclass iface_class)
373 _Jv_InterpClass *base = reinterpret_cast<_Jv_InterpClass *> (base2);
374 for (int i = 0; i < iface_class->interface_count; ++i)
376 for (int j = 0; j < iface_class->interfaces[i]->method_count; ++j)
378 _Jv_Method *meth = &iface_class->interfaces[i]->methods[j];
379 // Don't bother with <clinit>.
380 if (meth->name->data[0] == '<')
382 _Jv_Method *new_meth = _Jv_LookupDeclaredMethod (base, meth->name,
386 // We assume that such methods are very unlikely, so we
387 // just reallocate the method array each time one is
388 // found. This greatly simplifies the searching --
389 // otherwise we have to make sure that each such method
390 // found is really unique among all superinterfaces.
391 int new_count = base->method_count + 1;
393 = (_Jv_Method *) _Jv_AllocBytes (sizeof (_Jv_Method)
395 memcpy (new_m, base->methods,
396 sizeof (_Jv_Method) * base->method_count);
399 new_m[base->method_count] = *meth;
400 new_m[base->method_count].index = (_Jv_ushort) -1;
401 new_m[base->method_count].accflags
402 |= java::lang::reflect::Modifier::INVISIBLE;
404 _Jv_MethodBase **new_im
405 = (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
407 memcpy (new_im, base->interpreted_methods,
408 sizeof (_Jv_MethodBase *) * base->method_count);
410 base->methods = new_m;
411 base->interpreted_methods = new_im;
412 base->method_count = new_count;
416 _Jv_PrepareMissingMethods (base, iface_class->interfaces[i]);
421 _Jv_PrepareClass(jclass klass)
423 using namespace java::lang::reflect;
426 * The job of this function is to: 1) assign storage to fields, and 2)
427 * build the vtable. static fields are assigned real memory, instance
428 * fields are assigned offsets.
430 * NOTE: we have a contract with the garbage collector here. Static
431 * reference fields must not be resolved, until after they have storage
432 * assigned which is the check used by the collector to see if it
433 * should indirect the static field reference and mark the object
436 * Most fields are resolved lazily (i.e. have their class-type
437 * assigned) when they are accessed the first time by calling as part
438 * of _Jv_ResolveField, which is allways called after _Jv_PrepareClass.
439 * Static fields with initializers are resolved as part of this
440 * function, as are fields with primitive types.
443 if (! _Jv_IsInterpretedClass (klass))
446 if (klass->state >= JV_STATE_PREPARED)
449 // Make sure super-class is linked. This involves taking a lock on
450 // the super class, so we use the Java method resolveClass, which
451 // will unlock it properly, should an exception happen. If there's
452 // no superclass, do nothing -- Object will already have been
455 if (klass->superclass)
456 java::lang::ClassLoader::resolveClass0 (klass->superclass);
458 _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
460 /************ PART ONE: OBJECT LAYOUT ***************/
465 // Although java.lang.Object is never interpreted, an interface can
466 // have a null superclass.
468 instance_size = clz->superclass->size();
470 instance_size = java::lang::Object::class$.size();
473 for (int i = 0; i < clz->field_count; i++)
478 _Jv_Field *field = &clz->fields[i];
480 if (! field->isRef ())
482 // it's safe to resolve the field here, since it's
483 // a primitive class, which does not cause loading to happen.
484 _Jv_ResolveField (field, clz->loader);
486 field_size = field->type->size ();
487 field_align = get_alignment_from_class (field->type);
491 field_size = sizeof (jobject);
492 field_align = __alignof__ (jobject);
495 #ifndef COMPACT_FIELDS
496 field->bsize = field_size;
499 if (field->flags & Modifier::STATIC)
501 /* this computes an offset into a region we'll allocate
502 shortly, and then add this offset to the start address */
504 static_size = ROUND (static_size, field_align);
505 field->u.boffset = static_size;
506 static_size += field_size;
510 instance_size = ROUND (instance_size, field_align);
511 field->u.boffset = instance_size;
512 instance_size += field_size;
516 // set the instance size for the class
517 clz->size_in_bytes = instance_size;
519 // allocate static memory
520 if (static_size != 0)
522 char *static_data = (char*)_Jv_AllocBytes (static_size);
524 memset (static_data, 0, static_size);
526 for (int i = 0; i < clz->field_count; i++)
528 _Jv_Field *field = &clz->fields[i];
530 if ((field->flags & Modifier::STATIC) != 0)
532 field->u.addr = static_data + field->u.boffset;
534 if (clz->field_initializers[i] != 0)
536 _Jv_ResolveField (field, clz->loader);
537 _Jv_InitField (0, clz, i);
542 // now we don't need the field_initializers anymore, so let the
543 // collector get rid of it!
545 clz->field_initializers = 0;
548 /************ PART TWO: VTABLE LAYOUT ***************/
550 /* preparation: build the vtable stubs (even interfaces can)
551 have code -- for static constructors. */
552 for (int i = 0; i < clz->method_count; i++)
554 _Jv_MethodBase *imeth = clz->interpreted_methods[i];
556 if ((clz->methods[i].accflags & Modifier::NATIVE) != 0)
558 // You might think we could use a virtual `ncode' method in
559 // the _Jv_MethodBase and unify the native and non-native
560 // cases. Well, we can't, because we don't allocate these
561 // objects using `new', and thus they don't get a vtable.
562 _Jv_JNIMethod *jnim = reinterpret_cast<_Jv_JNIMethod *> (imeth);
563 clz->methods[i].ncode = jnim->ncode ();
565 else if (imeth != 0) // it could be abstract
567 _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
568 _Jv_VerifyMethod (im);
569 clz->methods[i].ncode = im->ncode ();
573 if ((clz->accflags & Modifier::INTERFACE))
575 clz->state = JV_STATE_PREPARED;
580 // A class might have so-called "Miranda methods". This is a method
581 // that is declared in an interface and not re-declared in an
582 // abstract class. Some compilers don't emit declarations for such
583 // methods in the class; this will give us problems since we expect
584 // a declaration for any method requiring a vtable entry. We handle
585 // this here by searching for such methods and constructing new
586 // internal declarations for them. We only need to do this for
588 if ((clz->accflags & Modifier::ABSTRACT))
589 _Jv_PrepareMissingMethods (clz, clz);
591 clz->vtable_method_count = -1;
592 _Jv_MakeVTable (clz);
594 /* wooha! we're done. */
595 clz->state = JV_STATE_PREPARED;
599 /** Do static initialization for fields with a constant initializer */
601 _Jv_InitField (jobject obj, jclass klass, int index)
603 using namespace java::lang::reflect;
605 if (obj != 0 && klass == 0)
606 klass = obj->getClass ();
608 if (!_Jv_IsInterpretedClass (klass))
611 _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;
613 _Jv_Field * field = (&clz->fields[0]) + index;
615 if (index > clz->field_count)
616 throw_internal_error ("field out of range");
618 int init = clz->field_initializers[index];
622 _Jv_Constants *pool = &clz->constants;
623 int tag = pool->tags[init];
625 if (! field->isResolved ())
626 throw_internal_error ("initializing unresolved field");
628 if (obj==0 && ((field->flags & Modifier::STATIC) == 0))
629 throw_internal_error ("initializing non-static field with no object");
633 if ((field->flags & Modifier::STATIC) != 0)
634 addr = (void*) field->u.addr;
636 addr = (void*) (((char*)obj) + field->u.boffset);
640 case JV_CONSTANT_String:
642 _Jv_MonitorEnter (clz);
644 str = _Jv_NewStringUtf8Const (pool->data[init].utf8);
645 pool->data[init].string = str;
646 pool->tags[init] = JV_CONSTANT_ResolvedString;
647 _Jv_MonitorExit (clz);
651 case JV_CONSTANT_ResolvedString:
652 if (! (field->type == &StringClass
653 || field->type == &java::lang::Class::class$))
654 throw_class_format_error ("string initialiser to non-string field");
656 *(jstring*)addr = pool->data[init].string;
659 case JV_CONSTANT_Integer:
661 int value = pool->data[init].i;
663 if (field->type == JvPrimClass (boolean))
664 *(jboolean*)addr = (jboolean)value;
666 else if (field->type == JvPrimClass (byte))
667 *(jbyte*)addr = (jbyte)value;
669 else if (field->type == JvPrimClass (char))
670 *(jchar*)addr = (jchar)value;
672 else if (field->type == JvPrimClass (short))
673 *(jshort*)addr = (jshort)value;
675 else if (field->type == JvPrimClass (int))
676 *(jint*)addr = (jint)value;
679 throw_class_format_error ("erroneous field initializer");
683 case JV_CONSTANT_Long:
684 if (field->type != JvPrimClass (long))
685 throw_class_format_error ("erroneous field initializer");
687 *(jlong*)addr = _Jv_loadLong (&pool->data[init]);
690 case JV_CONSTANT_Float:
691 if (field->type != JvPrimClass (float))
692 throw_class_format_error ("erroneous field initializer");
694 *(jfloat*)addr = pool->data[init].f;
697 case JV_CONSTANT_Double:
698 if (field->type != JvPrimClass (double))
699 throw_class_format_error ("erroneous field initializer");
701 *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]);
705 throw_class_format_error ("erroneous field initializer");
710 get_alignment_from_class (jclass klass)
712 if (klass == JvPrimClass (byte))
713 return __alignof__ (jbyte);
714 else if (klass == JvPrimClass (short))
715 return __alignof__ (jshort);
716 else if (klass == JvPrimClass (int))
717 return __alignof__ (jint);
718 else if (klass == JvPrimClass (long))
719 return __alignof__ (jlong);
720 else if (klass == JvPrimClass (boolean))
721 return __alignof__ (jboolean);
722 else if (klass == JvPrimClass (char))
723 return __alignof__ (jchar);
724 else if (klass == JvPrimClass (float))
725 return __alignof__ (jfloat);
726 else if (klass == JvPrimClass (double))
727 return __alignof__ (jdouble);
729 return __alignof__ (jobject);
733 inline static unsigned char*
734 skip_one_type (unsigned char* ptr)
745 do { ch = *ptr++; } while (ch != ';');
752 get_ffi_type_from_signature (unsigned char* ptr)
758 return &ffi_type_pointer;
762 // On some platforms a bool is a byte, on others an int.
763 if (sizeof (jboolean) == sizeof (jbyte))
764 return &ffi_type_sint8;
767 JvAssert (sizeof (jbyte) == sizeof (jint));
768 return &ffi_type_sint32;
773 return &ffi_type_sint8;
777 return &ffi_type_uint16;
781 return &ffi_type_sint16;
785 return &ffi_type_sint32;
789 return &ffi_type_sint64;
793 return &ffi_type_float;
797 return &ffi_type_double;
801 return &ffi_type_void;
805 throw_internal_error ("unknown type in signature");
808 /* this function yields the number of actual arguments, that is, if the
809 * function is non-static, then one is added to the number of elements
810 * found in the signature */
813 _Jv_count_arguments (_Jv_Utf8Const *signature,
816 unsigned char *ptr = (unsigned char*) signature->data;
817 int arg_count = staticp ? 0 : 1;
819 /* first, count number of arguments */
827 ptr = skip_one_type (ptr);
834 /* This beast will build a cif, given the signature. Memory for
835 * the cif itself and for the argument types must be allocated by the
840 init_cif (_Jv_Utf8Const* signature,
844 ffi_type **arg_types,
847 unsigned char *ptr = (unsigned char*) signature->data;
849 int arg_index = 0; // arg number
850 int item_count = 0; // stack-item count
855 arg_types[arg_index++] = &ffi_type_pointer;
865 arg_types[arg_index++] = get_ffi_type_from_signature (ptr);
867 if (*ptr == 'J' || *ptr == 'D')
872 ptr = skip_one_type (ptr);
877 ffi_type *rtype = get_ffi_type_from_signature (ptr);
879 ptr = skip_one_type (ptr);
880 if (ptr != (unsigned char*)signature->data + signature->length)
881 throw_internal_error ("did not find end of signature");
883 if (ffi_prep_cif (cif, FFI_DEFAULT_ABI,
884 arg_count, rtype, arg_types) != FFI_OK)
885 throw_internal_error ("ffi_prep_cif failed");
893 #if FFI_NATIVE_RAW_API
894 # define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure
895 # define FFI_RAW_SIZE ffi_raw_size
897 # define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure
898 # define FFI_RAW_SIZE ffi_java_raw_size
901 /* we put this one here, and not in interpret.cc because it
902 * calls the utility routines _Jv_count_arguments
903 * which are static to this module. The following struct defines the
904 * layout we use for the stubs, it's only used in the ncode method. */
907 ffi_raw_closure closure;
909 ffi_type *arg_types[0];
912 typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_raw*,void*);
915 _Jv_InterpMethod::ncode ()
917 using namespace java::lang::reflect;
919 if (self->ncode != 0)
922 jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
923 int arg_count = _Jv_count_arguments (self->signature, staticp);
925 ncode_closure *closure =
926 (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
927 + arg_count * sizeof (ffi_type*));
929 init_cif (self->signature,
933 &closure->arg_types[0],
938 args_raw_size = FFI_RAW_SIZE (&closure->cif);
940 JvAssert ((self->accflags & Modifier::NATIVE) == 0);
942 if ((self->accflags & Modifier::SYNCHRONIZED) != 0)
945 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class;
947 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object;
952 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class;
954 fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal;
957 FFI_PREP_RAW_CLOSURE (&closure->closure,
962 self->ncode = (void*)closure;
967 _Jv_JNIMethod::ncode ()
969 using namespace java::lang::reflect;
971 if (self->ncode != 0)
974 jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
975 int arg_count = _Jv_count_arguments (self->signature, staticp);
977 ncode_closure *closure =
978 (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
979 + arg_count * sizeof (ffi_type*));
982 init_cif (self->signature,
986 &closure->arg_types[0],
991 args_raw_size = FFI_RAW_SIZE (&closure->cif);
993 // Initialize the argument types and CIF that represent the actual
994 // underlying JNI function.
996 if ((self->accflags & Modifier::STATIC))
998 jni_arg_types = (ffi_type **) _Jv_Malloc ((extra_args + arg_count)
999 * sizeof (ffi_type *));
1001 jni_arg_types[offset++] = &ffi_type_pointer;
1002 if ((self->accflags & Modifier::STATIC))
1003 jni_arg_types[offset++] = &ffi_type_pointer;
1004 memcpy (&jni_arg_types[offset], &closure->arg_types[0],
1005 arg_count * sizeof (ffi_type *));
1007 if (ffi_prep_cif (&jni_cif, _Jv_platform_ffi_abi,
1008 extra_args + arg_count, rtype,
1009 jni_arg_types) != FFI_OK)
1010 throw_internal_error ("ffi_prep_cif failed for JNI function");
1012 JvAssert ((self->accflags & Modifier::NATIVE) != 0);
1014 // FIXME: for now we assume that all native methods for
1015 // interpreted code use JNI.
1016 fun = (ffi_closure_fun) &_Jv_JNIMethod::call;
1018 FFI_PREP_RAW_CLOSURE (&closure->closure,
1023 self->ncode = (void *) closure;
1028 /* A _Jv_ResolvedMethod is what is put in the constant pool for a
1029 * MethodRef or InterfacemethodRef. */
1030 static _Jv_ResolvedMethod*
1031 _Jv_BuildResolvedMethod (_Jv_Method* method,
1036 int arg_count = _Jv_count_arguments (method->signature, staticp);
1038 _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*)
1039 _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod)
1040 + arg_count*sizeof (ffi_type*));
1042 result->stack_item_count
1043 = init_cif (method->signature,
1047 &result->arg_types[0],
1050 result->vtable_index = vtable_index;
1051 result->method = method;
1052 result->klass = klass;
1059 throw_class_format_error (jstring msg)
1062 ? new java::lang::ClassFormatError (msg)
1063 : new java::lang::ClassFormatError);
1067 throw_class_format_error (char *msg)
1069 throw_class_format_error (JvNewStringLatin1 (msg));
1073 throw_internal_error (char *msg)
1075 throw new java::lang::InternalError (JvNewStringLatin1 (msg));
1079 #endif /* INTERPRETER */