java-interp.h: Don't include MethodInvocation.h.

	* include/java-interp.h: Don't include MethodInvocation.h.
	(class _Jv_InterpMethod): Don't make MethodInvocation a friend.
	* Makefile.in: Rebuilt.
	* Makefile.am (gnu/gcj/runtime/MethodInvocation.h): Removed.
	(ordinary_java_source_files): Don't mention
	MethodInvocation.java.
	* gnu/gcj/runtime/MethodInvocation.java: Removed.
	* interpret.cc (MethodInvocation::continue1): Removed.
	(run): Handle exceptions here.
	* java/lang/ClassLoader.java (defineClass1, defineClass2):
	Removed.
	* java/lang/natClassLoader.cc (defineClass0): Catch exceptions
	here.
	(defineClass2): Removed.

	* java/lang/reflect/Method.java (hack_trampoline, hack_call):
	Removed.
	* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Catch
	exceptions here.
	(hack_call): Removed.

	* java/lang/Class.h (Class): Removed hackRunInitializers,
	hackTrampoline.
	* java/lang/natClass.cc (hackRunInitializers): Removed.
	(initializeClass): Catch exceptions here.
	Include ExceptionInInitializerError.h.
	* java/lang/Class.java (hackTrampoline, hackRunInitializers):
	Removed.

	* java/lang/Object.h (Object): Don't mention hack12_6.
	* java/lang/natObject.cc (_Jv_FinalizeObject): Catch exceptions
	here.
	* java/lang/Object.java (hack12_6): Removed.

	* java/lang/natThread.cc (run_): Renamed.  Catch exceptions here.
	(start): Use run_, not run__.
	* java/lang/Thread.java (run_): Renamed from run__; old run_
	removed.

	* jni.cc (_Jv_JNI_FindClass): Handle exceptions.
	(_Jv_JNI_EnsureLocalCapacity): Likewise.
	(_Jv_JNI_DefineClass): Likewise.
	(_Jv_JNI_ThrowNew): Likewise.
	(_Jv_JNI_AllocObject): Likewise.
	(_Jv_JNI_GetAnyMethodID): Likewise.
	(_Jv_JNI_CallAnyMethodV): Likewise.
	(_Jv_JNI_CallAnyMethodA): Likewise.
	(_Jv_JNI_CallAnyVoidMethodV): Likewise.
	(_Jv_JNI_CallAnyVoidMethodA): Likewise.
	(_Jv_JNI_GetAnyFieldID): Likewise.
	(_Jv_JNI_NewString): Likewise.
	(_Jv_JNI_NewStringUTF): Likewise.
	(_Jv_JNI_GetStringUTFChars): Likewise.
	(_Jv_JNI_NewObjectArray): Likewise.
	(_Jv_JNI_NewPrimitiveArray): Likewise.
	(_Jv_JNI_GetPrimitiveArrayRegion): Likewise.
	(_Jv_JNI_GetStringRegion): Likewise.
	(_Jv_JNI_GetStringUTFRegion): Likewise.
	(_Jv_JNI_SetPrimitiveArrayRegion): Likewise.
	(_Jv_JNI_MonitorEnter): Likewise.
	(_Jv_JNI_MonitorExit): Likewise.
	(_Jv_JNI_ToReflectedField): Likewise.
	(_Jv_JNI_ToReflectedMethod): Likewise.
	(_Jv_JNI_RegisterNatives): Likewise.
	(_Jv_JNI_AttachCurrentThread): Likewise.
	(_Jv_JNI_DestroyJavaVM): Likewise.

From-SVN: r32294

19 files changed, 582 insertions, 482 deletions

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 80729f0..4401190 100644
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,72 @@
+2000-03-02  Tom Tromey  <tromey@cygnus.com>
+
+	* include/java-interp.h: Don't include MethodInvocation.h.
+	(class _Jv_InterpMethod): Don't make MethodInvocation a friend.
+	* Makefile.in: Rebuilt.
+	* Makefile.am (gnu/gcj/runtime/MethodInvocation.h): Removed.
+	(ordinary_java_source_files): Don't mention
+	MethodInvocation.java.
+	* gnu/gcj/runtime/MethodInvocation.java: Removed.
+	* interpret.cc (MethodInvocation::continue1): Removed.
+	(run): Handle exceptions here.
+	* java/lang/ClassLoader.java (defineClass1, defineClass2):
+	Removed.
+	* java/lang/natClassLoader.cc (defineClass0): Catch exceptions
+	here.
+	(defineClass2): Removed.
+
+	* java/lang/reflect/Method.java (hack_trampoline, hack_call):
+	Removed.
+	* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Catch
+	exceptions here.
+	(hack_call): Removed.
+
+	* java/lang/Class.h (Class): Removed hackRunInitializers,
+	hackTrampoline.
+	* java/lang/natClass.cc (hackRunInitializers): Removed.
+	(initializeClass): Catch exceptions here.
+	Include ExceptionInInitializerError.h.
+	* java/lang/Class.java (hackTrampoline, hackRunInitializers):
+	Removed.
+
+	* java/lang/Object.h (Object): Don't mention hack12_6.
+	* java/lang/natObject.cc (_Jv_FinalizeObject): Catch exceptions
+	here.
+	* java/lang/Object.java (hack12_6): Removed.
+
+	* java/lang/natThread.cc (run_): Renamed.  Catch exceptions here.
+	(start): Use run_, not run__.
+	* java/lang/Thread.java (run_): Renamed from run__; old run_
+	removed.
+
+	* jni.cc (_Jv_JNI_FindClass): Handle exceptions.
+	(_Jv_JNI_EnsureLocalCapacity): Likewise.
+	(_Jv_JNI_DefineClass): Likewise.
+	(_Jv_JNI_ThrowNew): Likewise.
+	(_Jv_JNI_AllocObject): Likewise.
+	(_Jv_JNI_GetAnyMethodID): Likewise.
+	(_Jv_JNI_CallAnyMethodV): Likewise.
+	(_Jv_JNI_CallAnyMethodA): Likewise.
+	(_Jv_JNI_CallAnyVoidMethodV): Likewise.
+	(_Jv_JNI_CallAnyVoidMethodA): Likewise.
+	(_Jv_JNI_GetAnyFieldID): Likewise.
+	(_Jv_JNI_NewString): Likewise.
+	(_Jv_JNI_NewStringUTF): Likewise.
+	(_Jv_JNI_GetStringUTFChars): Likewise.
+	(_Jv_JNI_NewObjectArray): Likewise.
+	(_Jv_JNI_NewPrimitiveArray): Likewise.
+	(_Jv_JNI_GetPrimitiveArrayRegion): Likewise.
+	(_Jv_JNI_GetStringRegion): Likewise.
+	(_Jv_JNI_GetStringUTFRegion): Likewise.
+	(_Jv_JNI_SetPrimitiveArrayRegion): Likewise.
+	(_Jv_JNI_MonitorEnter): Likewise.
+	(_Jv_JNI_MonitorExit): Likewise.
+	(_Jv_JNI_ToReflectedField): Likewise.
+	(_Jv_JNI_ToReflectedMethod): Likewise.
+	(_Jv_JNI_RegisterNatives): Likewise.
+	(_Jv_JNI_AttachCurrentThread): Likewise.
+	(_Jv_JNI_DestroyJavaVM): Likewise.
+
 2000-02-28  Mo DeJong  <mdejong@cygnus.com>
 
 	* java/util/zip/ZipOutputStream.java(closeEntry) : Fixed
