OSDN Git Service

2004-12-17 Andrew Haley <aph@redhat.com>
[pf3gnuchains/gcc-fork.git] / libjava / java / lang / reflect / natMethod.cc
1 // natMethod.cc - Native code for Method class.
2
3 /* Copyright (C) 1998, 1999, 2000, 2001 , 2002, 2003, 2004 Free Software Foundation
4
5    This file is part of libgcj.
6
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
9 details.  */
10
11 #include <config.h>
12
13 #include <gcj/cni.h>
14 #include <jvm.h>
15 #include <jni.h>
16
17 #include <java/lang/reflect/Method.h>
18 #include <java/lang/reflect/Constructor.h>
19 #include <java/lang/reflect/InvocationTargetException.h>
20 #include <java/lang/reflect/Modifier.h>
21
22 #include <java/lang/Void.h>
23 #include <java/lang/Byte.h>
24 #include <java/lang/Boolean.h>
25 #include <java/lang/Character.h>
26 #include <java/lang/Short.h>
27 #include <java/lang/Integer.h>
28 #include <java/lang/Long.h>
29 #include <java/lang/Float.h>
30 #include <java/lang/Double.h>
31 #include <java/lang/IllegalAccessException.h>
32 #include <java/lang/IllegalArgumentException.h>
33 #include <java/lang/NullPointerException.h>
34 #include <java/lang/ArrayIndexOutOfBoundsException.h>
35 #include <java/lang/VirtualMachineError.h>
36 #include <java/lang/Class.h>
37 #include <gcj/method.h>
38 #include <gnu/gcj/RawData.h>
39
40 #include <stdlib.h>
41
42 #if USE_LIBFFI
43 #include <ffi.h>
44 #else
45 #include <java/lang/UnsupportedOperationException.h>
46 #endif
47
48 struct cpair
49 {
50   jclass prim;
51   jclass wrap;
52 };
53
54 // This is used to determine when a primitive widening conversion is
55 // allowed.
56 static cpair primitives[] =
57 {
58 #define BOOLEAN 0
59   { JvPrimClass (boolean), &java::lang::Boolean::class$ },
60   { JvPrimClass (byte), &java::lang::Byte::class$ },
61 #define SHORT 2
62   { JvPrimClass (short), &java::lang::Short::class$ },
63 #define CHAR 3
64   { JvPrimClass (char), &java::lang::Character::class$ },
65   { JvPrimClass (int), &java::lang::Integer::class$ },
66   { JvPrimClass (long), &java::lang::Long::class$ },
67   { JvPrimClass (float), &java::lang::Float::class$ },
68   { JvPrimClass (double), &java::lang::Double::class$ },
69   { NULL, NULL }
70 };
71
72 static inline jboolean
73 can_widen (jclass from, jclass to)
74 {
75   int fromx = -1, tox = -1;
76
77   for (int i = 0; primitives[i].prim; ++i)
78     {
79       if (primitives[i].wrap == from)
80         fromx = i;
81       if (primitives[i].prim == to)
82         tox = i;
83     }
84
85   // Can't handle a miss.
86   if (fromx == -1 || tox == -1)
87     return false;
88   // Boolean arguments may not be widened.
89   if (fromx == BOOLEAN && tox != BOOLEAN)
90     return false;
91   // Nothing promotes to char.
92   if (tox == CHAR && fromx != CHAR)
93     return false;
94
95   return fromx <= tox;
96 }
97
98 #ifdef USE_LIBFFI
99 static inline ffi_type *
100 get_ffi_type (jclass klass)
101 {
102   // A special case.
103   if (klass == NULL)
104     return &ffi_type_pointer;
105
106   ffi_type *r;
107   if (klass == JvPrimClass (byte))
108     r = &ffi_type_sint8;
109   else if (klass == JvPrimClass (short))
110     r = &ffi_type_sint16;
111   else if (klass == JvPrimClass (int))
112     r = &ffi_type_sint32;
113   else if (klass == JvPrimClass (long))
114     r = &ffi_type_sint64;
115   else if (klass == JvPrimClass (float))
116     r = &ffi_type_float;
117   else if (klass == JvPrimClass (double))
118     r = &ffi_type_double;
119   else if (klass == JvPrimClass (boolean))
120     {
121       // On some platforms a bool is a byte, on others an int.
122       if (sizeof (jboolean) == sizeof (jbyte))
123         r = &ffi_type_sint8;
124       else
125         {
126           JvAssert (sizeof (jboolean) == sizeof (jint));
127           r = &ffi_type_sint32;
128         }
129     }
130   else if (klass == JvPrimClass (char))
131     r = &ffi_type_uint16;
132   else
133     {
134       JvAssert (! klass->isPrimitive());
135       r = &ffi_type_pointer;
136     }
137
138   return r;
139 }
140 #endif // USE_LIBFFI
141
142 jobject
143 java::lang::reflect::Method::invoke (jobject obj, jobjectArray args)
144 {
145   using namespace java::lang::reflect;
146   jclass iface = NULL;
147   
148   if (parameter_types == NULL)
149     getType ();
150     
151   jmethodID meth = _Jv_FromReflectedMethod (this);
152
153   if (Modifier::isStatic(meth->accflags))
154     {
155       // We have to initialize a static class.  It is safe to do this
156       // here and not in _Jv_CallAnyMethodA because JNI initializes a
157       // class whenever a method lookup is done.
158       _Jv_InitClass (declaringClass);
159     }
160   else
161     {
162       jclass objClass = JV_CLASS (obj);
163       if (! _Jv_IsAssignableFrom (declaringClass, objClass))
164         throw new java::lang::IllegalArgumentException;
165     }
166
167   // Check accessibility, if required.
168   if (! (Modifier::isPublic (meth->accflags) || this->isAccessible()))
169     {
170       gnu::gcj::runtime::StackTrace *t 
171         = new gnu::gcj::runtime::StackTrace(4);
172       Class *caller = NULL;
173       try
174         {
175           for (int i = 1; !caller; i++)
176             {
177               caller = t->classAt (i);
178             }
179         }
180       catch (::java::lang::ArrayIndexOutOfBoundsException *e)
181         {
182         }
183
184       if (! _Jv_CheckAccess(caller, declaringClass, meth->accflags))
185         throw new IllegalAccessException;
186     }
187
188   if (declaringClass->isInterface())
189     iface = declaringClass;
190   
191   return _Jv_CallAnyMethodA (obj, return_type, meth, false,
192                              parameter_types, args, iface);
193 }
194
195 jint
196 java::lang::reflect::Method::getModifiers ()
197 {
198   // Ignore all unknown flags.
199   return _Jv_FromReflectedMethod (this)->accflags & Modifier::ALL_FLAGS;
200 }
201
202 jstring
203 java::lang::reflect::Method::getName ()
204 {
205   if (name == NULL)
206     name = _Jv_NewStringUtf8Const (_Jv_FromReflectedMethod (this)->name);
207   return name;
208 }
209
210 /* Internal method to set return_type and parameter_types fields. */
211
212 void
213 java::lang::reflect::Method::getType ()
214 {
215   _Jv_Method *method = _Jv_FromReflectedMethod (this);
216   _Jv_GetTypesFromSignature (method,
217                              declaringClass,
218                              &parameter_types,
219                              &return_type);
220
221   int count = 0;
222   if (method->throws != NULL)
223     {
224       while (method->throws[count] != NULL)
225         ++count;
226     }
227
228   exception_types
229     = (JArray<jclass> *) JvNewObjectArray (count, &java::lang::Class::class$,
230                                            NULL);
231   jclass *elts = elements (exception_types);
232   for (int i = 0; i < count; ++i)
233     elts[i] = _Jv_FindClass (method->throws[i],
234                              declaringClass->getClassLoaderInternal ());
235 }
236
237 void
238 _Jv_GetTypesFromSignature (jmethodID method,
239                            jclass declaringClass,
240                            JArray<jclass> **arg_types_out,
241                            jclass *return_type_out)
242 {
243
244   _Jv_Utf8Const* sig = method->signature;
245   java::lang::ClassLoader *loader = declaringClass->getClassLoaderInternal();
246   char *ptr = sig->chars();
247   int numArgs = 0;
248   /* First just count the number of parameters. */
249   for (; ; ptr++)
250     {
251       switch (*ptr)
252         {
253         case 0:
254         case ')':
255         case 'V':
256           break;
257         case '[':
258         case '(':
259           continue;
260         case 'B':
261         case 'C':
262         case 'D':
263         case 'F':
264         case 'S':
265         case 'I':
266         case 'J':
267         case 'Z':
268           numArgs++;
269           continue;
270         case 'L':
271           numArgs++;
272           do 
273             ptr++;
274           while (*ptr != ';' && ptr[1] != '\0');
275           continue;
276         }
277       break;
278     }
279
280   JArray<jclass> *args = (JArray<jclass> *)
281     JvNewObjectArray (numArgs, &java::lang::Class::class$, NULL);
282   jclass* argPtr = elements (args);
283   for (ptr = sig->chars(); *ptr != '\0'; ptr++)
284     {
285       int num_arrays = 0;
286       jclass type;
287       for (; *ptr == '[';  ptr++)
288         num_arrays++;
289       switch (*ptr)
290         {
291         default:
292           return;
293         case ')':
294           argPtr = return_type_out;
295           continue;
296         case '(':
297           continue;
298         case 'V':
299         case 'B':
300         case 'C':
301         case 'D':
302         case 'F':
303         case 'S':
304         case 'I':
305         case 'J':
306         case 'Z':
307           type = _Jv_FindClassFromSignature(ptr, loader);
308           break;
309         case 'L':
310           type = _Jv_FindClassFromSignature(ptr, loader);
311           do 
312             ptr++;
313           while (*ptr != ';' && ptr[1] != '\0');
314           break;
315         }
316
317       while (--num_arrays >= 0)
318         type = _Jv_GetArrayClass (type, loader);
319       // ARGPTR can be NULL if we are processing the return value of a
320       // call from Constructor.
321       if (argPtr)
322         *argPtr++ = type;
323     }
324   *arg_types_out = args;
325 }
326
327 // This is a very rough analog of the JNI CallNonvirtual<type>MethodA
328 // functions.  It handles both Methods and Constructors, and it can
329 // handle any return type.  In the Constructor case, the `obj'
330 // argument is unused and should be NULL; also, the `return_type' is
331 // the class that the constructor will construct.  RESULT is a pointer
332 // to a `jvalue' (see jni.h); for a void method this should be NULL.
333 // This function returns an exception (if one was thrown), or NULL if
334 // the call went ok.
335 void
336 _Jv_CallAnyMethodA (jobject obj,
337                     jclass return_type,
338                     jmethodID meth,
339                     jboolean is_constructor,
340                     jboolean is_virtual_call,
341                     JArray<jclass> *parameter_types,
342                     jvalue *args,
343                     jvalue *result,
344                     jboolean is_jni_call,
345                     jclass iface)
346 {
347   using namespace java::lang::reflect;
348   
349 #ifdef USE_LIBFFI
350   JvAssert (! is_constructor || ! obj);
351   JvAssert (! is_constructor || return_type);
352
353   // See whether call needs an object as the first argument.  A
354   // constructor does need a `this' argument, but it is one we create.
355   jboolean needs_this = false;
356   if (is_constructor
357       || ! Modifier::isStatic(meth->accflags))
358     needs_this = true;
359
360   int param_count = parameter_types->length;
361   if (needs_this)
362     ++param_count;
363
364   ffi_type *rtype;
365   // A constructor itself always returns void.
366   if (is_constructor || return_type == JvPrimClass (void))
367     rtype = &ffi_type_void;
368   else
369     rtype = get_ffi_type (return_type);
370   ffi_type **argtypes = (ffi_type **) __builtin_alloca (param_count
371                                                         * sizeof (ffi_type *));
372
373   jclass *paramelts = elements (parameter_types);
374
375   // Special case for the `this' argument of a constructor.  Note that
376   // the JDK 1.2 docs specify that the new object must be allocated
377   // before argument conversions are done.
378   if (is_constructor)
379     obj = _Jv_AllocObject (return_type);
380
381   const int size_per_arg = sizeof(jvalue);
382   ffi_cif cif;
383
384   char *p = (char *) __builtin_alloca (param_count * size_per_arg);
385                 // Overallocate to get correct alignment.
386   void **values = (void **)
387                         __builtin_alloca (param_count * sizeof (void *));
388
389   int i = 0;
390   if (needs_this)
391     {
392       // The `NULL' type is `Object'.
393       argtypes[i] = get_ffi_type (NULL);
394       values[i] = p;
395       memcpy (p, &obj, sizeof (jobject));
396       p += size_per_arg;
397       ++i;
398     }
399
400   for (int arg = 0; i < param_count; ++i, ++arg)
401     {
402       int tsize;
403
404       argtypes[i] = get_ffi_type (paramelts[arg]);
405       if (paramelts[arg]->isPrimitive())
406         tsize = paramelts[arg]->size();
407       else
408         tsize = sizeof (jobject);
409
410       // Copy appropriate bits from the jvalue into the ffi array.
411       // FIXME: we could do this copying all in one loop, above, by
412       // over-allocating a bit.
413       // How do we do this without breaking big-endian platforms?
414       values[i] = p;
415       memcpy (p, &args[arg], tsize);
416       p += size_per_arg;
417     }
418
419   if (ffi_prep_cif (&cif, FFI_DEFAULT_ABI, param_count,
420                     rtype, argtypes) != FFI_OK)
421     throw new java::lang::VirtualMachineError(JvNewStringLatin1("internal error: ffi_prep_cif failed"));
422
423   using namespace java::lang;
424   using namespace java::lang::reflect;
425
426   union
427   {
428     ffi_arg i;
429     jobject o;
430     jlong l;
431     jfloat f;
432     jdouble d;
433   } ffi_result;
434
435   switch (rtype->type)
436     {
437     case FFI_TYPE_VOID:
438       break;
439     case FFI_TYPE_SINT8:
440       result->b = 0;
441       break;
442     case FFI_TYPE_SINT16:
443       result->s = 0;
444       break;
445     case FFI_TYPE_UINT16:
446       result->c = 0;
447       break;
448     case FFI_TYPE_SINT32:
449       result->i = 0;
450       break;
451     case FFI_TYPE_SINT64:
452       result->j = 0;
453       break;
454     case FFI_TYPE_FLOAT:
455       result->f = 0;
456       break;
457     case FFI_TYPE_DOUBLE:
458       result->d = 0;
459       break;
460     case FFI_TYPE_POINTER:
461       result->l = 0;
462       break;
463     default:
464       JvFail ("Unknown ffi_call return type");
465       break;
466     }
467
468   void *ncode;
469
470   // FIXME: If a vtable index is -1 at this point it is invalid, so we
471   // have to use the ncode.  
472   //
473   // This can happen because methods in final classes don't have
474   // vtable entries, but _Jv_isVirtualMethod() doesn't know that.  We
475   // could solve this problem by allocating a vtable index for methods
476   // in final classes.
477   if (is_virtual_call 
478       && ! Modifier::isFinal (meth->accflags)
479       && (_Jv_ushort)-1 != meth->index)
480     {
481       _Jv_VTable *vtable = *(_Jv_VTable **) obj;
482       if (iface == NULL)
483         ncode = vtable->get_method (meth->index);
484       else
485         ncode = _Jv_LookupInterfaceMethodIdx (vtable->clas, iface,
486                                               meth->index);
487     }
488   else
489     {
490       ncode = meth->ncode;
491     }
492
493   try
494     {
495       ffi_call (&cif, (void (*)()) ncode, &ffi_result, values);
496     }
497   catch (Throwable *ex)
498     {
499       // For JNI we just throw the real error.  For reflection, we
500       // wrap the underlying method's exception in an
501       // InvocationTargetException.
502       if (! is_jni_call)
503         ex = new InvocationTargetException (ex);
504       throw ex;
505     }
506
507   // Since ffi_call returns integer values promoted to a word, use
508   // a narrowing conversion for jbyte, jchar, etc. results.
509   // Note that boolean is handled either by the FFI_TYPE_SINT8 or
510   // FFI_TYPE_SINT32 case.
511   if (is_constructor)
512     result->l = obj;
513   else
514     {
515       switch (rtype->type)
516         {
517         case FFI_TYPE_VOID:
518           break;
519         case FFI_TYPE_SINT8:
520           result->b = (jbyte)ffi_result.i;
521           break;
522         case FFI_TYPE_SINT16:
523           result->s = (jshort)ffi_result.i;
524           break;
525         case FFI_TYPE_UINT16:
526           result->c = (jchar)ffi_result.i;
527           break;
528         case FFI_TYPE_SINT32:
529           result->i = (jint)ffi_result.i;
530           break;
531         case FFI_TYPE_SINT64:
532           result->j = (jlong)ffi_result.l;
533           break;
534         case FFI_TYPE_FLOAT:
535           result->f = (jfloat)ffi_result.f;
536           break;
537         case FFI_TYPE_DOUBLE:
538           result->d = (jdouble)ffi_result.d;
539           break;
540         case FFI_TYPE_POINTER:
541           result->l = (jobject)ffi_result.o;
542           break;
543         default:
544           JvFail ("Unknown ffi_call return type");
545           break;
546         }
547     }
548 #else
549   throw new java::lang::UnsupportedOperationException(JvNewStringLatin1("reflection not available in this build"));
550 #endif // USE_LIBFFI
551 }
552
553 // This is another version of _Jv_CallAnyMethodA, but this one does
554 // more checking and is used by the reflection (and not JNI) code.
555 jobject
556 _Jv_CallAnyMethodA (jobject obj,
557                     jclass return_type,
558                     jmethodID meth,
559                     jboolean is_constructor,
560                     JArray<jclass> *parameter_types,
561                     jobjectArray args,
562                     jclass iface)
563 {
564   if (parameter_types->length == 0 && args == NULL)
565     {
566       // The JDK accepts this, so we do too.
567     }
568   else if (parameter_types->length != args->length)
569     throw new java::lang::IllegalArgumentException;
570
571   int param_count = parameter_types->length;
572
573   jclass *paramelts = elements (parameter_types);
574   jobject *argelts = args == NULL ? NULL : elements (args);
575   jvalue argvals[param_count];
576
577 #define COPY(Where, What, Type) \
578   do { \
579     Type val = (What); \
580     memcpy ((Where), &val, sizeof (Type)); \
581   } while (0)
582
583   for (int i = 0; i < param_count; ++i)
584     {
585       jclass k = argelts[i] ? argelts[i]->getClass() : NULL;
586       if (paramelts[i]->isPrimitive())
587         {
588           if (! argelts[i]
589               || ! k
590               || ! can_widen (k, paramelts[i]))
591             throw new java::lang::IllegalArgumentException;
592             
593           if (paramelts[i] == JvPrimClass (boolean))
594             COPY (&argvals[i],
595                   ((java::lang::Boolean *) argelts[i])->booleanValue(),
596                   jboolean);
597           else if (paramelts[i] == JvPrimClass (char))
598             COPY (&argvals[i],
599                   ((java::lang::Character *) argelts[i])->charValue(),
600                   jchar);
601           else
602             {
603               java::lang::Number *num = (java::lang::Number *) argelts[i];
604               if (paramelts[i] == JvPrimClass (byte))
605                 COPY (&argvals[i], num->byteValue(), jbyte);
606               else if (paramelts[i] == JvPrimClass (short))
607                 COPY (&argvals[i], num->shortValue(), jshort);
608               else if (paramelts[i] == JvPrimClass (int))
609                 COPY (&argvals[i], num->intValue(), jint);
610               else if (paramelts[i] == JvPrimClass (long))
611                 COPY (&argvals[i], num->longValue(), jlong);
612               else if (paramelts[i] == JvPrimClass (float))
613                 COPY (&argvals[i], num->floatValue(), jfloat);
614               else if (paramelts[i] == JvPrimClass (double))
615                 COPY (&argvals[i], num->doubleValue(), jdouble);
616             }
617         }
618       else
619         {
620           if (argelts[i] && ! paramelts[i]->isAssignableFrom (k))
621             throw new java::lang::IllegalArgumentException;
622           COPY (&argvals[i], argelts[i], jobject);
623         }
624     }
625
626   jvalue ret_value;
627   _Jv_CallAnyMethodA (obj, return_type, meth, is_constructor,
628                       _Jv_isVirtualMethod (meth),
629                       parameter_types, argvals, &ret_value,
630                       false, iface);
631
632   jobject r;
633 #define VAL(Wrapper, Field)  (new Wrapper (ret_value.Field))
634   if (is_constructor)
635     r = ret_value.l;
636   else  if (return_type == JvPrimClass (byte))
637     r = VAL (java::lang::Byte, b);
638   else if (return_type == JvPrimClass (short))
639     r = VAL (java::lang::Short, s);
640   else if (return_type == JvPrimClass (int))
641     r = VAL (java::lang::Integer, i);
642   else if (return_type == JvPrimClass (long))
643     r = VAL (java::lang::Long, j);
644   else if (return_type == JvPrimClass (float))
645     r = VAL (java::lang::Float, f);
646   else if (return_type == JvPrimClass (double))
647     r = VAL (java::lang::Double, d);
648   else if (return_type == JvPrimClass (boolean))
649     r = VAL (java::lang::Boolean, z);
650   else if (return_type == JvPrimClass (char))
651     r = VAL (java::lang::Character, c);
652   else if (return_type == JvPrimClass (void))
653     r = NULL;
654   else
655     {
656       JvAssert (return_type == NULL || ! return_type->isPrimitive());
657       r = ret_value.l;
658     }
659
660   return r;
661 }