PR libgcj/11951:

	* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Returns
	void.  Throw VirtualMachineError if ffi fails.  Initialize return
	value.  Added is_jni_call argument; only wrap exception if not a
	JNI call.  Use descriptive message if operation not supported.
	(_Jv_GetTypesFromSignature): Use declaring class' loader to find
	array class.
	* include/jvm.h (_Jv_CallAnyMethodA): Updated declaration.
	* jni.cc (_Jv_JNI_CallAnyMethodV): Updated for new form of
	_Jv_CallAnyMethodA.
	(_Jv_JNI_CallAnyMethodA): Likewise.
	(_Jv_JNI_CallAnyVoidMethodV): Likewise.
	(_Jv_JNI_CallAnyVoidMethodA): Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@70544 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 633db92d48d8b5b17addc75c0fe365d00cb71564..5da7125345f26fb5baee87ebabd68654f4547451 100644 (file)
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,19 @@
+2003-08-18  Tom Tromey  <tromey@redhat.com>
+
+       PR libgcj/11951:
+       * java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Returns
+       void.  Throw VirtualMachineError if ffi fails.  Initialize return
+       value.  Added is_jni_call argument; only wrap exception if not a
+       JNI call.  Use descriptive message if operation not supported.
+       (_Jv_GetTypesFromSignature): Use declaring class' loader to find
+       array class.
+       * include/jvm.h (_Jv_CallAnyMethodA): Updated declaration.
+       * jni.cc (_Jv_JNI_CallAnyMethodV): Updated for new form of
+       _Jv_CallAnyMethodA.
+       (_Jv_JNI_CallAnyMethodA): Likewise.
+       (_Jv_JNI_CallAnyVoidMethodV): Likewise.
+       (_Jv_JNI_CallAnyVoidMethodA): Likewise.
+
 2003-08-13  Tom Tromey  <tromey@redhat.com>
 
        * gij.cc (help): Document -? and -X.

diff --git a/libjava/include/jvm.h b/libjava/include/jvm.h
index 38155d3a3ec5df668869ac4239dd98597cc47cb0..941b24e0e9064720a8594fc1130328627ad1a7ee 100644 (file)
--- a/libjava/include/jvm.h
+++ b/libjava/include/jvm.h
@@ -335,13 +335,14 @@ extern jobject _Jv_CallAnyMethodA (jobject obj, jclass return_type,
                                   jobjectArray args);
 
 union jvalue;
-extern jthrowable _Jv_CallAnyMethodA (jobject obj,
-                                     jclass return_type,
-                                     jmethodID meth,
-                                     jboolean is_constructor,
-                                     JArray<jclass> *parameter_types,
-                                     jvalue *args,
-                                     jvalue *result);
+extern void _Jv_CallAnyMethodA (jobject obj,
+                               jclass return_type,
+                               jmethodID meth,
+                               jboolean is_constructor,
+                               JArray<jclass> *parameter_types,
+                               jvalue *args,
+                               jvalue *result,
+                               jboolean is_jni_call = true);
 
 extern jobject _Jv_NewMultiArray (jclass, jint ndims, jint* dims)
   __attribute__((__malloc__));

diff --git a/libjava/java/lang/reflect/natMethod.cc b/libjava/java/lang/reflect/natMethod.cc
index 7f391f91969b4cf116d54163e2f0a64eae42cb6f..6330c4b4675b40adb826dfae07890ab976bf6232 100644 (file)
--- a/libjava/java/lang/reflect/natMethod.cc
+++ b/libjava/java/lang/reflect/natMethod.cc
@@ -31,6 +31,7 @@ details.  */
 #include <java/lang/IllegalArgumentException.h>
 #include <java/lang/NullPointerException.h>
 #include <java/lang/ArrayIndexOutOfBoundsException.h>
+#include <java/lang/VirtualMachineError.h>
 #include <java/lang/Class.h>
 #include <gcj/method.h>
 #include <gnu/gcj/RawData.h>
@@ -309,9 +310,8 @@ _Jv_GetTypesFromSignature (jmethodID method,
          break;
        }
 
-      // FIXME: 2'nd argument should be "current loader"
       while (--num_arrays >= 0)
-       type = _Jv_GetArrayClass (type, 0);
+       type = _Jv_GetArrayClass (type, loader);
       // ARGPTR can be NULL if we are processing the return value of a
       // call from Constructor.
       if (argPtr)