diff --git a/libjava/Makefile.am b/libjava/Makefile.am
index 3fa4841..65506cc 100644
--- a/libjava/Makefile.am
+++ b/libjava/Makefile.am
@@ -267,11 +267,6 @@ gnu/gcj/runtime/VMClassLoader.h: gnu/gcj/runtime/VMClassLoader.class libgcj.zip
 	    -friend 'java::lang::ClassLoader;' \
 	    $(basename $<)
 
-gnu/gcj/runtime/MethodInvocation.h: gnu/gcj/runtime/MethodInvocation.class libgcj.zip
-	$(GCJH) -classpath $(top_builddir) \
-	    -friend 'class _Jv_InterpMethod;' \
-	    $(basename $<)
-
 ## Headers we maintain by hand and which we want to install.
 extra_headers = java/lang/Object.h java/lang/Class.h
 
@@ -525,7 +520,6 @@ ordinary_java_source_files =  $(convert_source_files) \
 gnu/gcj/io/DefaultMimeTypes.java \
 gnu/gcj/io/MimeTypes.java \
 gnu/gcj/jni/NativeThread.java \
-gnu/gcj/runtime/MethodInvocation.java \
 gnu/gcj/runtime/VMClassLoader.java \
 gnu/gcj/text/BaseBreakIterator.java \
 gnu/gcj/text/CharacterBreakIterator.java \
diff --git a/libjava/Makefile.in b/libjava/Makefile.in
index 0185881..6fd0366 100644
--- a/libjava/Makefile.in
+++ b/libjava/Makefile.in
@@ -329,7 +329,6 @@ ordinary_java_source_files = $(convert_source_files) \
 gnu/gcj/io/DefaultMimeTypes.java \
 gnu/gcj/io/MimeTypes.java \
 gnu/gcj/jni/NativeThread.java \
-gnu/gcj/runtime/MethodInvocation.java \
 gnu/gcj/runtime/VMClassLoader.java \
 gnu/gcj/text/BaseBreakIterator.java \
 gnu/gcj/text/CharacterBreakIterator.java \
@@ -739,7 +738,7 @@ THANKS acinclude.m4 aclocal.m4 configure configure.in libgcj.spec.in
 
 DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
 
-TAR = gtar
+TAR = tar
 GZIP_ENV = --best
 DIST_SUBDIRS =  @DIRLTDL@ testsuite gcj include @DIRLTDL@ gcj include
 DEP_FILES =  .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
@@ -765,7 +764,6 @@ DEP_FILES =  .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
 .deps/gnu/gcj/protocol/http/Handler.P \
 .deps/gnu/gcj/protocol/jar/Connection.P \
 .deps/gnu/gcj/protocol/jar/Handler.P \
-.deps/gnu/gcj/runtime/MethodInvocation.P \
 .deps/gnu/gcj/runtime/VMClassLoader.P \
 .deps/gnu/gcj/text/BaseBreakIterator.P \
 .deps/gnu/gcj/text/CharacterBreakIterator.P \
@@ -1284,7 +1282,7 @@ distdir: $(DISTFILES)
 	@for file in $(DISTFILES); do \
 	  d=$(srcdir); \
 	  if test -d $$d/$$file; then \
-	    cp -pr $$d/$$file $(distdir)/$$file; \
+	    cp -pr $$/$$file $(distdir)/$$file; \
 	  else \
 	    test -f $(distdir)/$$file \
 	    || ln $$d/$$file $(distdir)/$$file 2> /dev/null \
@@ -1565,11 +1563,6 @@ gnu/gcj/runtime/VMClassLoader.h: gnu/gcj/runtime/VMClassLoader.class libgcj.zip
 	    -friend 'java::lang::ClassLoader;' \
 	    $(basename $<)
 
-gnu/gcj/runtime/MethodInvocation.h: gnu/gcj/runtime/MethodInvocation.class libgcj.zip
-	$(GCJH) -classpath $(top_builddir) \
-	    -friend 'class _Jv_InterpMethod;' \
-	    $(basename $<)
-
 install-data-local:
 	$(PRE_INSTALL)
 	@for f in $(nat_headers) $(extra_headers); do \
diff --git a/libjava/gnu/gcj/runtime/MethodInvocation.java b/libjava/gnu/gcj/runtime/MethodInvocation.java
deleted file mode 100644
index 4fee5b3..0000000
--- a/libjava/gnu/gcj/runtime/MethodInvocation.java
+++ /dev/null
@@ -1,32 +0,0 @@
-// MethodInvocation.java - wrapper used by the interpreter.
-// (the native method is implemented in interpret.cc)
-
-/* Copyright (C) 1999  Red Hat, Inc.
-
-   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 <krab@gnu.org>  */
-
-package gnu.gcj.runtime;
-
-import gnu.gcj.RawData;
-
-final class MethodInvocation {
-
-  private static Throwable continue0 (RawData meth, RawData inv)
-  {
-    try {
-      continue1 (meth, inv);
-    } catch (Throwable ex) {
-      return ex;
-    }
-    return null;
-  }
-
-  private static native void continue1 (RawData meth, RawData inv);
-
-}
diff --git a/libjava/include/java-interp.h b/libjava/include/java-interp.h
index 3f33d54..3074a2c 100644
--- a/libjava/include/java-interp.h
+++ b/libjava/include/java-interp.h
@@ -20,7 +20,6 @@ details.  */
 
 #include <java/lang/Class.h>
 #include <java/lang/ClassLoader.h>
-#include <gnu/gcj/runtime/MethodInvocation.h>
 
 extern "C" {
 #include <ffi.h>
@@ -135,7 +134,6 @@ class _Jv_InterpMethod : public _Jv_MethodBase
 
   friend class _Jv_ClassReader;
   friend class _Jv_InterpMethodInvocation;
-  friend class gnu::gcj::runtime::MethodInvocation;
 
   friend void _Jv_PrepareClass(jclass);
 };
diff --git a/libjava/interpret.cc b/libjava/interpret.cc
index 6cde68d..2dc5e77 100644
--- a/libjava/interpret.cc
+++ b/libjava/interpret.cc
@@ -33,19 +33,7 @@ details.  */
 #include <java-insns.h>
 #include <java-signal.h>
 
-#ifndef INTERPRETER
-
-#include <gnu/gcj/runtime/MethodInvocation.h>
-
-/* This should never happen. */
-void 
-gnu::gcj::runtime::MethodInvocation::continue1 (gnu::gcj::RawData *,
-						gnu::gcj::RawData *)
-{
-  JvFail ("no interpreter");
-}
-
-#else
+#ifdef INTERPRETER
 
 #define ClassError _CL_Q34java4lang5Error
 extern java::lang::Class ClassError;
