// resolve.cc - Code for linking and resolving classes and pool entries. /* Copyright (C) 1999, 2000, 2001 , 2002 Free Software Foundation This file is part of libgcj. This software is copyrighted work licensed under the terms of the Libgcj License. Please consult the file "LIBGCJ_LICENSE" for details. */ /* Author: Kresten Krab Thorup */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace gcj; void _Jv_ResolveField (_Jv_Field *field, java::lang::ClassLoader *loader) { if (! field->isResolved ()) { _Jv_Utf8Const *sig = (_Jv_Utf8Const*)field->type; field->type = _Jv_FindClassFromSignature (sig->data, loader); field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG; } } #ifdef INTERPRETER static void throw_internal_error (char *msg) __attribute__ ((__noreturn__)); static void throw_class_format_error (jstring msg) __attribute__ ((__noreturn__)); static void throw_class_format_error (char *msg) __attribute__ ((__noreturn__)); // Exceptional return values for _Jv_DetermineVTableIndex #define METHOD_NOT_THERE (-2) #define METHOD_INACCESSIBLE (-1) static int get_alignment_from_class (jclass); static _Jv_ResolvedMethod* _Jv_BuildResolvedMethod (_Jv_Method*, jclass, jboolean, jint); static void throw_incompatible_class_change_error (jstring msg) { throw new java::lang::IncompatibleClassChangeError (msg); } _Jv_word _Jv_ResolvePoolEntry (jclass klass, int index) { using namespace java::lang::reflect; _Jv_Constants *pool = &klass->constants; if ((pool->tags[index] & JV_CONSTANT_ResolvedFlag) != 0) return pool->data[index]; switch (pool->tags[index]) { case JV_CONSTANT_Class: { _Jv_Utf8Const *name = pool->data[index].utf8; jclass found; if (name->data[0] == '[') found = _Jv_FindClassFromSignature (&name->data[0], klass->loader); else found = _Jv_FindClass (name, klass->loader); if (! found) { jstring str = _Jv_NewStringUTF (name->data); throw new java::lang::ClassNotFoundException (str); } if ((found->accflags & Modifier::PUBLIC) == Modifier::PUBLIC || (_Jv_ClassNameSamePackage (found->name, klass->name))) { pool->data[index].clazz = found; pool->tags[index] |= JV_CONSTANT_ResolvedFlag; } else { throw new java::lang::IllegalAccessError (found->getName()); } } break; case JV_CONSTANT_String: { jstring str; str = _Jv_NewStringUtf8Const (pool->data[index].utf8); pool->data[index].o = str; pool->tags[index] |= JV_CONSTANT_ResolvedFlag; } break; case JV_CONSTANT_Fieldref: { _Jv_ushort class_index, name_and_type_index; _Jv_loadIndexes (&pool->data[index], class_index, name_and_type_index); jclass owner = (_Jv_ResolvePoolEntry (klass, class_index)).clazz; if (owner != klass) _Jv_InitClass (owner); _Jv_ushort name_index, type_index; _Jv_loadIndexes (&pool->data[name_and_type_index], name_index, type_index); _Jv_Utf8Const *field_name = pool->data[name_index].utf8; _Jv_Utf8Const *field_type_name = pool->data[type_index].utf8; // FIXME: The implementation of this function // (_Jv_FindClassFromSignature) will generate an instance of // _Jv_Utf8Const for each call if the field type is a class name // (Lxx.yy.Z;). This may be too expensive to do for each and // every fieldref being resolved. For now, we fix the problem by // only doing it when we have a loader different from the class // declaring the field. jclass field_type = 0; if (owner->loader != klass->loader) field_type = _Jv_FindClassFromSignature (field_type_name->data, klass->loader); _Jv_Field* the_field = 0; for (jclass cls = owner; cls != 0; cls = cls->getSuperclass ()) { for (int i = 0; i < cls->field_count; i++) { _Jv_Field *field = &cls->fields[i]; if (! _Jv_equalUtf8Consts (field->name, field_name)) continue; // now, check field access. if ( (cls == klass) || ((field->flags & Modifier::PUBLIC) != 0) || (((field->flags & Modifier::PROTECTED) != 0) && cls->isAssignableFrom (klass)) || (((field->flags & Modifier::PRIVATE) == 0) && _Jv_ClassNameSamePackage (cls->name, klass->name))) { /* resove the field using the class' own loader if necessary */ if (!field->isResolved ()) _Jv_ResolveField (field, cls->loader); if (field_type != 0 && field->type != field_type) throw new java::lang::LinkageError (JvNewStringLatin1 ("field type mismatch with different loaders")); the_field = field; goto end_of_field_search; } else { throw new java::lang::IllegalAccessError; } } } end_of_field_search: if (the_field == 0) { jstring msg = JvNewStringLatin1 ("field "); msg = msg->concat (owner->getName ()); msg = msg->concat (JvNewStringLatin1(".")); msg = msg->concat (_Jv_NewStringUTF (field_name->data)); msg = msg->concat (JvNewStringLatin1(" was not found.")); throw_incompatible_class_change_error (msg); } pool->data[index].field = the_field; pool->tags[index] |= JV_CONSTANT_ResolvedFlag; } break; case JV_CONSTANT_Methodref: case JV_CONSTANT_InterfaceMethodref: { _Jv_ushort class_index, name_and_type_index; _Jv_loadIndexes (&pool->data[index], class_index, name_and_type_index); jclass owner = (_Jv_ResolvePoolEntry (klass, class_index)).clazz; if (owner != klass) _Jv_InitClass (owner); _Jv_ushort name_index, type_index; _Jv_loadIndexes (&pool->data[name_and_type_index], name_index, type_index); _Jv_Utf8Const *method_name = pool->data[name_index].utf8; _Jv_Utf8Const *method_signature = pool->data[type_index].utf8; int vtable_index = -1; _Jv_Method *the_method = 0; jclass found_class = 0; // First search the class itself. the_method = _Jv_SearchMethodInClass (owner, klass, method_name, method_signature); if (the_method != 0) { found_class = owner; goto end_of_method_search; } // If we are resolving an interface method, search the interface's // superinterfaces (A superinterface is not an interface's superclass - // a superinterface is implemented by the interface). if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref) { _Jv_ifaces ifaces; ifaces.count = 0; ifaces.len = 4; ifaces.list = (jclass *) _Jv_Malloc (ifaces.len * sizeof (jclass *)); _Jv_GetInterfaces (owner, &ifaces); for (int i=0; i < ifaces.count; i++) { jclass cls = ifaces.list[i]; the_method = _Jv_SearchMethodInClass (cls, klass, method_name, method_signature); if (the_method != 0) { found_class = cls; break; } } _Jv_Free (ifaces.list); if (the_method != 0) goto end_of_method_search; } // Finally, search superclasses. for (jclass cls = owner->getSuperclass (); cls != 0; cls = cls->getSuperclass ()) { the_method = _Jv_SearchMethodInClass (cls, klass, method_name, method_signature); if (the_method != 0) { found_class = cls; break; } } end_of_method_search: // FIXME: if (cls->loader != klass->loader), then we // must actually check that the types of arguments // correspond. That is, for each argument type, and // the return type, doing _Jv_FindClassFromSignature // with either loader should produce the same result, // i.e., exactly the same jclass object. JVMS 5.4.3.3 if (pool->tags[index] == JV_CONSTANT_InterfaceMethodref) vtable_index = -1; else vtable_index = _Jv_DetermineVTableIndex (found_class, method_name, method_signature); if (vtable_index == METHOD_NOT_THERE) throw_incompatible_class_change_error (JvNewStringLatin1 ("method not found")); if (the_method == 0) { jstring msg = JvNewStringLatin1 ("method "); msg = msg->concat (owner->getName ()); msg = msg->concat (JvNewStringLatin1(".")); msg = msg->concat (_Jv_NewStringUTF (method_name->data)); msg = msg->concat (JvNewStringLatin1(" was not found.")); throw new java::lang::NoSuchMethodError (msg); } pool->data[index].rmethod = _Jv_BuildResolvedMethod(the_method, found_class, (the_method->accflags & Modifier::STATIC) != 0, vtable_index); pool->tags[index] |= JV_CONSTANT_ResolvedFlag; } break; } return pool->data[index]; } // Find a method declared in the cls that is referenced from klass and // perform access checks. _Jv_Method * _Jv_SearchMethodInClass (jclass cls, jclass klass, _Jv_Utf8Const *method_name, _Jv_Utf8Const *method_signature) { using namespace java::lang::reflect; for (int i = 0; i < cls->method_count; i++) { _Jv_Method *method = &cls->methods[i]; if ( (!_Jv_equalUtf8Consts (method->name, method_name)) || (!_Jv_equalUtf8Consts (method->signature, method_signature))) continue; if (cls == klass || ((method->accflags & Modifier::PUBLIC) != 0) || (((method->accflags & Modifier::PROTECTED) != 0) && cls->isAssignableFrom (klass)) || (((method->accflags & Modifier::PRIVATE) == 0) && _Jv_ClassNameSamePackage (cls->name, klass->name))) { return method; } else { throw new java::lang::IllegalAccessError; } } return 0; } /** FIXME: this is a terribly inefficient algorithm! It would improve things if compiled classes to know vtable offset, and _Jv_Method had a field for this. Returns METHOD_NOT_THERE if this class does not declare the given method. Returns METHOD_INACCESSIBLE if the given method does not appear in the vtable, i.e., it is static, private, final or a constructor. Otherwise, returns the vtable index. */ int _Jv_DetermineVTableIndex (jclass klass, _Jv_Utf8Const *name, _Jv_Utf8Const *signature) { using namespace java::lang::reflect; jclass super_class = klass->getSuperclass (); if (super_class != NULL) { int prev = _Jv_DetermineVTableIndex (super_class, name, signature); if (prev != METHOD_NOT_THERE) return prev; } /* at this point, we know that the super-class does not declare * the method. Otherwise, the above call would have found it, and * determined the result of this function (-1 or some positive * number). */ _Jv_Method *meth = _Jv_GetMethodLocal (klass, name, signature); /* now, if we do not declare this method, return zero */ if (meth == NULL) return METHOD_NOT_THERE; /* so now, we know not only that the super class does not declare the * method, but we do! So, this is a first declaration of the method. */ /* now, the checks for things that are declared in this class, but do * not go into the vtable. There are three cases. * 1) the method is static, private or final * 2) the class itself is final, or * 3) it is the method */ if ((meth->accflags & (Modifier::STATIC | Modifier::PRIVATE | Modifier::FINAL)) != 0 || (klass->accflags & Modifier::FINAL) != 0 || _Jv_equalUtf8Consts (name, init_name)) return METHOD_INACCESSIBLE; /* reaching this point, we know for sure, that the method in question * will be in the vtable. The question is where. */ /* the base offset, is where we will start assigning vtable * indexes for this class. It is 0 for base classes * and for non-base classes it is the * number of entries in the super class' vtable. */ int base_offset; if (super_class == 0) base_offset = 0; else base_offset = super_class->vtable_method_count; /* we will consider methods 0..this_method_index-1. And for each one, * determine if it is new (i.e., if it appears in the super class), * and if it should go in the vtable. If so, increment base_offset */ int this_method_index = meth - (&klass->methods[0]); for (int i = 0; i < this_method_index; i++) { _Jv_Method *m = &klass->methods[i]; /* fist some checks for things that surely do not go in the * vtable */ if ((m->accflags & (Modifier::STATIC | Modifier::PRIVATE)) != 0) continue; if (_Jv_equalUtf8Consts (m->name, init_name)) continue; /* Then, we need to know if this method appears in the superclass. (This is where this function gets expensive) */ _Jv_Method *sm = _Jv_LookupDeclaredMethod (super_class, m->name, m->signature); /* if it was somehow declared in the superclass, skip this */ if (sm != NULL) continue; /* but if it is final, and not declared in the super class, * then we also skip it */ if ((m->accflags & Modifier::FINAL) != 0) continue; /* finally, we can assign the index of this method */ /* m->vtable_index = base_offset */ base_offset += 1; } return base_offset; } /* this is installed in place of abstract methods */ static void _Jv_abstractMethodError () { throw new java::lang::AbstractMethodError; } void _Jv_PrepareClass(jclass klass) { using namespace java::lang::reflect; /* * The job of this function is to: 1) assign storage to fields, and 2) * build the vtable. static fields are assigned real memory, instance * fields are assigned offsets. * * NOTE: we have a contract with the garbage collector here. Static * reference fields must not be resolved, until after they have storage * assigned which is the check used by the collector to see if it * should indirect the static field reference and mark the object * pointed to. * * Most fields are resolved lazily (i.e. have their class-type * assigned) when they are accessed the first time by calling as part * of _Jv_ResolveField, which is allways called after _Jv_PrepareClass. * Static fields with initializers are resolved as part of this * function, as are fields with primitive types. */ if (! _Jv_IsInterpretedClass (klass)) return; if (klass->state >= JV_STATE_PREPARED) return; // Make sure super-class is linked. This involves taking a lock on // the super class, so we use the Java method resolveClass, which // will unlock it properly, should an exception happen. If there's // no superclass, do nothing -- Object will already have been // resolved. if (klass->superclass) java::lang::ClassLoader::resolveClass0 (klass->superclass); _Jv_InterpClass *clz = (_Jv_InterpClass*)klass; /************ PART ONE: OBJECT LAYOUT ***************/ int instance_size; int static_size; // Although java.lang.Object is never interpreted, an interface can // have a null superclass. if (clz->superclass) instance_size = clz->superclass->size(); else instance_size = java::lang::Object::class$.size(); static_size = 0; for (int i = 0; i < clz->field_count; i++) { int field_size; int field_align; _Jv_Field *field = &clz->fields[i]; if (! field->isRef ()) { // it's safe to resolve the field here, since it's // a primitive class, which does not cause loading to happen. _Jv_ResolveField (field, clz->loader); field_size = field->type->size (); field_align = get_alignment_from_class (field->type); } else { field_size = sizeof (jobject); field_align = __alignof__ (jobject); } #ifndef COMPACT_FIELDS field->bsize = field_size; #endif if (field->flags & Modifier::STATIC) { /* this computes an offset into a region we'll allocate shortly, and then add this offset to the start address */ static_size = ROUND (static_size, field_align); field->u.boffset = static_size; static_size += field_size; } else { instance_size = ROUND (instance_size, field_align); field->u.boffset = instance_size; instance_size += field_size; } } // set the instance size for the class clz->size_in_bytes = instance_size; // allocate static memory if (static_size != 0) { char *static_data = (char*)_Jv_AllocBytes (static_size); memset (static_data, 0, static_size); for (int i = 0; i < clz->field_count; i++) { _Jv_Field *field = &clz->fields[i]; if ((field->flags & Modifier::STATIC) != 0) { field->u.addr = static_data + field->u.boffset; if (clz->field_initializers[i] != 0) { _Jv_ResolveField (field, clz->loader); _Jv_InitField (0, clz, i); } } } // now we don't need the field_initializers anymore, so let the // collector get rid of it! clz->field_initializers = 0; } /************ PART TWO: VTABLE LAYOUT ***************/ /* preparation: build the vtable stubs (even interfaces can) have code -- for static constructors. */ for (int i = 0; i < clz->method_count; i++) { _Jv_MethodBase *imeth = clz->interpreted_methods[i]; if ((clz->methods[i].accflags & Modifier::NATIVE) != 0) { // You might think we could use a virtual `ncode' method in // the _Jv_MethodBase and unify the native and non-native // cases. Well, we can't, because we don't allocate these // objects using `new', and thus they don't get a vtable. _Jv_JNIMethod *jnim = reinterpret_cast<_Jv_JNIMethod *> (imeth); clz->methods[i].ncode = jnim->ncode (); } else if (imeth != 0) // it could be abstract { _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth); _Jv_VerifyMethod (im); clz->methods[i].ncode = im->ncode (); } } if (clz->accflags & Modifier::INTERFACE) { clz->state = JV_STATE_PREPARED; clz->notifyAll (); return; } /* Now onto the actual job: vtable layout. First, count how many new methods we have */ int new_method_count = 0; jclass super_class = clz->getSuperclass (); for (int i = 0; i < clz->method_count; i++) { _Jv_Method *this_meth = &clz->methods[i]; if ((this_meth->accflags & (Modifier::STATIC | Modifier::PRIVATE)) != 0 || _Jv_equalUtf8Consts (this_meth->name, init_name)) { /* skip this, it doesn't go in the vtable */ continue; } _Jv_Method *orig_meth = _Jv_LookupDeclaredMethod (super_class, this_meth->name, this_meth->signature); if (orig_meth == 0) { // new methods that are final, also don't go in the vtable if ((this_meth->accflags & Modifier::FINAL) != 0) continue; new_method_count += 1; continue; } if ((orig_meth->accflags & (Modifier::STATIC | Modifier::PRIVATE | Modifier::FINAL)) != 0 || ((orig_meth->accflags & Modifier::ABSTRACT) == 0 && (this_meth->accflags & Modifier::ABSTRACT) != 0 && (klass->accflags & Modifier::ABSTRACT) == 0)) { clz->state = JV_STATE_ERROR; clz->notifyAll (); throw new java::lang::IncompatibleClassChangeError (clz->getName ()); } /* FIXME: At this point, if (loader != super_class->loader), we * need to "impose class loader constraints" for the types * involved in the signature of this method */ } /* determine size */ int vtable_count = (super_class->vtable_method_count) + new_method_count; clz->vtable_method_count = vtable_count; /* allocate vtable structure */ _Jv_VTable *vtable = _Jv_VTable::new_vtable (vtable_count); vtable->clas = clz; vtable->gc_descr = _Jv_BuildGCDescr(clz); { jclass effective_superclass = super_class; /* If super_class is abstract or an interface it has no vtable. We need to find a real one... */ while (effective_superclass && effective_superclass->vtable == NULL) effective_superclass = effective_superclass->superclass; /* If we ended up without a superclass, use Object. */ if (! effective_superclass) effective_superclass = &java::lang::Object::class$; /* copy super class' vtable entries. */ if (effective_superclass && effective_superclass->vtable) for (int i = 0; i < effective_superclass->vtable_method_count; ++i) vtable->set_method (i, effective_superclass->vtable->get_method (i)); } /* now, install our own vtable entries, reprise... */ for (int i = 0; i < clz->method_count; i++) { _Jv_Method *this_meth = &clz->methods[i]; int index = _Jv_DetermineVTableIndex (clz, this_meth->name, this_meth->signature); if (index == METHOD_NOT_THERE) throw_internal_error ("method now found in own class"); if (index != METHOD_INACCESSIBLE) { if (index > clz->vtable_method_count) throw_internal_error ("vtable problem..."); if (clz->interpreted_methods[i] == 0) vtable->set_method(index, (void*)&_Jv_abstractMethodError); else vtable->set_method(index, this_meth->ncode); } } /* finally, assign the vtable! */ clz->vtable = vtable; /* wooha! we're done. */ clz->state = JV_STATE_PREPARED; clz->notifyAll (); } /** Do static initialization for fields with a constant initializer */ void _Jv_InitField (jobject obj, jclass klass, int index) { using namespace java::lang::reflect; if (obj != 0 && klass == 0) klass = obj->getClass (); if (!_Jv_IsInterpretedClass (klass)) return; _Jv_InterpClass *clz = (_Jv_InterpClass*)klass; _Jv_Field * field = (&clz->fields[0]) + index; if (index > clz->field_count) throw_internal_error ("field out of range"); int init = clz->field_initializers[index]; if (init == 0) return; _Jv_Constants *pool = &clz->constants; int tag = pool->tags[init]; if (! field->isResolved ()) throw_internal_error ("initializing unresolved field"); if (obj==0 && ((field->flags & Modifier::STATIC) == 0)) throw_internal_error ("initializing non-static field with no object"); void *addr = 0; if ((field->flags & Modifier::STATIC) != 0) addr = (void*) field->u.addr; else addr = (void*) (((char*)obj) + field->u.boffset); switch (tag) { case JV_CONSTANT_String: { _Jv_MonitorEnter (clz); jstring str; str = _Jv_NewStringUtf8Const (pool->data[init].utf8); pool->data[init].string = str; pool->tags[init] = JV_CONSTANT_ResolvedString; _Jv_MonitorExit (clz); } /* fall through */ case JV_CONSTANT_ResolvedString: if (! (field->type == &StringClass || field->type == &java::lang::Class::class$)) throw_class_format_error ("string initialiser to non-string field"); *(jstring*)addr = pool->data[init].string; break; case JV_CONSTANT_Integer: { int value = pool->data[init].i; if (field->type == JvPrimClass (boolean)) *(jboolean*)addr = (jboolean)value; else if (field->type == JvPrimClass (byte)) *(jbyte*)addr = (jbyte)value; else if (field->type == JvPrimClass (char)) *(jchar*)addr = (jchar)value; else if (field->type == JvPrimClass (short)) *(jshort*)addr = (jshort)value; else if (field->type == JvPrimClass (int)) *(jint*)addr = (jint)value; else throw_class_format_error ("erroneous field initializer"); } break; case JV_CONSTANT_Long: if (field->type != JvPrimClass (long)) throw_class_format_error ("erroneous field initializer"); *(jlong*)addr = _Jv_loadLong (&pool->data[init]); break; case JV_CONSTANT_Float: if (field->type != JvPrimClass (float)) throw_class_format_error ("erroneous field initializer"); *(jfloat*)addr = pool->data[init].f; break; case JV_CONSTANT_Double: if (field->type != JvPrimClass (double)) throw_class_format_error ("erroneous field initializer"); *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]); break; default: throw_class_format_error ("erroneous field initializer"); } } static int get_alignment_from_class (jclass klass) { if (klass == JvPrimClass (byte)) return __alignof__ (jbyte); else if (klass == JvPrimClass (short)) return __alignof__ (jshort); else if (klass == JvPrimClass (int)) return __alignof__ (jint); else if (klass == JvPrimClass (long)) return __alignof__ (jlong); else if (klass == JvPrimClass (boolean)) return __alignof__ (jboolean); else if (klass == JvPrimClass (char)) return __alignof__ (jchar); else if (klass == JvPrimClass (float)) return __alignof__ (jfloat); else if (klass == JvPrimClass (double)) return __alignof__ (jdouble); else return __alignof__ (jobject); } inline static unsigned char* skip_one_type (unsigned char* ptr) { int ch = *ptr++; while (ch == '[') { ch = *ptr++; } if (ch == 'L') { do { ch = *ptr++; } while (ch != ';'); } return ptr; } static ffi_type* get_ffi_type_from_signature (unsigned char* ptr) { switch (*ptr) { case 'L': case '[': return &ffi_type_pointer; break; case 'Z': // On some platforms a bool is a byte, on others an int. if (sizeof (jboolean) == sizeof (jbyte)) return &ffi_type_sint8; else { JvAssert (sizeof (jbyte) == sizeof (jint)); return &ffi_type_sint32; } break; case 'B': return &ffi_type_sint8; break; case 'C': return &ffi_type_uint16; break; case 'S': return &ffi_type_sint16; break; case 'I': return &ffi_type_sint32; break; case 'J': return &ffi_type_sint64; break; case 'F': return &ffi_type_float; break; case 'D': return &ffi_type_double; break; case 'V': return &ffi_type_void; break; } throw_internal_error ("unknown type in signature"); } /* this function yields the number of actual arguments, that is, if the * function is non-static, then one is added to the number of elements * found in the signature */ int _Jv_count_arguments (_Jv_Utf8Const *signature, jboolean staticp) { unsigned char *ptr = (unsigned char*) signature->data; int arg_count = staticp ? 0 : 1; /* first, count number of arguments */ // skip '(' ptr++; // count args while (*ptr != ')') { ptr = skip_one_type (ptr); arg_count += 1; } return arg_count; } /* This beast will build a cif, given the signature. Memory for * the cif itself and for the argument types must be allocated by the * caller. */ static int init_cif (_Jv_Utf8Const* signature, int arg_count, jboolean staticp, ffi_cif *cif, ffi_type **arg_types, ffi_type **rtype_p) { unsigned char *ptr = (unsigned char*) signature->data; int arg_index = 0; // arg number int item_count = 0; // stack-item count // setup receiver if (!staticp) { arg_types[arg_index++] = &ffi_type_pointer; item_count += 1; } // skip '(' ptr++; // assign arg types while (*ptr != ')') { arg_types[arg_index++] = get_ffi_type_from_signature (ptr); if (*ptr == 'J' || *ptr == 'D') item_count += 2; else item_count += 1; ptr = skip_one_type (ptr); } // skip ')' ptr++; ffi_type *rtype = get_ffi_type_from_signature (ptr); ptr = skip_one_type (ptr); if (ptr != (unsigned char*)signature->data + signature->length) throw_internal_error ("did not find end of signature"); if (ffi_prep_cif (cif, FFI_DEFAULT_ABI, arg_count, rtype, arg_types) != FFI_OK) throw_internal_error ("ffi_prep_cif failed"); if (rtype_p != NULL) *rtype_p = rtype; return item_count; } #if FFI_NATIVE_RAW_API # define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure # define FFI_RAW_SIZE ffi_raw_size #else # define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure # define FFI_RAW_SIZE ffi_java_raw_size #endif /* we put this one here, and not in interpret.cc because it * calls the utility routines _Jv_count_arguments * which are static to this module. The following struct defines the * layout we use for the stubs, it's only used in the ncode method. */ typedef struct { ffi_raw_closure closure; ffi_cif cif; ffi_type *arg_types[0]; } ncode_closure; typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_raw*,void*); void * _Jv_InterpMethod::ncode () { using namespace java::lang::reflect; if (self->ncode != 0) return self->ncode; jboolean staticp = (self->accflags & Modifier::STATIC) != 0; int arg_count = _Jv_count_arguments (self->signature, staticp); ncode_closure *closure = (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure) + arg_count * sizeof (ffi_type*)); init_cif (self->signature, arg_count, staticp, &closure->cif, &closure->arg_types[0], NULL); ffi_closure_fun fun; args_raw_size = FFI_RAW_SIZE (&closure->cif); JvAssert ((self->accflags & Modifier::NATIVE) == 0); if ((self->accflags & Modifier::SYNCHRONIZED) != 0) { if (staticp) fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class; else fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object; } else { fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal; } FFI_PREP_RAW_CLOSURE (&closure->closure, &closure->cif, fun, (void*)this); self->ncode = (void*)closure; return self->ncode; } void * _Jv_JNIMethod::ncode () { using namespace java::lang::reflect; if (self->ncode != 0) return self->ncode; jboolean staticp = (self->accflags & Modifier::STATIC) != 0; int arg_count = _Jv_count_arguments (self->signature, staticp); ncode_closure *closure = (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure) + arg_count * sizeof (ffi_type*)); ffi_type *rtype; init_cif (self->signature, arg_count, staticp, &closure->cif, &closure->arg_types[0], &rtype); ffi_closure_fun fun; args_raw_size = FFI_RAW_SIZE (&closure->cif); // Initialize the argument types and CIF that represent the actual // underlying JNI function. int extra_args = 1; if ((self->accflags & Modifier::STATIC)) ++extra_args; jni_arg_types = (ffi_type **) _Jv_Malloc ((extra_args + arg_count) * sizeof (ffi_type *)); int offset = 0; jni_arg_types[offset++] = &ffi_type_pointer; if ((self->accflags & Modifier::STATIC)) jni_arg_types[offset++] = &ffi_type_pointer; memcpy (&jni_arg_types[offset], &closure->arg_types[0], arg_count * sizeof (ffi_type *)); if (ffi_prep_cif (&jni_cif, FFI_DEFAULT_ABI, extra_args + arg_count, rtype, jni_arg_types) != FFI_OK) throw_internal_error ("ffi_prep_cif failed for JNI function"); JvAssert ((self->accflags & Modifier::NATIVE) != 0); // FIXME: for now we assume that all native methods for // interpreted code use JNI. fun = (ffi_closure_fun) &_Jv_JNIMethod::call; FFI_PREP_RAW_CLOSURE (&closure->closure, &closure->cif, fun, (void*) this); self->ncode = (void *) closure; return self->ncode; } /* A _Jv_ResolvedMethod is what is put in the constant pool for a * MethodRef or InterfacemethodRef. */ static _Jv_ResolvedMethod* _Jv_BuildResolvedMethod (_Jv_Method* method, jclass klass, jboolean staticp, jint vtable_index) { int arg_count = _Jv_count_arguments (method->signature, staticp); _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*) _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod) + arg_count*sizeof (ffi_type*)); result->stack_item_count = init_cif (method->signature, arg_count, staticp, &result->cif, &result->arg_types[0], NULL); result->vtable_index = vtable_index; result->method = method; result->klass = klass; return result; } static void throw_class_format_error (jstring msg) { throw (msg ? new java::lang::ClassFormatError (msg) : new java::lang::ClassFormatError); } static void throw_class_format_error (char *msg) { throw_class_format_error (JvNewStringLatin1 (msg)); } static void throw_internal_error (char *msg) { throw new java::lang::InternalError (JvNewStringLatin1 (msg)); } #endif /* INTERPRETER */