@@ -328,14 +328,15 @@ _Jv_GetTypesFromSignature (jmethodID method,
 // to a `jvalue' (see jni.h); for a void method this should be NULL.
 // This function returns an exception (if one was thrown), or NULL if
 // the call went ok.
-jthrowable
+void
 _Jv_CallAnyMethodA (jobject obj,
                    jclass return_type,
                    jmethodID meth,
                    jboolean is_constructor,
                    JArray<jclass> *parameter_types,
                    jvalue *args,
-                   jvalue *result)
+                   jvalue *result,
+                   jboolean is_jni_call)
 {
 #ifdef USE_LIBFFI
   JvAssert (! is_constructor || ! obj);
@@ -409,15 +410,11 @@ _Jv_CallAnyMethodA (jobject obj,
 
   if (ffi_prep_cif (&cif, FFI_DEFAULT_ABI, param_count,
                    rtype, argtypes) != FFI_OK)
-    {
-      // FIXME: throw some kind of VirtualMachineError here.
-    }
+    throw new java::lang::VirtualMachineError(JvNewStringLatin1("internal error: ffi_prep_cif failed"));
 
   using namespace java::lang;
   using namespace java::lang::reflect;
 
-  Throwable *ex = NULL;
-
   union
   {
     ffi_arg i;
@@ -427,17 +424,51 @@ _Jv_CallAnyMethodA (jobject obj,
     jdouble d;
   } ffi_result;
 
+  switch (rtype->type)
+    {
+    case FFI_TYPE_VOID:
+      break;
+    case FFI_TYPE_SINT8:
+      result->b = 0;
+      break;
+    case FFI_TYPE_SINT16:
+      result->s = 0;
+      break;
+    case FFI_TYPE_UINT16:
+      result->c = 0;
+      break;
+    case FFI_TYPE_SINT32:
+      result->i = 0;
+      break;
+    case FFI_TYPE_SINT64:
+      result->j = 0;
+      break;
+    case FFI_TYPE_FLOAT:
+      result->f = 0;
+      break;
+    case FFI_TYPE_DOUBLE:
+      result->d = 0;
+      break;
+    case FFI_TYPE_POINTER:
+      result->l = 0;
+      break;
+    default:
+      JvFail ("Unknown ffi_call return type");
+      break;
+    }
+
   try
     {
       ffi_call (&cif, (void (*)()) meth->ncode, &ffi_result, values);
     }
-  catch (Throwable *ex2)
+  catch (Throwable *ex)
     {
-      // FIXME: this is wrong for JNI.  But if we just return the
-      // exception, then the non-JNI cases won't be able to
-      // distinguish it from exceptions we might generate ourselves.
-      // Sigh.
-      ex = new InvocationTargetException (ex2);
+      // For JNI we just throw the real error.  For reflection, we
+      // wrap the underlying method's exception in an
+      // InvocationTargetException.
+      if (! is_jni_call)
+       ex = new InvocationTargetException (ex);
+      throw ex;
     }
 
   // Since ffi_call returns integer values promoted to a word, use
@@ -481,11 +512,8 @@ _Jv_CallAnyMethodA (jobject obj,
          break;
        }
     }
-
-  return ex;
 #else
-  throw new java::lang::UnsupportedOperationException;
-  return 0;
+  throw new java::lang::UnsupportedOperationException(JvNewStringLatin1("reflection not available in this build"));
 #endif // USE_LIBFFI
 }
 
@@ -562,16 +590,9 @@ _Jv_CallAnyMethodA (jobject obj,
     }
 
   jvalue ret_value;
-  java::lang::Throwable *ex = _Jv_CallAnyMethodA (obj,
-                                                 return_type,
-                                                 meth,
-                                                 is_constructor,
-                                                 parameter_types,
-                                                 argvals,
-                                                 &ret_value);
-
-  if (ex)
-    throw ex;
+  _Jv_CallAnyMethodA (obj, return_type, meth, is_constructor,
+                     parameter_types, argvals, &ret_value,
+                     false);
 
   jobject r;
 #define VAL(Wrapper, Field)  (new Wrapper (ret_value.Field))

diff --git a/libjava/jni.cc b/libjava/jni.cc
index eace628acfccec5ea7539d1035477098834bd8be..47017dc8c18503f207ba7334c901e3cc860a4179 100644 (file)
--- a/libjava/jni.cc
+++ b/libjava/jni.cc
@@ -777,12 +777,9 @@ static T
        return_type = klass;
 
       jvalue result;
-      jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
-                                         style == constructor,
-                                         arg_types, args, &result);
-
-      if (ex != NULL)
-       env->ex = ex;
+      _Jv_CallAnyMethodA (obj, return_type, id,
+                         style == constructor,
+                         arg_types, args, &result);
 
       // We cheat a little here.  FIXME.
       return wrap_value (env, * (T *) &result);
@@ -847,12 +844,9 @@ static T
        }
 
       jvalue result;
-      jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
-                                         style == constructor,
-                                         arg_types, arg_copy, &result);
-
-      if (ex != NULL)
-       env->ex = ex;
+      _Jv_CallAnyMethodA (obj, return_type, id,
+                         style == constructor,
+                         arg_types, arg_copy, &result);
 
       // We cheat a little here.  FIXME.
       return wrap_value (env, * (T *) &result);
@@ -893,12 +887,9 @@ static void
       if (style == constructor)
        return_type = klass;
 
-      jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
-                                         style == constructor,
-                                         arg_types, args, NULL);
-
-      if (ex != NULL)
-       env->ex = ex;
+      _Jv_CallAnyMethodA (obj, return_type, id,
+                         style == constructor,
+                         arg_types, args, NULL);
     }
   catch (jthrowable t)
     {
@@ -947,12 +938,9 @@ static void
            arg_copy[i].l = unwrap (args[i].l);
        }
 
-      jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
-                                         style == constructor,
-                                         arg_types, args, NULL);
-
-      if (ex != NULL)
-       env->ex = ex;
+      _Jv_CallAnyMethodA (obj, return_type, id,
+                         style == constructor,
+                         arg_types, args, NULL);
     }
   catch (jthrowable t)
     {