@@ -216,10 +204,17 @@ _Jv_InterpMethod::run (ffi_cif* cif,
   memcpy ((void*) locals, (void*) args, args_raw_size);
 
  next_segment:
-  /* this will call the method _Jv_InterpMethod::continue0, see below */
-  jobject ex = 
-    gnu::gcj::runtime::MethodInvocation::continue0
-    ((gnu::gcj::RawData *)this, (gnu::gcj::RawData *)inv);
+
+  jobject ex = NULL;
+
+  try
+    {
+      continue1 (inv);
+    }
+  catch (java::lang::Throwable *ex2)
+    {
+      ex = ex2;
+    }
 
   if (ex == 0)			// no exception...
     {
@@ -280,7 +275,6 @@ _Jv_InterpMethod::run (ffi_cif* cif,
 	default:
 	  throw_internal_error ("unknown return type");
 	}
-
     }
 
   /** handle an exception */
@@ -379,16 +373,6 @@ void _Jv_InterpMethod::run_synch_class (ffi_cif* cif,
   if (ex != 0) _Jv_Throw (ex);
 }
 
-/* this is the exception handler hack, for the interpreter */
-void 
-gnu::gcj::runtime::MethodInvocation::continue1 (gnu::gcj::RawData *meth,
-						gnu::gcj::RawData *inv)
-{
-  _Jv_InterpMethod           *meth0 = (_Jv_InterpMethod*)meth;
-  _Jv_InterpMethodInvocation *inv0  = (_Jv_InterpMethodInvocation*)inv;
-  meth0->continue1 (inv0);
-}
-
 /*
   This proceeds execution, as designated in "inv".  If an exception
   happens, then it is simply thrown, and handled in Java.  Thus, the pc
diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h
index 2ad6c5d..717eed7 100644
--- a/libjava/java/lang/Class.h
+++ b/libjava/java/lang/Class.h
@@ -157,9 +157,6 @@ public:
 private:
   void checkMemberAccess (jint flags);
 
-  // Various functions to handle class initialization.
-  java::lang::Throwable *hackTrampoline (jint, java::lang::Throwable *);
-  void hackRunInitializers (void);
   void initializeClass (void);
 
   // Friend functions implemented in natClass.cc.
diff --git a/libjava/java/lang/Class.java b/libjava/java/lang/Class.java
index 1d73c89..b080624 100644
--- a/libjava/java/lang/Class.java
+++ b/libjava/java/lang/Class.java
@@ -172,32 +172,6 @@ public final class Class implements Serializable
       sm.checkMemberAccess(this, flags);
   }
 
-  // FIXME: this method exists only because we cannot catch Java
-  // exceptions from C++ code.  This is a helper for initializeClass.
-  private Throwable hackTrampoline (int what, Throwable old_exception)
-    {
-      Throwable new_val = null;
-      try
-	{
-	  if (what == 0)
-	    initializeClass ();
-	  else if (what == 1)
-	    hackRunInitializers ();
-	  else if (what == 2)
-	    new_val = new ExceptionInInitializerError (old_exception);
-	}
-      catch (Throwable t)
-	{
-	  new_val = t;
-	}
-      return new_val;
-    }
-
-  // FIXME: this is a hack to let us run the class initializers.  We
-  // could do it inline in initializeClass() if we could catch Java
-  // exceptions from C++.
-  private native void hackRunInitializers ();
-
   // Initialize the class.
   private native void initializeClass ();
 
diff --git a/libjava/java/lang/ClassLoader.java b/libjava/java/lang/ClassLoader.java
index 776093e..fb3f37a 100644
--- a/libjava/java/lang/ClassLoader.java
+++ b/libjava/java/lang/ClassLoader.java
@@ -1,6 +1,6 @@
 // ClassLoader.java - Define policies for loading Java classes.
 
-/* Copyright (C) 1998, 1999  Red Hat, Inc.
+/* Copyright (C) 1998, 1999, 2000  Red Hat, Inc.
 
    This file is part of libgcj.
 
@@ -234,28 +234,6 @@ public abstract class ClassLoader {
     throws java.lang.ClassNotFoundException, java.lang.LinkageError;
 
 
-  /** This is called by defineClass0, once the "raw" and uninitialized
-   * class object has been created, and handles exceptions generated
-   * while actually defining the class (_Jv_DefineClass).  defineClass0
-   * holds the lock on the new class object, so it needs to capture
-   * these exceptions.  */
-
-  private static Throwable defineClass1 (Class klass, byte[] data,
-					 int offset, int length)
-  {
-    try {
-      defineClass2 (klass, data, offset, length);
-    } catch (Throwable x) {
-      return x;
-    }
-    return null;
-  }
- 
-  /** This is just a wrapper for _Jv_DefineClass */
-  private static native void defineClass2 (Class klass, byte[] data, 
-				    int offset, int length)
-    throws Throwable;
-
   /** 
    * Link the given class.  This will bring the class to a state where
    * the class initializer can be run.  Linking involves the following
diff --git a/libjava/java/lang/Object.h b/libjava/java/lang/Object.h
index 05a4751..5e7337a 100644
--- a/libjava/java/lang/Object.h
+++ b/libjava/java/lang/Object.h
@@ -1,6 +1,6 @@
 // Object.h - Header file for java.lang.Object.  -*- c++ -*-
 
-/* Copyright (C) 1998, 1999  Red Hat, Inc.
+/* Copyright (C) 1998, 1999, 2000  Red Hat, Inc.
 
    This file is part of libgcj.
 
@@ -69,8 +69,6 @@ private:
 
   // Initialize the sync_info field.
   void sync_init (void);
-
-  static void hack12_6 (jobject f);
 };
 
 #endif /* __JAVA_LANG_OBJECT_H__ */
diff --git a/libjava/java/lang/Object.java b/libjava/java/lang/Object.java
index b61943a..9523f03 100644
--- a/libjava/java/lang/Object.java
+++ b/libjava/java/lang/Object.java
@@ -1,6 +1,6 @@
 // Object.java - The root of all evil.
 
-/* Copyright (C) 1998, 1999  Red Hat, Inc.
+/* Copyright (C) 1998, 1999, 2000  Red Hat, Inc.
 
    This file is part of libgcj.
 
@@ -66,21 +66,6 @@ public class Object
   // completeness (some day we'll be able to auto-generate Object.h).
   private final native void sync_init ();
 
-  // This exists as a workaround for the fact that we can't catch a
-  // Java Exception from C++.  This is from section 12.6 of the Java
-  // Language Spec.  FIXME: remove this once exception processing
-  // works.
-  private static final void hack12_6 (Object f)
-  {
-    try
-      {
-	f.finalize();
-      }
-    catch (Throwable x)
-      {
-      }
-  }
-
   // Note that we don't mention the sync_info field here.  If we do,
   // jc1 will not work correctly.
 }
diff --git a/libjava/java/lang/Thread.java b/libjava/java/lang/Thread.java
index 68dc244..9cf7109 100644
--- a/libjava/java/lang/Thread.java
+++ b/libjava/java/lang/Thread.java
@@ -116,8 +116,8 @@ public class Thread implements Runnable
   public final native void resume ();
 
   // This method exists only to avoid a warning from the C++ compiler.
-  private static final native void run__ (Object obj);
-  private native final void finish_ ();
+  private static final native void run_ (Object obj);
+  private final native void finish_ ();
 
   // Convenience method to check and clear the thread's interrupted status.  
   private boolean isInterrupted_ ()
@@ -127,28 +127,6 @@ public class Thread implements Runnable
     return r;
   }
   
-  private final void run_ ()
-  {
-    try
-      {
-	run ();
-      }
-    catch (Throwable e)
-      {
-	// Uncaught exceptions are forwarded to the ThreadGroup.  If
-	// this results in an uncaught exception, that is ignored.
-	try
-	  {
-	    group.uncaughtException(this, e);
-	  }
-	catch (Throwable f)
-	  {
-	    // Nothing.
-	  }
-      }
-    finish_ ();
-  }
-
   public void run ()
   {
     if (runnable != null)
diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc
index 882fadd..42af715 100644
--- a/libjava/java/lang/natClass.cc
+++ b/libjava/java/lang/natClass.cc
@@ -27,6 +27,7 @@ details.  */
 #include <java/lang/reflect/Constructor.h>
 #include <java/lang/AbstractMethodError.h>
 #include <java/lang/ClassNotFoundException.h>
+#include <java/lang/ExceptionInInitializerError.h>
 #include <java/lang/IllegalAccessException.h>
 #include <java/lang/IllegalAccessError.h>
 #include <java/lang/IncompatibleClassChangeError.h>
@@ -690,15 +691,6 @@ java::lang::Class::finalize (void)
 #endif
 }
 
