1 // natMethod.cc - Native code for Method class.
3 /* Copyright (C) 1998, 1999, 2000, 2001 , 2002, 2003, 2004, 2005, 2006 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
16 #include <java-stack.h>
18 #include <java/lang/reflect/Method.h>
19 #include <java/lang/reflect/Constructor.h>
20 #include <java/lang/reflect/InvocationTargetException.h>
21 #include <java/lang/reflect/Modifier.h>
23 #include <java/lang/Void.h>
24 #include <java/lang/Byte.h>
25 #include <java/lang/Boolean.h>
26 #include <java/lang/Character.h>
27 #include <java/lang/Short.h>
28 #include <java/lang/Integer.h>
29 #include <java/lang/Long.h>
30 #include <java/lang/Float.h>
31 #include <java/lang/Double.h>
32 #include <java/lang/IllegalAccessException.h>
33 #include <java/lang/IllegalArgumentException.h>
34 #include <java/lang/IncompatibleClassChangeError.h>
35 #include <java/lang/NullPointerException.h>
36 #include <java/lang/ArrayIndexOutOfBoundsException.h>
37 #include <java/lang/VirtualMachineError.h>
38 #include <java/lang/Class.h>
39 #include <gcj/method.h>
40 #include <gnu/gcj/RawData.h>
41 #include <java/lang/NoClassDefFoundError.h>
48 #include <java/lang/UnsupportedOperationException.h>
51 typedef JArray< ::java::lang::annotation::Annotation * > * anno_a_t;
52 typedef JArray< JArray< ::java::lang::annotation::Annotation * > *> * anno_aa_t;
62 // This is used to determine when a primitive widening conversion is
64 static cpair primitives[] =
67 { JvPrimClass (boolean), &java::lang::Boolean::class$ },
68 { JvPrimClass (byte), &java::lang::Byte::class$ },
70 { JvPrimClass (short), &java::lang::Short::class$ },
72 { JvPrimClass (char), &java::lang::Character::class$ },
73 { JvPrimClass (int), &java::lang::Integer::class$ },
74 { JvPrimClass (long), &java::lang::Long::class$ },
75 { JvPrimClass (float), &java::lang::Float::class$ },
76 { JvPrimClass (double), &java::lang::Double::class$ },
80 static inline jboolean
81 can_widen (jclass from, jclass to)
83 int fromx = -1, tox = -1;
85 for (int i = 0; primitives[i].prim; ++i)
87 if (primitives[i].wrap == from)
89 if (primitives[i].prim == to)
93 // Can't handle a miss.
94 if (fromx == -1 || tox == -1)
96 // Boolean arguments may not be widened.
97 if (fromx == BOOLEAN && tox != BOOLEAN)
99 // Nothing promotes to char.
100 if (tox == CHAR && fromx != CHAR)
107 static inline ffi_type *
108 get_ffi_type (jclass klass)
112 return &ffi_type_pointer;
115 if (klass == JvPrimClass (byte))
117 else if (klass == JvPrimClass (short))
118 r = &ffi_type_sint16;
119 else if (klass == JvPrimClass (int))
120 r = &ffi_type_sint32;
121 else if (klass == JvPrimClass (long))
122 r = &ffi_type_sint64;
123 else if (klass == JvPrimClass (float))
125 else if (klass == JvPrimClass (double))
126 r = &ffi_type_double;
127 else if (klass == JvPrimClass (boolean))
129 // On some platforms a bool is a byte, on others an int.
130 if (sizeof (jboolean) == sizeof (jbyte))
134 JvAssert (sizeof (jboolean) == sizeof (jint));
135 r = &ffi_type_sint32;
138 else if (klass == JvPrimClass (char))
139 r = &ffi_type_uint16;
142 JvAssert (! klass->isPrimitive());
143 r = &ffi_type_pointer;
151 java::lang::reflect::Method::invoke (jobject obj, jobjectArray args)
153 using namespace java::lang::reflect;
156 if (parameter_types == NULL)
159 jmethodID meth = _Jv_FromReflectedMethod (this);
161 if (Modifier::isStatic(meth->accflags))
163 // We have to initialize a static class. It is safe to do this
164 // here and not in _Jv_CallAnyMethodA because JNI initializes a
165 // class whenever a method lookup is done.
166 _Jv_InitClass (declaringClass);
170 jclass objClass = JV_CLASS (obj);
171 if (! _Jv_IsAssignableFrom (objClass, declaringClass))
172 throw new java::lang::IllegalArgumentException;
175 // Check accessibility, if required.
176 if (! this->isAccessible())
178 if (! (Modifier::isPublic (meth->accflags)))
180 Class *caller = _Jv_StackTrace::GetCallingClass (&Method::class$);
181 if (! _Jv_CheckAccess(caller, declaringClass, meth->accflags))
182 throw new IllegalAccessException;
185 // Method is public, check to see if class is accessible.
187 jint flags = (declaringClass->accflags
189 | Modifier::PROTECTED
190 | Modifier::PRIVATE));
191 if (flags == 0) // i.e. class is package private
193 Class *caller = _Jv_StackTrace::GetCallingClass (&Method::class$);
194 if (! _Jv_ClassNameSamePackage (caller->name,
195 declaringClass->name))
196 throw new IllegalAccessException;
201 if (declaringClass->isInterface())
202 iface = declaringClass;
204 return _Jv_CallAnyMethodA (obj, return_type, meth, false,
205 parameter_types, args, iface);
209 java::lang::reflect::Method::getModifiersInternal ()
211 return _Jv_FromReflectedMethod (this)->accflags;
215 java::lang::reflect::Method::getSignature()
217 return declaringClass->getReflectionSignature (this);
221 java::lang::reflect::Method::getDefaultValue()
223 return declaringClass->getMethodDefaultValue(this);
227 java::lang::reflect::Method::getDeclaredAnnotationsInternal()
229 return (anno_a_t) declaringClass->getDeclaredAnnotations(this, false);
233 java::lang::reflect::Method::getParameterAnnotationsInternal()
235 return (anno_aa_t) declaringClass->getDeclaredAnnotations(this, true);
239 java::lang::reflect::Method::getName ()
242 name = _Jv_NewStringUtf8Const (_Jv_FromReflectedMethod (this)->name);
246 /* Internal method to set return_type and parameter_types fields. */
249 java::lang::reflect::Method::getType ()
251 _Jv_Method *method = _Jv_FromReflectedMethod (this);
252 _Jv_GetTypesFromSignature (method,
258 if (method->throws != NULL)
260 while (method->throws[count] != NULL)
265 = (JArray<jclass> *) JvNewObjectArray (count, &java::lang::Class::class$,
267 jclass *elts = elements (exception_types);
268 for (int i = 0; i < count; ++i)
269 elts[i] = _Jv_FindClass (method->throws[i],
270 declaringClass->getClassLoaderInternal ());
274 _Jv_GetTypesFromSignature (jmethodID method,
275 jclass declaringClass,
276 JArray<jclass> **arg_types_out,
277 jclass *return_type_out)
280 _Jv_Utf8Const* sig = method->signature;
281 java::lang::ClassLoader *loader = declaringClass->getClassLoaderInternal();
282 char *ptr = sig->chars();
284 /* First just count the number of parameters. */
285 // FIXME: should do some validation here, e.g., that there is only
312 while (*ptr != ';' && ptr[1] != '\0');
318 JArray<jclass> *args = (JArray<jclass> *)
319 JvNewObjectArray (numArgs, &java::lang::Class::class$, NULL);
320 jclass* argPtr = elements (args);
321 for (ptr = sig->chars(); *ptr != '\0'; ptr++)
327 argPtr = return_type_out;
332 jclass type = _Jv_FindClassFromSignature (ptr, loader, &end_ptr);
334 // FIXME: This isn't ideal.
335 throw new java::lang::NoClassDefFoundError (sig->toString());
337 // ARGPTR can be NULL if we are processing the return value of a
338 // call from Constructor.
344 *arg_types_out = args;
347 // This is a very rough analog of the JNI CallNonvirtual<type>MethodA
348 // functions. It handles both Methods and Constructors, and it can
349 // handle any return type. In the Constructor case, the `obj'
350 // argument is unused and should be NULL; also, the `return_type' is
351 // the class that the constructor will construct. RESULT is a pointer
352 // to a `jvalue' (see jni.h); for a void method this should be NULL.
353 // This function returns an exception (if one was thrown), or NULL if
356 _Jv_CallAnyMethodA (jobject obj,
359 jboolean is_constructor,
360 jboolean is_virtual_call,
361 JArray<jclass> *parameter_types,
364 jboolean is_jni_call,
367 using namespace java::lang::reflect;
370 JvAssert (! is_constructor || ! obj);
371 JvAssert (! is_constructor || return_type);
373 // See whether call needs an object as the first argument. A
374 // constructor does need a `this' argument, but it is one we create.
375 jboolean needs_this = false;
377 || ! Modifier::isStatic(meth->accflags))
380 int param_count = parameter_types->length;
385 // A constructor itself always returns void.
386 if (is_constructor || return_type == JvPrimClass (void))
387 rtype = &ffi_type_void;
389 rtype = get_ffi_type (return_type);
390 ffi_type **argtypes = (ffi_type **) __builtin_alloca (param_count
391 * sizeof (ffi_type *));
393 jclass *paramelts = elements (parameter_types);
395 // Special case for the `this' argument of a constructor. Note that
396 // the JDK 1.2 docs specify that the new object must be allocated
397 // before argument conversions are done.
399 obj = _Jv_AllocObject (return_type);
401 const int size_per_arg = sizeof(jvalue);
404 char *p = (char *) __builtin_alloca (param_count * size_per_arg);
405 // Overallocate to get correct alignment.
406 void **values = (void **)
407 __builtin_alloca (param_count * sizeof (void *));
412 // The `NULL' type is `Object'.
413 argtypes[i] = get_ffi_type (NULL);
415 memcpy (p, &obj, sizeof (jobject));
420 for (int arg = 0; i < param_count; ++i, ++arg)
424 argtypes[i] = get_ffi_type (paramelts[arg]);
425 if (paramelts[arg]->isPrimitive())
426 tsize = paramelts[arg]->size();
428 tsize = sizeof (jobject);
430 // Copy appropriate bits from the jvalue into the ffi array.
431 // FIXME: we could do this copying all in one loop, above, by
432 // over-allocating a bit.
433 // How do we do this without breaking big-endian platforms?
435 memcpy (p, &args[arg], tsize);
439 if (ffi_prep_cif (&cif, FFI_DEFAULT_ABI, param_count,
440 rtype, argtypes) != FFI_OK)
441 throw new java::lang::VirtualMachineError(JvNewStringLatin1("internal error: ffi_prep_cif failed"));
443 using namespace java::lang;
444 using namespace java::lang::reflect;
462 case FFI_TYPE_SINT16:
465 case FFI_TYPE_UINT16:
468 case FFI_TYPE_SINT32:
471 case FFI_TYPE_SINT64:
477 case FFI_TYPE_DOUBLE:
480 case FFI_TYPE_POINTER:
484 JvFail ("Unknown ffi_call return type");
490 // FIXME: If a vtable index is -1 at this point it is invalid, so we
491 // have to use the ncode.
493 // This can happen because methods in final classes don't have
494 // vtable entries, but _Jv_isVirtualMethod() doesn't know that. We
495 // could solve this problem by allocating a vtable index for methods
498 && ! Modifier::isFinal (meth->accflags)
499 && (_Jv_ushort)-1 != meth->index)
501 _Jv_VTable *vtable = *(_Jv_VTable **) obj;
504 if (is_jni_call && Modifier::isAbstract (meth->accflags))
506 // With JNI we don't know if this is an interface call
507 // or a call to an abstract method. Look up the method
508 // by name, the slow way.
509 _Jv_Method *concrete_meth
510 = _Jv_LookupDeclaredMethod (vtable->clas,
514 if (concrete_meth == NULL
515 || concrete_meth->ncode == NULL
516 || Modifier::isAbstract(concrete_meth->accflags))
517 throw new java::lang::IncompatibleClassChangeError
518 (_Jv_GetMethodString (vtable->clas, meth));
519 ncode = concrete_meth->ncode;
522 ncode = vtable->get_method (meth->index);
525 ncode = _Jv_LookupInterfaceMethodIdx (vtable->clas, iface,
535 ffi_call (&cif, (void (*)()) ncode, &ffi_result, values);
537 catch (Throwable *ex)
539 // For JNI we just throw the real error. For reflection, we
540 // wrap the underlying method's exception in an
541 // InvocationTargetException.
543 ex = new InvocationTargetException (ex);
547 // Since ffi_call returns integer values promoted to a word, use
548 // a narrowing conversion for jbyte, jchar, etc. results.
549 // Note that boolean is handled either by the FFI_TYPE_SINT8 or
550 // FFI_TYPE_SINT32 case.
560 result->b = (jbyte)ffi_result.i;
562 case FFI_TYPE_SINT16:
563 result->s = (jshort)ffi_result.i;
565 case FFI_TYPE_UINT16:
566 result->c = (jchar)ffi_result.i;
568 case FFI_TYPE_SINT32:
569 result->i = (jint)ffi_result.i;
571 case FFI_TYPE_SINT64:
572 result->j = (jlong)ffi_result.l;
575 result->f = (jfloat)ffi_result.f;
577 case FFI_TYPE_DOUBLE:
578 result->d = (jdouble)ffi_result.d;
580 case FFI_TYPE_POINTER:
581 result->l = (jobject)ffi_result.o;
584 JvFail ("Unknown ffi_call return type");
589 throw new java::lang::UnsupportedOperationException(JvNewStringLatin1("reflection not available in this build"));
593 // This is another version of _Jv_CallAnyMethodA, but this one does
594 // more checking and is used by the reflection (and not JNI) code.
596 _Jv_CallAnyMethodA (jobject obj,
599 jboolean is_constructor,
600 JArray<jclass> *parameter_types,
604 if (parameter_types->length == 0 && args == NULL)
606 // The JDK accepts this, so we do too.
608 else if (parameter_types->length != args->length)
609 throw new java::lang::IllegalArgumentException;
611 int param_count = parameter_types->length;
613 jclass *paramelts = elements (parameter_types);
614 jobject *argelts = args == NULL ? NULL : elements (args);
615 jvalue argvals[param_count];
617 #define COPY(Where, What, Type) \
620 memcpy ((Where), &val, sizeof (Type)); \
623 for (int i = 0; i < param_count; ++i)
625 jclass k = argelts[i] ? argelts[i]->getClass() : NULL;
626 if (paramelts[i]->isPrimitive())
630 || ! can_widen (k, paramelts[i]))
631 throw new java::lang::IllegalArgumentException;
633 if (paramelts[i] == JvPrimClass (boolean))
635 ((java::lang::Boolean *) argelts[i])->booleanValue(),
637 else if (paramelts[i] == JvPrimClass (char))
639 ((java::lang::Character *) argelts[i])->charValue(),
643 java::lang::Number *num = (java::lang::Number *) argelts[i];
644 if (paramelts[i] == JvPrimClass (byte))
645 COPY (&argvals[i], num->byteValue(), jbyte);
646 else if (paramelts[i] == JvPrimClass (short))
647 COPY (&argvals[i], num->shortValue(), jshort);
648 else if (paramelts[i] == JvPrimClass (int))
649 COPY (&argvals[i], num->intValue(), jint);
650 else if (paramelts[i] == JvPrimClass (long))
651 COPY (&argvals[i], num->longValue(), jlong);
652 else if (paramelts[i] == JvPrimClass (float))
653 COPY (&argvals[i], num->floatValue(), jfloat);
654 else if (paramelts[i] == JvPrimClass (double))
655 COPY (&argvals[i], num->doubleValue(), jdouble);
660 if (argelts[i] && ! paramelts[i]->isAssignableFrom (k))
661 throw new java::lang::IllegalArgumentException;
662 COPY (&argvals[i], argelts[i], jobject);
667 _Jv_CallAnyMethodA (obj, return_type, meth, is_constructor,
668 _Jv_isVirtualMethod (meth),
669 parameter_types, argvals, &ret_value,
673 #define VAL(Wrapper, Field) (new Wrapper (ret_value.Field))
676 else if (return_type == JvPrimClass (byte))
677 r = VAL (java::lang::Byte, b);
678 else if (return_type == JvPrimClass (short))
679 r = VAL (java::lang::Short, s);
680 else if (return_type == JvPrimClass (int))
681 r = VAL (java::lang::Integer, i);
682 else if (return_type == JvPrimClass (long))
683 r = VAL (java::lang::Long, j);
684 else if (return_type == JvPrimClass (float))
685 r = VAL (java::lang::Float, f);
686 else if (return_type == JvPrimClass (double))
687 r = VAL (java::lang::Double, d);
688 else if (return_type == JvPrimClass (boolean))
689 r = VAL (java::lang::Boolean, z);
690 else if (return_type == JvPrimClass (char))
691 r = VAL (java::lang::Character, c);
692 else if (return_type == JvPrimClass (void))
696 JvAssert (return_type == NULL || ! return_type->isPrimitive());