-// FIXME.
-void
-java::lang::Class::hackRunInitializers (void)
-{
-  _Jv_Method *meth = _Jv_GetMethodLocal (this, clinit_name, void_signature);
-  if (meth)
-    ((void (*) (void)) meth->ncode) ();
-}
-
 // This implements the initialization process for a class.  From Spec
 // section 12.4.2.
 void
@@ -764,46 +756,53 @@ java::lang::Class::initializeClass (void)
   // Step 7.
   if (! isInterface () && superclass)
     {
-      // FIXME: We can't currently catch a Java exception in C++ code.
-      // So instead we call a Java trampoline.  It returns an
-      // exception, or null.
-      jobject except = superclass->hackTrampoline(0, NULL);
-      if (except)
+      try
+	{
+	  superclass->initializeClass ();
+	}
+      catch (java::lang::Throwable *except)
 	{
 	  // Caught an exception.
 	  _Jv_MonitorEnter (this);
 	  state = JV_STATE_ERROR;
 	  notifyAll ();
 	  _Jv_MonitorExit (this);
-	  JvThrow (except);
+	  throw except;
 	}
     }
 
-  // Step 8.
-  // FIXME: once again we have to go through a trampoline.
-  java::lang::Throwable *except = hackTrampoline (1, NULL);
-
-  // Steps 9, 10, 11.
-  if (! except)
+  // Steps 8, 9, 10, 11.
+  try
     {
-      _Jv_MonitorEnter (this);
-      state = JV_STATE_DONE;
+      _Jv_Method *meth = _Jv_GetMethodLocal (this, clinit_name,
+					     void_signature);
+      if (meth)
+	((void (*) (void)) meth->ncode) ();
     }
-  else
+  catch (java::lang::Throwable *except)
     {
       if (! ErrorClass.isInstance(except))
 	{
-	  // Once again we must use the trampoline.  In this case we
-	  // have to detect an OutOfMemoryError.
-	  except = hackTrampoline(2, except);
+	  try
+	    {
+	      except = new ExceptionInInitializerError (except);
+	    }
+	  catch (java::lang::Throwable *t)
+	    {
+	      except = t;
+	    }
 	}
       _Jv_MonitorEnter (this);
       state = JV_STATE_ERROR;
+      notifyAll ();
+      _Jv_MonitorExit (this);
+      JvThrow (except);
     }
+
+  _Jv_MonitorEnter (this);
+  state = JV_STATE_DONE;
   notifyAll ();
   _Jv_MonitorExit (this);
-  if (except)
-    JvThrow (except);
 }
 
 
diff --git a/libjava/java/lang/natClassLoader.cc b/libjava/java/lang/natClassLoader.cc
index e5ff17e..39ee0ba 100644
--- a/libjava/java/lang/natClassLoader.cc
+++ b/libjava/java/lang/natClassLoader.cc
@@ -58,15 +58,6 @@ java::lang::ClassLoader::getSystemClassLoader (void)
   return system;
 }
 
-void
-java::lang::ClassLoader::defineClass2 (jclass klass, jbyteArray data,
-				       jint offset, jint length)
-{
-#ifdef INTERPRETER
-  _Jv_DefineClass (klass, data, offset, length);
-#endif
-}
-
 java::lang::Class *
 java::lang::ClassLoader::defineClass0 (jstring name,
 				       jbyteArray data, 
@@ -94,11 +85,11 @@ java::lang::ClassLoader::defineClass0 (jstring name,
       klass->name = name2;
     }
 
-  // this will do the magic.  loadInto also operates
-  // as an exception trampoline for now...
-  Throwable *ex = defineClass1 (klass, data, offset, length);
-    
-  if (ex)  // we failed to load it
+  try
+    {
+      _Jv_DefineClass (klass, data, offset, length);
+    }
+  catch (java::lang::Throwable *ex)
     {
       klass->state = JV_STATE_ERROR;
       klass->notifyAll ();
@@ -106,15 +97,15 @@ java::lang::ClassLoader::defineClass0 (jstring name,
       _Jv_UnregisterClass (klass);
 
       _Jv_MonitorExit (klass);
-	  
+
       // FIXME: Here we may want to test that EX does
       // indeed represent a valid exception.  That is,
       // anything but ClassNotFoundException, 
       // or some kind of Error.
-	  
+
       JvThrow (ex);
     }
-    
+
   // if everything proceeded sucessfully, we're loaded.
   JvAssert (klass->state == JV_STATE_LOADED);
 
diff --git a/libjava/java/lang/natObject.cc b/libjava/java/lang/natObject.cc
index 66fbdbf..cdce6d2 100644
--- a/libjava/java/lang/natObject.cc
+++ b/libjava/java/lang/natObject.cc
@@ -1,6 +1,6 @@
 // natObject.cc - Implementation of the Object class.
 
-/* Copyright (C) 1998, 1999  Red Hat, Inc.
+/* Copyright (C) 1998, 1999, 2000  Red Hat, Inc.
 
    This file is part of libgcj.
 
@@ -242,5 +242,13 @@ _Jv_MonitorExit (jobject obj)
 void
 _Jv_FinalizeObject (jobject obj)
 {
-  java::lang::Object::hack12_6(obj);
+  // Ignore exceptions.  From section 12.6 of the Java Language Spec.
+  try
+    {
+      obj->finalize ();
+    }
+  catch (java::lang::Throwable *t)
+    {
+      // Ignore.
+    }
 }
diff --git a/libjava/java/lang/natThread.cc b/libjava/java/lang/natThread.cc
index 6d05217..9c56808 100644
--- a/libjava/java/lang/natThread.cc
+++ b/libjava/java/lang/natThread.cc
@@ -263,9 +263,9 @@ java::lang::Thread::sleep (jlong millis, jint nanos)
 }
 
 void
-java::lang::Thread::finish_ (void)
+java::lang::Thread::finish_ ()
 {
-  // Notify all threads waiting to join this thread.
+  // Notify all threads waiting to join this this.
   _Jv_MonitorEnter (this);
   alive_flag = false;
 
@@ -285,10 +285,28 @@ java::lang::Thread::finish_ (void)
 }
 
 void
-java::lang::Thread::run__ (jobject obj)
+java::lang::Thread::run_ (jobject obj)
 {
   java::lang::Thread *thread = (java::lang::Thread *) obj;
-  thread->run_ ();
+  try
+    {
+      thread->run ();
+    }
+  catch (java::lang::Throwable *t)
+    {
+      // Uncaught exceptions are forwarded to the ThreadGroup.  If
+      // this results in an uncaught exception, that is ignored.
+      try
+	{
+	  thread->group->uncaughtException (thread, t);
+	}
+      catch (java::lang::Throwable *f)
+	{
+	  // Nothing.
+	}
+    }
+
+  thread->finish_ ();
 }
 
 void
@@ -301,7 +319,7 @@ java::lang::Thread::start (void)
 
   alive_flag = true;
   natThread *nt = (natThread *) data;
-  _Jv_ThreadStart (this, nt->thread, (_Jv_ThreadStartFunc *) &run__);
+  _Jv_ThreadStart (this, nt->thread, (_Jv_ThreadStartFunc *) &run_);
 }
 
 void
diff --git a/libjava/java/lang/reflect/Method.java b/libjava/java/lang/reflect/Method.java
index edca309..e95ca0d 100644
--- a/libjava/java/lang/reflect/Method.java
+++ b/libjava/java/lang/reflect/Method.java
@@ -1,6 +1,6 @@
 // Method.java - Represent method of class or interface.
 
-/* Copyright (C) 1998, 1999  Red Hat, Inc.
+/* Copyright (C) 1998, 1999, 2000  Red Hat, Inc.
 
    This file is part of libgcj.
 
@@ -68,30 +68,6 @@ public final class Method extends AccessibleObject implements Member
       return name.hashCode() + declaringClass.getName().hashCode();
     }
 
-  // This is used to perform an actual method call via ffi.
-  private static final native void hack_call (RawData cif,
-					      RawData method,
-					      RawData ret_value,
-					      RawData values);
-
-  // Perform an ffi call while capturing exceptions.  We have to do
-  // this because we can't catch Java exceptions from C++.
-  static final Throwable hack_trampoline (RawData cif,
-					  RawData method,
-					  RawData ret_value,
-					  RawData values)
-  {
-    try
-      {
-	hack_call (cif, method, ret_value, values);
-      }
-    catch (Throwable x)
-      {
-	return x;
-      }
-    return null;
-  }
-
   public native Object invoke (Object obj, Object[] args)
     throws IllegalAccessException, IllegalArgumentException,
            InvocationTargetException;
diff --git a/libjava/java/lang/reflect/natMethod.cc b/libjava/java/lang/reflect/natMethod.cc
index 988fa1e..c4482ee 100644
--- a/libjava/java/lang/reflect/natMethod.cc
+++ b/libjava/java/lang/reflect/natMethod.cc
@@ -152,21 +152,6 @@ get_ffi_type (jclass klass)
   return r;
 }
 
-// Actually perform an FFI call.
-void
-java::lang::reflect::Method::hack_call (gnu::gcj::RawData *rcif,
-					gnu::gcj::RawData *rmethod,
-					gnu::gcj::RawData *rret_value,
-					gnu::gcj::RawData *rvalues)
-{
-  ffi_cif *cif = (ffi_cif *) rcif;
-  void (*method) (...) = (void (*) (...)) rmethod;
-  void *ret_value = (void *) rret_value;
-  void **values = (void **) rvalues;
-
-  ffi_call (cif, method, ret_value, values);
-}
-
 jobject
 java::lang::reflect::Method::invoke (jobject obj, jobjectArray args)
 {
@@ -419,19 +404,23 @@ _Jv_CallAnyMethodA (jobject obj,
 
   // FIXME: initialize class here.
 
-  java::lang::Throwable *ex;
   using namespace java::lang;
   using namespace java::lang::reflect;
-  ex = Method::hack_trampoline ((gnu::gcj::RawData *) &cif,
-				(gnu::gcj::RawData *) meth->ncode,
-				(gnu::gcj::RawData *) result,
-				(gnu::gcj::RawData *) values);
 
-  if (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 (ex);
+  Throwable *ex = NULL;
+
+  try
+    {
+      ffi_call (&cif, (void (*) (...)) meth->ncode, result, values);
+    }
+  catch (Throwable *ex2)
+    {
+      // 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);
+    }
 
   if (is_constructor)
     result->l = obj;
diff --git a/libjava/jni.cc b/libjava/jni.cc
index 3eca4057..f06e580 100644
--- a/libjava/jni.cc
+++ b/libjava/jni.cc
@@ -115,6 +115,7 @@ mark_for_gc (jobject obj)
   using namespace java::lang;
   Integer *refcount = (Integer *) ref_table->get (obj);
   jint val = (refcount == NULL) ? 0 : refcount->intValue ();
+  // FIXME: what about out of memory error?
   ref_table->put (obj, new Integer (val + 1));
 }
 
@@ -131,6 +132,7 @@ unmark_for_gc (jobject obj)
   if (val == 0)
     ref_table->remove (obj);
   else
+    // FIXME: what about out of memory error?
     ref_table->put (obj, new Integer (val));
 }
 
@@ -180,13 +182,15 @@ _Jv_JNI_EnsureLocalCapacity (JNIEnv *env, jint size)
   // size.  This isn't the most efficient thing, but for now we don't
   // care.  Note that _Jv_JNI_PushLocalFrame relies on this right now.
 
-  _Jv_JNI_LocalFrame *frame
-    = (_Jv_JNI_LocalFrame *) _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame)
-						  + size * sizeof (jobject));
-  if (frame == NULL)
+  _Jv_JNI_LocalFrame *frame;
+  try
     {
-      // FIXME: exception processing.
-      env->ex = new java::lang::OutOfMemoryError;
+      frame = (_Jv_JNI_LocalFrame *) _Jv_Malloc (sizeof (_Jv_JNI_LocalFrame)
+						 + size * sizeof (jobject));
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
       return JNI_ERR;
     }
 
@@ -304,16 +308,24 @@ static jclass
 _Jv_JNI_DefineClass (JNIEnv *env, jobject loader, 
 		     const jbyte *buf, jsize bufLen)
 {
-  jbyteArray bytes = JvNewByteArray (bufLen);
-  jbyte *elts = elements (bytes);
-  memcpy (elts, buf, bufLen * sizeof (jbyte));
+  try
+    {
+      jbyteArray bytes = JvNewByteArray (bufLen);
 
-  java::lang::ClassLoader *l
-    = reinterpret_cast<java::lang::ClassLoader *> (loader);
+      jbyte *elts = elements (bytes);
+      memcpy (elts, buf, bufLen * sizeof (jbyte));
 
-  // FIXME: exception processing.
-  jclass result = l->defineClass (bytes, 0, bufLen);
-  return (jclass) wrap_value (env, result);
+      java::lang::ClassLoader *l
+	= reinterpret_cast<java::lang::ClassLoader *> (loader);
+
+      jclass result = l->defineClass (bytes, 0, bufLen);
+      return (jclass) wrap_value (env, result);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+      return NULL;
+    }
 }
 
 static jclass
@@ -324,20 +336,29 @@ _Jv_JNI_FindClass (JNIEnv *env, const char *name)
   char s[len + 1];
   for (int i = 0; i <= len; ++i)
     s[i] = (name[i] == '/') ? '.' : name[i];
-  jstring n = JvNewStringUTF (s);
 
-  java::lang::ClassLoader *loader;
-  if (env->klass == NULL)
+  jclass r = NULL;
+  try
     {
-      // FIXME: should use getBaseClassLoader, but we don't have that
-      // yet.
-      loader = java::lang::ClassLoader::getSystemClassLoader ();
-    }
-  else
-    loader = env->klass->getClassLoader ();
+      // This might throw an out of memory exception.
+      jstring n = JvNewStringUTF (s);
+
+      java::lang::ClassLoader *loader;
+      if (env->klass == NULL)
+	{
+	  // FIXME: should use getBaseClassLoader, but we don't have that
+	  // yet.
+	  loader = java::lang::ClassLoader::getSystemClassLoader ();
+	}
+      else
+	loader = env->klass->getClassLoader ();
 
-  // FIXME: exception processing.
-  jclass r = loader->loadClass (n);
+      r = loader->loadClass (n);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
 
   return (jclass) wrap_value (env, r);
 }
@@ -370,24 +391,32 @@ _Jv_JNI_ThrowNew (JNIEnv *env, jclass clazz, const char *message)
 
   JvAssert ((&ThrowableClass)->isAssignableFrom (clazz));
 
-  JArray<jclass> *argtypes
-    = (JArray<jclass> *) JvNewObjectArray (1, &ClassClass, NULL);
+  int r = JNI_OK;
+  try
+    {
+      JArray<jclass> *argtypes
+	= (JArray<jclass> *) JvNewObjectArray (1, &ClassClass, NULL);
 
-  jclass *elts = elements (argtypes);
-  elts[0] = &StringClass;
+      jclass *elts = elements (argtypes);
+      elts[0] = &StringClass;
 
-  // FIXME: exception processing.
-  Constructor *cons = clazz->getConstructor (argtypes);
+      Constructor *cons = clazz->getConstructor (argtypes);
 
-  jobjectArray values = JvNewObjectArray (1, &StringClass, NULL);
-  jobject *velts = elements (values);
-  velts[0] = JvNewStringUTF (message);
+      jobjectArray values = JvNewObjectArray (1, &StringClass, NULL);
+      jobject *velts = elements (values);
+      velts[0] = JvNewStringUTF (message);
 
-  // FIXME: exception processing.
-  jobject obj = cons->newInstance (values);
+      jobject obj = cons->newInstance (values);
 
-  env->ex = reinterpret_cast<jthrowable> (obj);
-  return 0;
+      env->ex = reinterpret_cast<jthrowable> (obj);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+      r = JNI_ERR;
+    }
+
+  return r;
 }
 
 static jthrowable
@@ -435,14 +464,20 @@ _Jv_JNI_AllocObject (JNIEnv *env, jclass clazz)
   jobject obj = NULL;
   using namespace java::lang::reflect;
 
-  JvAssert (clazz && ! clazz->isArray ());
-  if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers()))
-    env->ex = new java::lang::InstantiationException ();
-  else
+  try
+    {
+      JvAssert (clazz && ! clazz->isArray ());
+      if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers()))
+	env->ex = new java::lang::InstantiationException ();
+      else
+	{
+	  // FIXME: will this work for String?
+	  obj = JvAllocObject (clazz);
+	}
+    }
+  catch (jthrowable t)
     {
-      // FIXME: exception processing.
-      // FIXME: will this work for String?
-      obj = JvAllocObject (clazz);
+      env->ex = t;
     }
 
   return wrap_value (env, obj);
@@ -472,36 +507,43 @@ static jmethodID
 _Jv_JNI_GetAnyMethodID (JNIEnv *env, jclass clazz,
 			const char *name, const char *sig)
 {
-  // FIXME: exception processing.
-  _Jv_InitClass (clazz);
-
-  _Jv_Utf8Const *name_u = _Jv_makeUtf8Const ((char *) name, -1);
-  _Jv_Utf8Const *sig_u = _Jv_makeUtf8Const ((char *) sig, -1);
+  try
+    {
+      _Jv_InitClass (clazz);
 
-  JvAssert (! clazz->isPrimitive());
+      _Jv_Utf8Const *name_u = _Jv_makeUtf8Const ((char *) name, -1);
+      _Jv_Utf8Const *sig_u = _Jv_makeUtf8Const ((char *) sig, -1);
 
-  using namespace java::lang::reflect;
+      JvAssert (! clazz->isPrimitive());
 
-  while (clazz != NULL)
-    {
-      jint count = JvNumMethods (clazz);
-      jmethodID meth = JvGetFirstMethod (clazz);
+      using namespace java::lang::reflect;
 
-      for (jint i = 0; i < count; ++i)
+      while (clazz != NULL)
 	{
-	  if (((is_static && Modifier::isStatic (meth->accflags))
-	       || (! is_static && ! Modifier::isStatic (meth->accflags)))
-	      && _Jv_equalUtf8Consts (meth->name, name_u)
-	      && _Jv_equalUtf8Consts (meth->signature, sig_u))
-	    return meth;
+	  jint count = JvNumMethods (clazz);
+	  jmethodID meth = JvGetFirstMethod (clazz);
+
+	  for (jint i = 0; i < count; ++i)
+	    {
+	      if (((is_static && Modifier::isStatic (meth->accflags))
+		   || (! is_static && ! Modifier::isStatic (meth->accflags)))
+		  && _Jv_equalUtf8Consts (meth->name, name_u)
+		  && _Jv_equalUtf8Consts (meth->signature, sig_u))
+		return meth;
+
+	      meth = meth->getNextMethod();
+	    }
 
-	  meth = meth->getNextMethod();
+	  clazz = clazz->getSuperclass ();
 	}
 
-      clazz = clazz->getSuperclass ();
+      env->ex = new java::lang::NoSuchMethodError ();
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
     }
 
-  env->ex = new java::lang::NoSuchMethodError ();
   return NULL;
 }
 
@@ -553,27 +595,36 @@ _Jv_JNI_CallAnyMethodV (JNIEnv *env, jobject obj, jclass klass,
 
   jclass return_type;
   JArray<jclass> *arg_types;
-  // FIXME: exception processing.
-  _Jv_GetTypesFromSignature (id, decl_class,
-			     &arg_types, &return_type);
 
-  jvalue args[arg_types->length];
-  array_from_valist (args, arg_types, vargs);
+  try
+    {
+      _Jv_GetTypesFromSignature (id, decl_class,
+				 &arg_types, &return_type);
+
+      jvalue args[arg_types->length];
+      array_from_valist (args, arg_types, vargs);
 
-  // For constructors we need to pass the Class we are instantiating.
-  if (style == constructor)
-    return_type = klass;
+      // For constructors we need to pass the Class we are instantiating.
+      if (style == constructor)
+	return_type = klass;
 
-  jvalue result;
-  jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
-				      style == constructor,
-				      arg_types, args, &result);
+      jvalue result;
+      jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
+					  style == constructor,
+					  arg_types, args, &result);
 
-  if (ex != NULL)
-    env->ex = ex;
+      if (ex != NULL)
+	env->ex = ex;
 
-  // We cheat a little here.  FIXME.
-  return wrap_value (env, * (T *) &result);
+      // We cheat a little here.  FIXME.
+      return wrap_value (env, * (T *) &result);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
+
+  return wrap_value (env, (T) 0);
 }
 
 template<typename T, invocation_type style>
@@ -604,24 +655,32 @@ _Jv_JNI_CallAnyMethodA (JNIEnv *env, jobject obj, jclass klass,
 
   jclass return_type;
   JArray<jclass> *arg_types;
-  // FIXME: exception processing.
-  _Jv_GetTypesFromSignature (id, decl_class,
-			     &arg_types, &return_type);
+  try
+    {
+      _Jv_GetTypesFromSignature (id, decl_class,
+				 &arg_types, &return_type);
 
-  // For constructors we need to pass the Class we are instantiating.
-  if (style == constructor)
-    return_type = klass;
+      // For constructors we need to pass the Class we are instantiating.
+      if (style == constructor)
+	return_type = klass;
 
-  jvalue result;
-  jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
-				      style == constructor,
-				      arg_types, args, &result);
+      jvalue result;
+      jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
+					  style == constructor,
+					  arg_types, args, &result);
 
-  if (ex != NULL)
-    env->ex = ex;
+      if (ex != NULL)
+	env->ex = ex;
 
-  // We cheat a little here.  FIXME.
-  return wrap_value (env, * (T *) &result);
+      // We cheat a little here.  FIXME.
+      return wrap_value (env, * (T *) &result);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
+
+  return wrap_value (env, (T) 0);
 }
 
 template<invocation_type style>
@@ -637,23 +696,29 @@ _Jv_JNI_CallAnyVoidMethodV (JNIEnv *env, jobject obj, jclass klass,
 
   jclass return_type;
   JArray<jclass> *arg_types;
-  // FIXME: exception processing.
-  _Jv_GetTypesFromSignature (id, decl_class,
-			     &arg_types, &return_type);
+  try
+    {
+      _Jv_GetTypesFromSignature (id, decl_class,
+				 &arg_types, &return_type);
 
-  jvalue args[arg_types->length];
-  array_from_valist (args, arg_types, vargs);
+      jvalue args[arg_types->length];
+      array_from_valist (args, arg_types, vargs);
 
-  // For constructors we need to pass the Class we are instantiating.
-  if (style == constructor)
-    return_type = klass;
+      // For constructors we need to pass the Class we are instantiating.
+      if (style == constructor)
+	return_type = klass;
 
-  jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
-				      style == constructor,
-				      arg_types, args, NULL);
+      jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
+					  style == constructor,
+					  arg_types, args, NULL);
 
-  if (ex != NULL)
-    env->ex = ex;
+      if (ex != NULL)
+	env->ex = ex;
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
 }
 
 template<invocation_type style>
@@ -681,16 +746,22 @@ _Jv_JNI_CallAnyVoidMethodA (JNIEnv *env, jobject obj, jclass klass,
 
   jclass return_type;
   JArray<jclass> *arg_types;
-  // FIXME: exception processing.
-  _Jv_GetTypesFromSignature (id, decl_class,
-			     &arg_types, &return_type);
+  try
+    {
+      _Jv_GetTypesFromSignature (id, decl_class,
+				 &arg_types, &return_type);
 
-  jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
-				      style == constructor,
-				      arg_types, args, NULL);
+      jthrowable ex = _Jv_CallAnyMethodA (obj, return_type, id,
+					  style == constructor,
+					  arg_types, args, NULL);
 
-  if (ex != NULL)
-    env->ex = ex;
+      if (ex != NULL)
+	env->ex = ex;
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
 }
 
 // Functions with this signature are used to implement functions in
@@ -895,49 +966,55 @@ static jfieldID
 _Jv_JNI_GetAnyFieldID (JNIEnv *env, jclass clazz,
 		       const char *name, const char *sig)
 {
-  // FIXME: exception processing.
-  _Jv_InitClass (clazz);
+  try
+    {
+      _Jv_InitClass (clazz);
 
-  _Jv_Utf8Const *a_name = _Jv_makeUtf8Const ((char *) name, -1);
+      _Jv_Utf8Const *a_name = _Jv_makeUtf8Const ((char *) name, -1);
 
-  jclass field_class = NULL;
-  if (sig[0] == '[')
-    field_class = _Jv_FindClassFromSignature ((char *) sig, NULL);
-  else
-    {
-      _Jv_Utf8Const *sig_u = _Jv_makeUtf8Const ((char *) sig, -1);
-      field_class = _Jv_FindClass (sig_u, NULL);
-    }
+      jclass field_class = NULL;
+      if (sig[0] == '[')
+	field_class = _Jv_FindClassFromSignature ((char *) sig, NULL);
+      else
+	{
+	  _Jv_Utf8Const *sig_u = _Jv_makeUtf8Const ((char *) sig, -1);
+	  field_class = _Jv_FindClass (sig_u, NULL);
+	}
 
-  // FIXME: what if field_class == NULL?
+      // FIXME: what if field_class == NULL?
 
-  while (clazz != NULL)
-    {
-      jint count = (is_static
-		    ? JvNumStaticFields (clazz)
-		    : JvNumInstanceFields (clazz));
-      jfieldID field = (is_static
-			? JvGetFirstStaticField (clazz)
-			: JvGetFirstInstanceField (clazz));
-      for (jint i = 0; i < count; ++i)
+      while (clazz != NULL)
 	{
-	  // The field is resolved as a side effect of class
-	  // initialization.
-	  JvAssert (field->isResolved ());
+	  jint count = (is_static
+			? JvNumStaticFields (clazz)
+			: JvNumInstanceFields (clazz));
+	  jfieldID field = (is_static
+			    ? JvGetFirstStaticField (clazz)
+			    : JvGetFirstInstanceField (clazz));
+	  for (jint i = 0; i < count; ++i)
+	    {
+	      // The field is resolved as a side effect of class
+	      // initialization.
+	      JvAssert (field->isResolved ());
 
-	  _Jv_Utf8Const *f_name = field->getNameUtf8Const(clazz);
+	      _Jv_Utf8Const *f_name = field->getNameUtf8Const(clazz);
 
-	  if (_Jv_equalUtf8Consts (f_name, a_name)
-	      && field->getClass() == field_class)
-	    return field;
+	      if (_Jv_equalUtf8Consts (f_name, a_name)
+		  && field->getClass() == field_class)
+		return field;
 
-	  field = field->getNextField ();
+	      field = field->getNextField ();
+	    }
+
+	  clazz = clazz->getSuperclass ();
 	}
 
-      clazz = clazz->getSuperclass ();
+      env->ex = new java::lang::NoSuchFieldError ();
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
     }
-
-  env->ex = new java::lang::NoSuchFieldError ();
   return NULL;
 }
 
@@ -960,9 +1037,16 @@ _Jv_JNI_SetStaticField (JNIEnv *, jclass, jfieldID field, T value)
 static jstring
 _Jv_JNI_NewString (JNIEnv *env, const jchar *unichars, jsize len)
 {
-  // FIXME: exception processing.
-  jstring r = _Jv_NewString (unichars, len);
-  return (jstring) wrap_value (env, r);
+  try
+    {
+      jstring r = _Jv_NewString (unichars, len);
+      return (jstring) wrap_value (env, r);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+      return NULL;
+    }
 }
 
 static jsize
@@ -990,9 +1074,16 @@ _Jv_JNI_ReleaseStringChars (JNIEnv *, jstring string, const jchar *)
 static jstring
 _Jv_JNI_NewStringUTF (JNIEnv *env, const char *bytes)
 {
-  // FIXME: exception processing.
-  jstring result = JvNewStringUTF (bytes);
-  return (jstring) wrap_value (env, result);
+  try
+    {
+      jstring result = JvNewStringUTF (bytes);
+      return (jstring) wrap_value (env, result);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+      return NULL;
+    }
 }
 
 static jsize
@@ -1002,18 +1093,25 @@ _Jv_JNI_GetStringUTFLength (JNIEnv *, jstring string)
 }
 
 static const char *
-_Jv_JNI_GetStringUTFChars (JNIEnv *, jstring string, jboolean *isCopy)
+_Jv_JNI_GetStringUTFChars (JNIEnv *env, jstring string, jboolean *isCopy)
 {
   jsize len = JvGetStringUTFLength (string);
-  // FIXME: exception processing.
-  char *r = (char *) _Jv_Malloc (len + 1);
-  JvGetStringUTFRegion (string, 0, len, r);
-  r[len] = '\0';
+  try
+    {
+      char *r = (char *) _Jv_Malloc (len + 1);
+      JvGetStringUTFRegion (string, 0, len, r);
+      r[len] = '\0';
 
-  if (isCopy)
-    *isCopy = true;
+      if (isCopy)
+	*isCopy = true;
 
-  return (const char *) r;
+      return (const char *) r;
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+      return NULL;
+    }
 }
 
 static void
@@ -1029,7 +1127,16 @@ _Jv_JNI_GetStringRegion (JNIEnv *env, jstring string, jsize start, jsize len,
   jchar *result = _Jv_GetStringChars (string);
   if (start < 0 || start > string->length ()
       || len < 0 || start + len > string->length ())
-    env->ex = new java::lang::StringIndexOutOfBoundsException ();
+    {
+      try
+	{
+	  env->ex = new java::lang::StringIndexOutOfBoundsException ();
+	}
+      catch (jthrowable t)
+	{
+	  env->ex = t;
+	}
+    }
   else
     memcpy (buf, &result[start], len * sizeof (jchar));
 }
@@ -1040,7 +1147,16 @@ _Jv_JNI_GetStringUTFRegion (JNIEnv *env, jstring str, jsize start,
 {
   if (start < 0 || start > str->length ()
       || len < 0 || start + len > str->length ())
-    env->ex = new java::lang::StringIndexOutOfBoundsException ();
+    {
+      try
+	{
+	  env->ex = new java::lang::StringIndexOutOfBoundsException ();
+	}
+      catch (jthrowable t)
+	{
+	  env->ex = t;
+	}
+    }
   else
     _Jv_GetStringUTFRegion (str, start, len, buf);
 }
@@ -1070,9 +1186,16 @@ static jarray
 _Jv_JNI_NewObjectArray (JNIEnv *env, jsize length, jclass elementClass,
 			jobject init)
 {
-  // FIXME: exception processing.
-  jarray result = JvNewObjectArray (length, elementClass, init);
-  return (jarray) wrap_value (env, result);
+  try
+    {
+      jarray result = JvNewObjectArray (length, elementClass, init);
+      return (jarray) wrap_value (env, result);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+      return NULL;
+    }
 }
 
 static jobject
@@ -1083,21 +1206,34 @@ _Jv_JNI_GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index)
 }
 
 static void
-_Jv_JNI_SetObjectArrayElement (JNIEnv *, jobjectArray array, jsize index,
+_Jv_JNI_SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index,
 			       jobject value)
 {
-  // FIXME: exception processing.
-  _Jv_CheckArrayStore (array, value);
-  jobject *elts = elements (array);
-  elts[index] = value;
+  try
+    {
+      _Jv_CheckArrayStore (array, value);
+      jobject *elts = elements (array);
+      elts[index] = value;
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
 }
 
 template<typename T, jclass K>
 static JArray<T> *
 _Jv_JNI_NewPrimitiveArray (JNIEnv *env, jsize length)
 {
-  // FIXME: exception processing.
-  return (JArray<T> *) wrap_value (env, _Jv_NewPrimArray (K, length));
+  try
+    {
+      return (JArray<T> *) wrap_value (env, _Jv_NewPrimArray (K, length));
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+      return NULL;
+    }
 }
 
 template<typename T>
@@ -1134,8 +1270,16 @@ _Jv_JNI_GetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
 {
   if (start < 0 || len >= array->length || start + len >= array->length)
     {
-      // FIXME: index.
-      env->ex = new java::lang::ArrayIndexOutOfBoundsException ();
+      try
+	{
+	  // FIXME: index.
+	  env->ex = new java::lang::ArrayIndexOutOfBoundsException ();
+	}
+      catch (jthrowable t)
+	{
+	  // Could have thown out of memory error.
+	  env->ex = t;
+	}
     }
   else
     {
@@ -1151,8 +1295,15 @@ _Jv_JNI_SetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
 {
   if (start < 0 || len >= array->length || start + len >= array->length)
     {
-      // FIXME: index.
-      env->ex = new java::lang::ArrayIndexOutOfBoundsException ();
+      try
+	{
+	  // FIXME: index.
+	  env->ex = new java::lang::ArrayIndexOutOfBoundsException ();
+	}
+      catch (jthrowable t)
+	{
+	  env->ex = t;
+	}
     }
   else
     {
@@ -1181,19 +1332,31 @@ _Jv_JNI_ReleasePrimitiveArrayCritical (JNIEnv *, jarray, void *, jint)
 }
 
 static jint
-_Jv_JNI_MonitorEnter (JNIEnv *, jobject obj)
+_Jv_JNI_MonitorEnter (JNIEnv *env, jobject obj)
 {
-  // FIXME: exception processing.
-  jint r = _Jv_MonitorEnter (obj);
-  return r;
+  try
+    {
+      return _Jv_MonitorEnter (obj);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
+  return JNI_ERR;
 }
 
 static jint
-_Jv_JNI_MonitorExit (JNIEnv *, jobject obj)
+_Jv_JNI_MonitorExit (JNIEnv *env, jobject obj)
 {
-  // FIXME: exception processing.
-  jint r = _Jv_MonitorExit (obj);
-  return r;
+  try
+    {
+      return _Jv_MonitorExit (obj);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
+  return JNI_ERR;
 }
 
 // JDK 1.2
@@ -1201,12 +1364,19 @@ jobject
 _Jv_JNI_ToReflectedField (JNIEnv *env, jclass cls, jfieldID fieldID,
 			  jboolean)
 {
-  // FIXME: exception processing.
-  java::lang::reflect::Field *field = new java::lang::reflect::Field();
-  field->declaringClass = cls;
-  field->offset = (char*) fieldID - (char *) cls->fields;
-  field->name = _Jv_NewStringUtf8Const (fieldID->getNameUtf8Const (cls));
-  return wrap_value (env, field);
+  try
+    {
+      java::lang::reflect::Field *field = new java::lang::reflect::Field();
+      field->declaringClass = cls;
+      field->offset = (char*) fieldID - (char *) cls->fields;
+      field->name = _Jv_NewStringUtf8Const (fieldID->getNameUtf8Const (cls));
+      return wrap_value (env, field);
+    }
+  catch (jthrowable t)
+    {
+      env->ex = t;
+    }
+  return NULL;
 }
 
 // JDK 1.2
@@ -1228,21 +1398,29 @@ _Jv_JNI_ToReflectedMethod (JNIEnv *env, jclass klass, jmethodID id,
   // FIXME.
   static _Jv_Utf8Const *init_name = _Jv_makeUtf8Const ("<init>", 6);
 
-  jobject result;
-  if (_Jv_equalUtf8Consts (id->name, init_name))
+  jobject result = NULL;
+
+  try
     {
-      // A constructor.
-      Constructor *cons = new Constructor ();
-      cons->offset = (char *) id - (char *) &klass->methods;
-      cons->declaringClass = klass;
-      result = cons;
+      if (_Jv_equalUtf8Consts (id->name, init_name))
+	{
+	  // A constructor.
+	  Constructor *cons = new Constructor ();
+	  cons->offset = (char *) id - (char *) &klass->methods;
+	  cons->declaringClass = klass;
+	  result = cons;
+	}
+      else
+	{
+	  Method *meth = new Method ();
+	  meth->offset = (char *) id - (char *) &klass->methods;
+	  meth->declaringClass = klass;
+	  result = meth;
+	}
     }
-  else
+  catch (jthrowable t)
     {
-      Method *meth = new Method ();
-      meth->offset = (char *) id - (char *) &klass->methods;
-      meth->declaringClass = klass;
-      result = meth;
+      env->ex = t;
     }
 
   return wrap_value (env, result);
@@ -1302,7 +1480,14 @@ _Jv_JNI_RegisterNatives (JNIEnv *env, jclass k,
       if (! found)
 	{
 	  jstring m = JvNewStringUTF (methods[j].name);
-	  _Jv_JNI_Throw (env, new java::lang::NoSuchMethodError (m));
+	  try
+	    {
+	      env->ex =new java::lang::NoSuchMethodError (m);
+	    }
+	  catch (jthrowable t)
+	    {
+	      env->ex = t;
+	    }
 	  return JNI_ERR;
 	}
     }
@@ -1545,7 +1730,14 @@ _Jv_JNI_AttachCurrentThread (JavaVM *, jstring name, void **penv, void *args)
   // have been called simply to set the new JNIEnv.
   if (_Jv_ThreadCurrent () == NULL)
     {
-      (void) new gnu::gcj::jni::NativeThread (group, name);
+      try
+	{
+	  (void) new gnu::gcj::jni::NativeThread (group, name);
+	}
+      catch (jthrowable t)
+	{
+	  return JNI_ERR;
+	}
     }
   _Jv_SetCurrentJNIEnv (env);
 
@@ -1567,8 +1759,19 @@ _Jv_JNI_DestroyJavaVM (JavaVM *vm)
   JNIEnv *env;
   if (_Jv_ThreadCurrent () != NULL)
     {
+      jstring main_name;
+      // This sucks.
+      try
+	{
+	  main_name = JvNewStringLatin1 ("main");
+	}
+      catch (jthrowable t)
+	{
+	  return JNI_ERR;
+	}
+
       jint r = _Jv_JNI_AttachCurrentThread (vm,
-					    JvNewStringLatin1 ("main"),
+					    main_name,
 					    reinterpret_cast<void **> (&env),
 					    NULL);
       if (r < 0)