Use the stock GCC 3.1-snap version of this.

1 files changed, 649 insertions, 917 deletions

diff --git a/contrib/gcc/cp/except.c b/contrib/gcc/cp/except.c
index f2896c7..e320dea 100644
--- a/contrib/gcc/cp/except.c
+++ b/contrib/gcc/cp/except.c
@@ -1,5 +1,6 @@
 /* Handle exceptional things in C++.
-   Copyright (C) 1989, 92-97, 1998, 1999 Free Software Foundation, Inc.
+   Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   2000, 2001  Free Software Foundation, Inc.
    Contributed by Michael Tiemann <tiemann@cygnus.com>
    Rewritten by Mike Stump <mrs@cygnus.com>, based upon an
    initial re-implementation courtesy Tad Hunt.
@@ -28,382 +29,83 @@ Boston, MA 02111-1307, USA.  */
 #include "system.h"
 #include "tree.h"
 #include "rtl.h"
+#include "expr.h"
+#include "libfuncs.h"
 #include "cp-tree.h"
 #include "flags.h"
 #include "obstack.h"
-#include "expr.h"
 #include "output.h"
 #include "except.h"
-#include "function.h"
-#include "defaults.h"
 #include "toplev.h"
-#include "eh-common.h"
-
-rtx expand_builtin_return_addr	PROTO((enum built_in_function, int, rtx));
-
-/* Holds the fndecl for __builtin_return_address.  */
-tree builtin_return_address_fndecl;
-
-/* A couple of backend routines from m88k.c */
-
-static void push_eh_cleanup PROTO((void));
-static tree build_eh_type_type PROTO((tree));
-static tree build_eh_type PROTO((tree));
-static void expand_end_eh_spec PROTO((tree));
-static tree call_eh_info PROTO((void));
-static void push_eh_info PROTO((void));
-static tree get_eh_info PROTO((void));
-static tree get_eh_value PROTO((void));
-#if 0
-static tree get_eh_type PROTO((void));
-static tree get_eh_caught PROTO((void));
-static tree get_eh_handlers PROTO((void));
-#endif
-static tree do_pop_exception PROTO((void));
-static void process_start_catch_block PROTO((tree, tree));
-static tree build_eh_type_type_ref PROTO((tree));
-static tree build_terminate_handler PROTO((void));
-static tree alloc_eh_object PROTO((tree));
-
-#if 0
-/* This is the startup, and finish stuff per exception table.  */
-
-/* XXX - Tad: exception handling section */
-#ifndef EXCEPT_SECTION_ASM_OP
-#define EXCEPT_SECTION_ASM_OP	"section\t.gcc_except_table,\"a\",@progbits"
-#endif
-
-#ifdef EXCEPT_SECTION_ASM_OP
-
- /* on machines which support it, the exception table lives in another section,
-	but it needs a label so we can reference it...  This sets up that
-    label! */
-asm (EXCEPT_SECTION_ASM_OP);
-exception_table __EXCEPTION_TABLE__[1] = { (void*)0, (void*)0, (void*)0 };
-asm (TEXT_SECTION_ASM_OP);
-
-#endif /* EXCEPT_SECTION_ASM_OP */
-
-#ifdef EXCEPT_SECTION_ASM_OP
-
- /* we need to know where the end of the exception table is... so this
-    is how we do it! */
 
-asm (EXCEPT_SECTION_ASM_OP);
-exception_table __EXCEPTION_END__[1] = { (void*)-1, (void*)-1, (void*)-1 };
-asm (TEXT_SECTION_ASM_OP);
-
-#endif /* EXCEPT_SECTION_ASM_OP */
-
-#endif
+static void push_eh_cleanup PARAMS ((tree));
+static tree prepare_eh_type PARAMS ((tree));
+static tree build_eh_type_type PARAMS ((tree));
+static tree do_begin_catch PARAMS ((void));
+static int dtor_nothrow PARAMS ((tree));
+static tree do_end_catch PARAMS ((tree));
+static void push_eh_cleanup PARAMS ((tree));
+static bool decl_is_java_type PARAMS ((tree decl, int err));
+static void initialize_handler_parm PARAMS ((tree, tree));
+static tree do_allocate_exception PARAMS ((tree));
+static int complete_ptr_ref_or_void_ptr_p PARAMS ((tree, tree));
+static bool is_admissible_throw_operand PARAMS ((tree));
+static int can_convert_eh PARAMS ((tree, tree));
+static void check_handlers_1 PARAMS ((tree, tree));
+static tree cp_protect_cleanup_actions PARAMS ((void));
 
 #include "decl.h"
-#include "insn-flags.h"
 #include "obstack.h"
 
-/* ======================================================================
-   Briefly the algorithm works like this:
-
-     When a constructor or start of a try block is encountered,
-     push_eh_entry (&eh_stack) is called.  Push_eh_entry () creates a
-     new entry in the unwind protection stack and returns a label to
-     output to start the protection for that block.
-
-     When a destructor or end try block is encountered, pop_eh_entry
-     (&eh_stack) is called.  Pop_eh_entry () returns the eh_entry it
-     created when push_eh_entry () was called.  The eh_entry structure
-     contains three things at this point.  The start protect label,
-     the end protect label, and the exception handler label.  The end
-     protect label should be output before the call to the destructor
-     (if any). If it was a destructor, then its parse tree is stored
-     in the finalization variable in the eh_entry structure.  Otherwise
-     the finalization variable is set to NULL to reflect the fact that
-     it is the end of a try block.  Next, this modified eh_entry node
-     is enqueued in the finalizations queue by calling
-     enqueue_eh_entry (&queue,entry).
-
-	+---------------------------------------------------------------+
-	|XXX: Will need modification to deal with partially		|
-	|			constructed arrays of objects		|
-	|								|
-	|	Basically, this consists of keeping track of how many	|
-	|	of the objects have been constructed already (this	|
-	|	should be in a register though, so that shouldn't be a	|
-	|	problem.						|
-	+---------------------------------------------------------------+
-
-     When a catch block is encountered, there is a lot of work to be
-     done.
-
-     Since we don't want to generate the catch block inline with the
-     regular flow of the function, we need to have some way of doing
-     so.  Luckily, we can use sequences to defer the catch sections.
-     When the start of a catch block is encountered, we start the
-     sequence.  After the catch block is generated, we end the
-     sequence.
-
-     Next we must insure that when the catch block is executed, all
-     finalizations for the matching try block have been completed.  If
-     any of those finalizations throw an exception, we must call
-     terminate according to the ARM (section r.15.6.1).  What this
-     means is that we need to dequeue and emit finalizations for each
-     entry in the eh_queue until we get to an entry with a NULL
-     finalization field.  For any of the finalization entries, if it
-     is not a call to terminate (), we must protect it by giving it
-     another start label, end label, and exception handler label,
-     setting its finalization tree to be a call to terminate (), and
-     enqueue'ing this new eh_entry to be output at an outer level.
-     Finally, after all that is done, we can get around to outputting
-     the catch block which basically wraps all the "catch (...) {...}"
-     statements in a big if/then/else construct that matches the
-     correct block to call.
-     
-     ===================================================================== */
-
-/* local globals for function calls
-   ====================================================================== */
-
-/* Used to cache "terminate" and "__throw_type_match*".  */
-static tree Terminate, CatchMatch;
-
-/* Used to cache __find_first_exception_table_match for throw.  */
-static tree FirstExceptionMatch;
-
-/* Used to cache a call to __unwind_function.  */
-static tree Unwind;
-
-/* ====================================================================== */
-
-
-/* ========================================================================= */
-
-
-
-/* local globals - these local globals are for storing data necessary for
-   generating the exception table and code in the correct order.
-
-   ========================================================================= */
-
-extern rtx catch_clauses;
-extern tree const_ptr_type_node;
-
-/* ========================================================================= */
-
-/* sets up all the global eh stuff that needs to be initialized at the
-   start of compilation.
-
-   This includes:
-		- Setting up all the function call trees.  */
+/* Sets up all the global eh stuff that needs to be initialized at the
+   start of compilation.  */
 
 void
 init_exception_processing ()
 {
-  /* void vtype () */
-  tree vtype = build_function_type (void_type_node, void_list_node);
-  
-  if (flag_honor_std)
-    push_namespace (get_identifier ("std"));
-  Terminate = auto_function (get_identifier ("terminate"),
-			     vtype, NOT_BUILT_IN);
-  TREE_THIS_VOLATILE (Terminate) = 1;
-  if (flag_honor_std)
-    pop_namespace ();
-
-  push_lang_context (lang_name_c);
-
-  set_exception_lang_code (EH_LANG_C_plus_plus);
-  set_exception_version_code (1);
-
-  CatchMatch
-    = builtin_function (flag_rtti
-			? "__throw_type_match_rtti"
-			: "__throw_type_match",
-			build_function_type (ptr_type_node,
-					     tree_cons (NULL_TREE, const_ptr_type_node,
-							tree_cons (NULL_TREE, const_ptr_type_node,
-								   tree_cons (NULL_TREE, ptr_type_node,
-									      void_list_node)))),
-			NOT_BUILT_IN, NULL_PTR);
-  FirstExceptionMatch
-    = builtin_function ("__find_first_exception_table_match",
-			build_function_type (ptr_type_node,
-					     tree_cons (NULL_TREE, ptr_type_node,
-							void_list_node)),
-			NOT_BUILT_IN, NULL_PTR);
-  Unwind
-    = builtin_function ("__unwind_function",
-			build_function_type (void_type_node,
-					     tree_cons (NULL_TREE, ptr_type_node,
-							void_list_node)),
-			NOT_BUILT_IN, NULL_PTR);
-
-  pop_lang_context ();
-
-  /* If we use setjmp/longjmp EH, arrange for all cleanup actions to
-     be protected with __terminate.  */
-  protect_cleanup_actions_with_terminate = 1;
-}
-
-/* Retrieve a pointer to the cp_eh_info node for the current exception.  */
-
-static tree
-call_eh_info ()
-{
-  tree fn;
-
-  fn = get_identifier ("__start_cp_handler");
-  if (IDENTIFIER_GLOBAL_VALUE (fn))
-    fn = IDENTIFIER_GLOBAL_VALUE (fn);
-  else
-    {
-      tree t1, t, fields[7];
-
-      /* Declare cp_eh_info * __start_cp_handler (void),
-	 as defined in exception.cc. */
-      push_obstacks_nochange ();
-      end_temporary_allocation ();
-
-      /* struct cp_eh_info.  This must match exception.cc.  Note that this
-	 type is not pushed anywhere.  */
-      t1= make_lang_type (RECORD_TYPE);
-      fields[0] = build_lang_field_decl (FIELD_DECL, 
-                    get_identifier ("handler_label"), ptr_type_node);
-      fields[1] = build_lang_field_decl (FIELD_DECL, 
-                    get_identifier ("dynamic_handler_chain"), ptr_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, 
-                    get_identifier ("info"), ptr_type_node);
-      fields[3] = build_lang_field_decl (FIELD_DECL, 
-                    get_identifier ("table_index"), ptr_type_node);
-      /* N.B.: The fourth field LEN is expected to be
-	 the number of fields - 1, not the total number of fields.  */
-      finish_builtin_type (t1, "eh_context", fields, 3, ptr_type_node);
-      t1 = build_pointer_type (t1);
-
-      t1= make_lang_type (RECORD_TYPE);
-      fields[0] = build_lang_field_decl (FIELD_DECL, 
-                    get_identifier ("match_function"), ptr_type_node);
-      fields[1] = build_lang_field_decl (FIELD_DECL, 
-                    get_identifier ("language"), short_integer_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, 
-                    get_identifier ("version"), short_integer_type_node);
-      /* N.B.: The fourth field LEN is expected to be
-	 the number of fields - 1, not the total number of fields.  */
-      finish_builtin_type (t1, "__eh_info", fields, 2, ptr_type_node);
-      t = make_lang_type (RECORD_TYPE);
-      fields[0] = build_lang_field_decl (FIELD_DECL, 
-                                              get_identifier ("eh_info"), t1);
-      fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("value"),
-					 ptr_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("type"),
-					 ptr_type_node);
-      fields[3] = build_lang_field_decl
-	(FIELD_DECL, get_identifier ("cleanup"),
-	 build_pointer_type (build_function_type
-			     (ptr_type_node, tree_cons
-			      (NULL_TREE, ptr_type_node, void_list_node))));
-      fields[4] = build_lang_field_decl (FIELD_DECL, get_identifier ("caught"),
-					 boolean_type_node);
-      fields[5] = build_lang_field_decl (FIELD_DECL, get_identifier ("next"),
-					 build_pointer_type (t));
-      fields[6] = build_lang_field_decl
-	(FIELD_DECL, get_identifier ("handlers"), long_integer_type_node);
-      /* N.B.: The fourth field LEN is expected to be
-	 the number of fields - 1, not the total number of fields.  */
-      finish_builtin_type (t, "cp_eh_info", fields, 6, ptr_type_node);
-      t = build_pointer_type (t);
-
-      /* And now the function.  */
-      fn = build_lang_decl (FUNCTION_DECL, fn,
-			    build_function_type (t, void_list_node));
-      DECL_EXTERNAL (fn) = 1;
-      TREE_PUBLIC (fn) = 1;
-      DECL_ARTIFICIAL (fn) = 1;
-      pushdecl_top_level (fn);
-      make_function_rtl (fn);
-      pop_obstacks ();
-    }
-  mark_used (fn);
-  return build_function_call (fn, NULL_TREE);
-}
-
-/* Retrieve a pointer to the cp_eh_info node for the current exception
-   and save it in the current binding level.  */
-
-static void
-push_eh_info ()
-{
-  tree decl, fn = call_eh_info ();
-
-  /* Remember the pointer to the current exception info; it won't change
-     during this catch block.  */
-  decl = build_decl (VAR_DECL, get_identifier ("__exception_info"),
-		     TREE_TYPE (fn));
-  DECL_ARTIFICIAL (decl) = 1;
-  DECL_INITIAL (decl) = fn;
-  decl = pushdecl (decl);
-  cp_finish_decl (decl, fn, NULL_TREE, 0, 0);
+  tree tmp;
+
+  /* void std::terminate (); */
+  push_namespace (std_identifier);
+  tmp = build_function_type (void_type_node, void_list_node);
+  terminate_node = build_cp_library_fn_ptr ("terminate", tmp);
+  TREE_THIS_VOLATILE (terminate_node) = 1;
+  TREE_NOTHROW (terminate_node) = 1;
+  pop_namespace ();
+
+  /* void __cxa_call_unexpected(void *); */
+  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
+  tmp = build_function_type (void_type_node, tmp);
+  call_unexpected_node
+    = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);
+
+  eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
+					     ? "__gxx_personality_sj0"
+					     : "__gxx_personality_v0");
+
+  lang_eh_runtime_type = build_eh_type_type;
+  lang_protect_cleanup_actions = &cp_protect_cleanup_actions;
 }
 
-/* Returns a reference to the cp_eh_info node for the current exception.  */
+/* Returns an expression to be executed if an unhandled exception is
+   propagated out of a cleanup region.  */
 
 static tree
-get_eh_info ()
+cp_protect_cleanup_actions ()
 {
-  /* Look for the pointer pushed in push_eh_info.  */
-  tree t = lookup_name (get_identifier ("__exception_info"), 0);
-  return build_indirect_ref (t, NULL_PTR);
-}
+  /* [except.terminate]
 
-/* Returns a reference to the current exception object.  */
+     When the destruction of an object during stack unwinding exits
+     using an exception ... void terminate(); is called.  */
+  return build_call (terminate_node, NULL_TREE);
+}     
 
 static tree
-get_eh_value ()
-{
-  return build_component_ref (get_eh_info (), get_identifier ("value"),
-			      NULL_TREE, 0);
-}
-
-/* Returns a reference to the current exception type.  */
-
-#if 0
-static tree
-get_eh_type ()
-{
-  return build_component_ref (get_eh_info (), get_identifier ("type"),
-			      NULL_TREE, 0);
-}
-
-/* Returns a reference to whether or not the current exception
-   has been caught.  */
-
-static tree
-get_eh_caught ()
-{
-  return build_component_ref (get_eh_info (), get_identifier ("caught"),
-			      NULL_TREE, 0);
-}
-
-/* Returns a reference to whether or not the current exception
-   has been caught.  */
-
-static tree
-get_eh_handlers ()
-{
-  return build_component_ref (get_eh_info (), get_identifier ("handlers"),
-			      NULL_TREE, 0);
-}
-#endif
-
-/* Build a type value for use at runtime for a type that is matched
-   against by the exception handling system.  */
-
-static tree
-build_eh_type_type (type)
+prepare_eh_type (type)
      tree type;
 {
-  const char *typestring;
-  tree exp;
-
+  if (type == NULL_TREE)
+    return type;
   if (type == error_mark_node)
     return error_mark_node;
 
@@ -414,295 +116,338 @@ build_eh_type_type (type)
   /* Peel off cv qualifiers.  */
   type = TYPE_MAIN_VARIANT (type);
 
-  if (flag_rtti)
-    return build1 (ADDR_EXPR, ptr_type_node, get_typeid_1 (type));
-
-  typestring = build_overload_name (type, 1, 1);
-  exp = combine_strings (build_string (strlen (typestring)+1, typestring));
-  return build1 (ADDR_EXPR, ptr_type_node, exp);
+  return type;
 }
 
-/* Build the address of a runtime type for use in the runtime matching
-   field of the new exception model */
+/* Build the address of a typeinfo decl for use in the runtime
+   matching field of the exception model.   */
 
 static tree
-build_eh_type_type_ref (type)
+build_eh_type_type (type)
      tree type;
 {
-  const char *typestring;
   tree exp;
 
-  if (type == error_mark_node)
-    return error_mark_node;
+  if (type == NULL_TREE || type == error_mark_node)
+    return type;
 
-  /* peel back references, so they match.  */
-  if (TREE_CODE (type) == REFERENCE_TYPE)
-    type = TREE_TYPE (type);
-
-  /* Peel off cv qualifiers.  */
-  type = TYPE_MAIN_VARIANT (type);
+  if (decl_is_java_type (type, 0))
+    exp = build_java_class_ref (TREE_TYPE (type));
+  else
+    exp = get_tinfo_decl (type);
 
-  push_obstacks_nochange ();
-  end_temporary_allocation ();
+  mark_used (exp);
+  exp = build1 (ADDR_EXPR, ptr_type_node, exp);
 
-  if (flag_rtti)
-    {
-      exp = get_tinfo_fn (type);
-      TREE_USED (exp) = 1;
-      mark_inline_for_output (exp);
-      exp = build1 (ADDR_EXPR, ptr_type_node, exp);
-    }
-  else
-    {
-      typestring = build_overload_name (type, 1, 1);
-      exp = combine_strings (build_string (strlen (typestring)+1, typestring));
-      exp = build1 (ADDR_EXPR, ptr_type_node, exp);
-    }
-  pop_obstacks ();
-  return (exp);
+  return exp;
 }
 
+tree
+build_exc_ptr ()
+{
+  return build (EXC_PTR_EXPR, ptr_type_node);
+}
 
-/* Build a type value for use at runtime for a exp that is thrown or
-   matched against by the exception handling system.  */
+/* Build up a call to __cxa_begin_catch, to tell the runtime that the
+   exception has been handled.  */
 
 static tree
-build_eh_type (exp)
-     tree exp;
+do_begin_catch ()
 {
-  if (flag_rtti)
+  tree fn;
+
+  fn = get_identifier ("__cxa_begin_catch");
+  if (IDENTIFIER_GLOBAL_VALUE (fn))
+    fn = IDENTIFIER_GLOBAL_VALUE (fn);
+  else
     {
-      exp = build_typeid (exp);
-      return build1 (ADDR_EXPR, ptr_type_node, exp);
+      /* Declare void* __cxa_begin_catch (void *).  */
+      tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
+      fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp));
     }
-  return build_eh_type_type (TREE_TYPE (exp));
+
+  return build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
+					     NULL_TREE));
 }
 
-/* This routine is called to mark all the symbols representing runtime
-   type functions in the exception table as haveing been referenced.
-   This will make sure code is emitted for them. Called from finish_file. */
-void 
-mark_all_runtime_matches () 
+/* Returns nonzero if cleaning up an exception of type TYPE (which can be
+   NULL_TREE for a ... handler) will not throw an exception.  */
+
+static int
+dtor_nothrow (type)
+     tree type;
 {
-  int x,num;
-  void **ptr;
-  tree exp;
-  
-  num = find_all_handler_type_matches (&ptr);
-  if (num == 0 || ptr == NULL)
-    return;
-  
-  for (x=0; x <num; x++)
-    {
-      exp = (tree) ptr[x];
-      if (TREE_CODE (exp) == ADDR_EXPR)
-        {
-          exp = TREE_OPERAND (exp, 0);
-          if (TREE_CODE (exp) == FUNCTION_DECL)
-            TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (exp)) = 1;
-        }
-    }
-  
-  free (ptr);
+  tree fn;
+
+  if (type == NULL_TREE)
+    return 0;
+
+  if (! TYPE_HAS_DESTRUCTOR (type))
+    return 1;
+
+  fn = lookup_member (type, dtor_identifier, 0, 0);
+  fn = TREE_VALUE (fn);
+  return TREE_NOTHROW (fn);
 }
 
-/* Build up a call to __cp_pop_exception, to destroy the exception object
-   for the current catch block.  HANDLER is either true or false, telling
-   the library whether or not it is being called from an exception handler;
-   if it is, it avoids destroying the object on rethrow.  */
+/* Build up a call to __cxa_end_catch, to destroy the exception object
+   for the current catch block if no others are currently using it.  */
 
 static tree
-do_pop_exception ()
+do_end_catch (type)
+     tree type;
 {
   tree fn, cleanup;
-  fn = get_identifier ("__cp_pop_exception");
+
+  fn = get_identifier ("__cxa_end_catch");
   if (IDENTIFIER_GLOBAL_VALUE (fn))
     fn = IDENTIFIER_GLOBAL_VALUE (fn);
   else
     {
-      /* Declare void __cp_pop_exception (void *),
-	 as defined in exception.cc. */
-      push_obstacks_nochange ();
-      end_temporary_allocation ();
-      fn = build_lang_decl
-	(FUNCTION_DECL, fn,
-	 build_function_type (void_type_node, tree_cons
-			      (NULL_TREE, ptr_type_node, void_list_node)));
-      DECL_EXTERNAL (fn) = 1;
-      TREE_PUBLIC (fn) = 1;
-      DECL_ARTIFICIAL (fn) = 1;
-      pushdecl_top_level (fn);
-      make_function_rtl (fn);
-      pop_obstacks ();
+      /* Declare void __cxa_end_catch ().  */
+      fn = push_void_library_fn (fn, void_list_node);
+      /* This can throw if the destructor for the exception throws.  */
+      TREE_NOTHROW (fn) = 0;
     }
 
-  mark_used (fn);
-  /* Arrange to do a dynamically scoped cleanup upon exit from this region.  */
-  cleanup = lookup_name (get_identifier ("__exception_info"), 0);
-  cleanup = build_function_call (fn, expr_tree_cons
-				 (NULL_TREE, cleanup, NULL_TREE));
+  cleanup = build_function_call (fn, NULL_TREE);
+  TREE_NOTHROW (cleanup) = dtor_nothrow (type);
+
   return cleanup;
 }
 
 /* This routine creates the cleanup for the current exception.  */
 
 static void
-push_eh_cleanup ()
+push_eh_cleanup (type)
+     tree type;
 {
-  int yes;
-
-  yes = suspend_momentary ();
-  /* All cleanups must last longer than normal.  */
-  expand_decl_cleanup (NULL_TREE, do_pop_exception ());
-  resume_momentary (yes);
+  finish_decl_cleanup (NULL_TREE, do_end_catch (type));
 }
 
-/* Build up a call to terminate on the function obstack, for use as an
-   exception handler.  */
+/* Return nonzero value if DECL is a Java type suitable for catch or
+   throw.  */
 
-static tree
-build_terminate_handler ()
+static bool
+decl_is_java_type (decl, err)
+     tree decl;
+     int err;
 {
-  int yes = suspend_momentary ();
-  tree term = build_function_call (Terminate, NULL_TREE);
-  resume_momentary (yes);
-  return term;
-}
+  bool r = (TREE_CODE (decl) == POINTER_TYPE
+	    && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
+	    && TYPE_FOR_JAVA (TREE_TYPE (decl)));
+
+  if (err)
+    {
+      if (TREE_CODE (decl) == REFERENCE_TYPE
+	  && TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
+	  && TYPE_FOR_JAVA (TREE_TYPE (decl)))
+	{
+	  /* Can't throw a reference.  */
+	  error ("type `%T' is disallowed in Java `throw' or `catch'",
+		    decl);
+	}
+
+      if (r)
+	{
+	  tree jthrow_node
+	    = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jthrowable"));
+
+	  if (jthrow_node == NULL_TREE)
+	    fatal_error
+	      ("call to Java `catch' or `throw' with `jthrowable' undefined");
 
-/* Call this to start a catch block. Typename is the typename, and identifier
-   is the variable to place the object in or NULL if the variable doesn't
-   matter.  If typename is NULL, that means its a "catch (...)" or catch
-   everything.  In that case we don't need to do any type checking.
-   (ie: it ends up as the "else" clause rather than an "else if" clause) */
+	  jthrow_node = TREE_TYPE (TREE_TYPE (jthrow_node));
 
+	  if (! DERIVED_FROM_P (jthrow_node, TREE_TYPE (decl)))
+	    {
+	      /* Thrown object must be a Throwable.  */
+	      error ("type `%T' is not derived from `java::lang::Throwable'",
+			TREE_TYPE (decl));
+	    }
+	}
+    }
+
+  return r;
+}
+
+/* Select the personality routine to be used for exception handling,
+   or issue an error if we need two different ones in the same
+   translation unit.
+   ??? At present eh_personality_libfunc is set to
+   __gxx_personality_(sj|v)0 in init_exception_processing - should it
+   be done here instead?  */
 void
-expand_start_catch_block (declspecs, declarator)
-     tree declspecs, declarator;
+choose_personality_routine (lang)
+     enum languages lang;
 {
-  tree decl;
-
-  if (processing_template_decl)
+  static enum {
+    chose_none,
+    chose_cpp,
+    chose_java,
+    gave_error
+  } state;
+
+  switch (state)
     {
-      if (declspecs)
-	{
-	  decl = grokdeclarator (declarator, declspecs, CATCHPARM,
-				 1, NULL_TREE);
-	  pushdecl (decl);
-	  decl = build_min_nt (DECL_STMT, copy_to_permanent (declarator),
-			       copy_to_permanent (declspecs),
-			       NULL_TREE);
-	  add_tree (decl);
-	}
+    case gave_error:
       return;
+
+    case chose_cpp:
+      if (lang != lang_cplusplus)
+	goto give_error;
+      return;
+
+    case chose_java:
+      if (lang != lang_java)
+	goto give_error;
+      return;
+
+    case chose_none:
+      ; /* proceed to language selection */
     }
 
-  if (! doing_eh (1))
-    return;
+  switch (lang)
+    {
+    case lang_cplusplus:
+      state = chose_cpp;
+      break;
+
+    case lang_java:
+      state = chose_java;
+      eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS
+						 ? "__gcj_personality_sj0"
+						 : "__gcj_personality_v0");
+      break;
+
+    default:
+      abort ();
+    }
+  return;
 
-  process_start_catch_block (declspecs, declarator);
+ give_error:
+  error ("mixing C++ and Java catches in a single translation unit");
+  state = gave_error;
 }
 
-
-/* This function performs the expand_start_catch_block functionality for 
-   exceptions implemented in the new style. __throw determines whether
-   a handler needs to be called or not, so the handler itself has to do
-   nothing additional. */
+/* Initialize the catch parameter DECL.  */
 
 static void 
-process_start_catch_block (declspecs, declarator)
-     tree declspecs, declarator;
+initialize_handler_parm (decl, exp)
+     tree decl;
+     tree exp;
 {
-  tree decl = NULL_TREE;
   tree init;
+  tree init_type;
 
-  /* Create a binding level for the eh_info and the exception object
-     cleanup.  */
-  pushlevel (0);
-  expand_start_bindings (0);
+  /* Make sure we mark the catch param as used, otherwise we'll get a
+     warning about an unused ((anonymous)).  */
+  TREE_USED (decl) = 1;
 
+  /* Figure out the type that the initializer is.  Pointers are returned
+     adjusted by value from __cxa_begin_catch.  Others are returned by 
+     reference.  */
+  init_type = TREE_TYPE (decl);
+  if (! TYPE_PTR_P (init_type)
+      && TREE_CODE (init_type) != REFERENCE_TYPE)
+    init_type = build_reference_type (init_type);
 
-  if (declspecs)
-    {
-      decl = grokdeclarator (declarator, declspecs, CATCHPARM, 1, NULL_TREE);
-
-      if (decl == NULL_TREE)
-	error ("invalid catch parameter");
-    }
+  choose_personality_routine (decl_is_java_type (init_type, 0)
+			      ? lang_java : lang_cplusplus);
 
-  if (decl)
-    start_catch_handler (build_eh_type_type_ref (TREE_TYPE (decl)));
-  else
-    start_catch_handler (CATCH_ALL_TYPE);
+  /* Since pointers are passed by value, initialize a reference to
+     pointer catch parm with the address of the temporary.  */
+  if (TREE_CODE (init_type) == REFERENCE_TYPE
+      && TYPE_PTR_P (TREE_TYPE (init_type)))
+    exp = build_unary_op (ADDR_EXPR, exp, 1);
 
-  emit_line_note (input_filename, lineno);
+  exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
 
-  push_eh_info ();
+  init = convert_from_reference (exp);
 
-  if (decl)
+  /* If the constructor for the catch parm exits via an exception, we
+     must call terminate.  See eh23.C.  */
+  if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
     {
-      tree exp;
-      tree init_type;
+      /* Generate the copy constructor call directly so we can wrap it.
+	 See also expand_default_init.  */
+      init = ocp_convert (TREE_TYPE (decl), init,
+			  CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
+      init = build1 (MUST_NOT_THROW_EXPR, TREE_TYPE (init), init);
+    }
 
-      /* Make sure we mark the catch param as used, otherwise we'll get
-	 a warning about an unused ((anonymous)).  */
-      TREE_USED (decl) = 1;
+  /* Let `cp_finish_decl' know that this initializer is ok.  */
+  DECL_INITIAL (decl) = error_mark_node;
+  decl = pushdecl (decl);
 
-      /* Figure out the type that the initializer is.  */
-      init_type = TREE_TYPE (decl);
-      if (TREE_CODE (init_type) != REFERENCE_TYPE
-	  && TREE_CODE (init_type) != POINTER_TYPE)
-	init_type = build_reference_type (init_type);
+  start_decl_1 (decl);
+  cp_finish_decl (decl, init, NULL_TREE,
+		  LOOKUP_ONLYCONVERTING|DIRECT_BIND);
+}
 
-      exp = get_eh_value ();
+/* Call this to start a catch block.  DECL is the catch parameter.  */
 
-      /* Since pointers are passed by value, initialize a reference to
-	 pointer catch parm with the address of the value slot.  */
-      if (TREE_CODE (init_type) == REFERENCE_TYPE
-	  && TREE_CODE (TREE_TYPE (init_type)) == POINTER_TYPE)
-	exp = build_unary_op (ADDR_EXPR, exp, 1);
+tree
+expand_start_catch_block (decl)
+     tree decl;
+{
+  tree exp = NULL_TREE;
+  tree type;
+  bool is_java;
 
-      exp = ocp_convert (init_type , exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
+  if (! doing_eh (1))
+    return NULL_TREE;
 
-      push_eh_cleanup ();
+  /* Make sure this declaration is reasonable.  */
+  if (decl && !complete_ptr_ref_or_void_ptr_p (TREE_TYPE (decl), NULL_TREE))
+    decl = NULL_TREE;
 
-      /* Create a binding level for the parm.  */
-      pushlevel (0);
-      expand_start_bindings (0);
+  if (decl)
+    type = prepare_eh_type (TREE_TYPE (decl));
+  else
+    type = NULL_TREE;
 
-      init = convert_from_reference (exp);
+  is_java = false;
+  if (decl)
+    {
+      tree init;
 
-      /* If the constructor for the catch parm exits via an exception, we
-         must call terminate.  See eh23.C.  */
-      if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
+      if (decl_is_java_type (type, 1))
 	{
-	  /* Generate the copy constructor call directly so we can wrap it.
-	     See also expand_default_init.  */
-	  init = ocp_convert (TREE_TYPE (decl), init,
-			      CONV_IMPLICIT|CONV_FORCE_TEMP, 0);
-	  init = build (TRY_CATCH_EXPR, TREE_TYPE (init), init,
-			build_terminate_handler ());
+	  /* Java only passes object via pointer and doesn't require
+	     adjusting.  The java object is immediately before the
+	     generic exception header.  */
+	  init = build_exc_ptr ();
+	  init = build1 (NOP_EXPR, build_pointer_type (type), init);
+	  init = build (MINUS_EXPR, TREE_TYPE (init), init,
+			TYPE_SIZE_UNIT (TREE_TYPE (init)));
+	  init = build_indirect_ref (init, NULL);
+	  is_java = true;
 	}
-
-      /* Let `cp_finish_decl' know that this initializer is ok.  */
-      DECL_INITIAL (decl) = init;
-      decl = pushdecl (decl);
-
-      start_decl_1 (decl);
-      cp_finish_decl (decl, init, NULL_TREE, 0,
-		      LOOKUP_ONLYCONVERTING|DIRECT_BIND);
+      else
+	{
+	  /* C++ requires that we call __cxa_begin_catch to get the
+	     pointer to the actual object.  */
+	  init = do_begin_catch ();
+	}
+	  
+      exp = create_temporary_var (ptr_type_node);
+      DECL_REGISTER (exp) = 1;
+      cp_finish_decl (exp, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
+      finish_expr_stmt (build_modify_expr (exp, INIT_EXPR, init));
     }
   else
-    {
-      push_eh_cleanup ();
+    finish_expr_stmt (do_begin_catch ());
 
-      /* Create a binding level for the parm.  */
-      pushlevel (0);
-      expand_start_bindings (0);
+  /* C++ requires that we call __cxa_end_catch at the end of
+     processing the exception.  */
+  if (! is_java)
+    push_eh_cleanup (type);
 
-      /* Fall into the catch all section.  */
-    }
+  if (decl)
+    initialize_handler_parm (decl, exp);
 
-  emit_line_note (input_filename, lineno);
+  return type;
 }
 
 
@@ -716,448 +461,435 @@ expand_end_catch_block ()
   if (! doing_eh (1))
     return;
 
-  /* Cleanup the EH parameter.  */
-  expand_end_bindings (getdecls (), kept_level_p (), 0);
-  poplevel (kept_level_p (), 1, 0);
-      
-  /* Cleanup the EH object.  */
-  expand_end_bindings (getdecls (), kept_level_p (), 0);
-  poplevel (kept_level_p (), 1, 0);
-
-  /* Fall to outside the try statement when done executing handler and
-     we fall off end of handler.  This is jump Lresume in the
-     documentation.  */
-  expand_goto (top_label_entry (&caught_return_label_stack));
-
-  end_catch_handler ();
+  /* The exception being handled is rethrown if control reaches the end of
+     a handler of the function-try-block of a constructor or destructor.  */
+  if (in_function_try_handler
+      && (DECL_CONSTRUCTOR_P (current_function_decl)
+	  || DECL_DESTRUCTOR_P (current_function_decl)))
+    finish_expr_stmt (build_throw (NULL_TREE));
 }
 
-/* An exception spec is implemented more or less like:
-
-   try {
-     function body;
-   } catch (...) {
-     void *p[] = { typeid(raises) };
-     __check_eh_spec (p, count);
-   }
-
-   __check_eh_spec in exception.cc handles all the details.  */
-
-void
-expand_start_eh_spec ()
+tree
+begin_eh_spec_block ()
 {
-  expand_start_try_stmts ();
+  tree r = build_stmt (EH_SPEC_BLOCK, NULL_TREE, NULL_TREE);
+  add_stmt (r);
+  return r;
 }
 
-static void
-expand_end_eh_spec (raises)
-     tree raises;
+void
+finish_eh_spec_block (raw_raises, eh_spec_block)
+     tree raw_raises;
+     tree eh_spec_block;
 {
-  tree tmp, fn, decl, types = NULL_TREE;
-  int count = 0;
+  tree raises;
 
-  expand_start_all_catch ();
-  expand_start_catch_block (NULL_TREE, NULL_TREE);
+  RECHAIN_STMTS (eh_spec_block, EH_SPEC_STMTS (eh_spec_block));
 
-  /* Build up an array of type_infos.  */
-  for (; raises && TREE_VALUE (raises); raises = TREE_CHAIN (raises))
-    {
-      types = expr_tree_cons
-	(NULL_TREE, build_eh_type_type (TREE_VALUE (raises)), types);
-      ++count;
-    }
+  /* Strip cv quals, etc, from the specification types.  */
+  for (raises = NULL_TREE;
+       raw_raises && TREE_VALUE (raw_raises);
+       raw_raises = TREE_CHAIN (raw_raises))
+    raises = tree_cons (NULL_TREE, prepare_eh_type (TREE_VALUE (raw_raises)),
+			raises);
 
-  types = build_nt (CONSTRUCTOR, NULL_TREE, types);
-  TREE_HAS_CONSTRUCTOR (types) = 1;
+  EH_SPEC_RAISES (eh_spec_block) = raises;
+}
 
-  /* We can't pass the CONSTRUCTOR directly, so stick it in a variable.  */
-  tmp = build_cplus_array_type (const_ptr_type_node, NULL_TREE);
-  decl = build_decl (VAR_DECL, NULL_TREE, tmp);
-  DECL_ARTIFICIAL (decl) = 1;
-  DECL_INITIAL (decl) = types;
-  cp_finish_decl (decl, types, NULL_TREE, 0, 0);
+/* Return a pointer to a buffer for an exception object of type TYPE.  */
 
-  decl = decay_conversion (decl);
+static tree
+do_allocate_exception (type)
+     tree type;
+{
+  tree fn;
 
-  fn = get_identifier ("__check_eh_spec");
+  fn = get_identifier ("__cxa_allocate_exception");
   if (IDENTIFIER_GLOBAL_VALUE (fn))
     fn = IDENTIFIER_GLOBAL_VALUE (fn);
   else
     {
-      push_obstacks_nochange ();
-      end_temporary_allocation ();
-
-      tmp = tree_cons
-	(NULL_TREE, integer_type_node, tree_cons
-	 (NULL_TREE, TREE_TYPE (decl), void_list_node));
-      tmp = build_function_type	(void_type_node, tmp);
-  
-      fn = build_lang_decl (FUNCTION_DECL, fn, tmp);
-      DECL_EXTERNAL (fn) = 1;
-      TREE_PUBLIC (fn) = 1;
-      DECL_ARTIFICIAL (fn) = 1;
-      TREE_THIS_VOLATILE (fn) = 1;
-      pushdecl_top_level (fn);
-      make_function_rtl (fn);
-      pop_obstacks ();
-    }
-
-  mark_used (fn);
-  tmp = expr_tree_cons (NULL_TREE, build_int_2 (count, 0), expr_tree_cons
-			(NULL_TREE, decl, NULL_TREE));
-  tmp = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), tmp);
-  expand_expr (tmp, const0_rtx, VOIDmode, EXPAND_NORMAL);
-
-  expand_end_catch_block ();
-  expand_end_all_catch ();
-}
-
-/* This is called to expand all the toplevel exception handling
-   finalization for a function.  It should only be called once per
-   function.  */
-
-void
-expand_exception_blocks ()
-{
-  do_pending_stack_adjust ();
-  push_to_sequence (catch_clauses);
-  expand_leftover_cleanups ();
-  do_pending_stack_adjust ();
-  catch_clauses = get_insns ();
-  end_sequence ();
-
-  /* Do this after we expand leftover cleanups, so that the
-     expand_eh_region_end that expand_end_eh_spec does will match the
-     right expand_eh_region_start, and make sure it comes out before
-     the terminate protected region.  */
-  if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
-    {
-     expand_end_eh_spec (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)));
-     do_pending_stack_adjust ();
-     push_to_sequence (catch_clauses);
-     expand_leftover_cleanups ();
-     do_pending_stack_adjust ();
-     catch_clauses = get_insns ();
-     end_sequence ();
-    }
-
-  if (catch_clauses)
-    {
-      rtx funcend = gen_label_rtx ();
-      emit_jump (funcend);
-
-      /* We cannot protect n regions this way if we must flow into the
-	 EH region through the top of the region, as we have to with
-	 the setjmp/longjmp approach.  */
-      if (exceptions_via_longjmp == 0)
-	expand_eh_region_start ();
-
-      emit_insns (catch_clauses);
-      catch_clauses = NULL_RTX;
-
-      if (exceptions_via_longjmp == 0)
-	expand_eh_region_end (build_terminate_handler ());
-
-      expand_leftover_cleanups ();
-
-      emit_label (funcend);
+      /* Declare void *__cxa_allocate_exception(size_t).  */
+      tree tmp = tree_cons (NULL_TREE, c_size_type_node, void_list_node);
+      fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp));
     }
+  
+  return build_function_call (fn, tree_cons (NULL_TREE, size_in_bytes (type),
+					     NULL_TREE));
 }
 
-tree
-start_anon_func ()
-{
-  static int counter = 0;
-  int old_interface_unknown = interface_unknown;
-  char name[32];
-  tree params;
-  tree t;
-
-  push_cp_function_context (NULL_TREE);
-  push_to_top_level ();
-
-  /* No need to mangle this.  */
-  push_lang_context (lang_name_c);
-
-  interface_unknown = 1;
-
-  params = void_list_node;
-  /* tcf stands for throw clean function.  */
-  sprintf (name, "__tcf_%d", counter++);
-  t = make_call_declarator (get_identifier (name), params, NULL_TREE,
-			    NULL_TREE);
-  start_function (decl_tree_cons (NULL_TREE, get_identifier ("static"),
-				  void_list_node),
-		  t, NULL_TREE, 0);
-  store_parm_decls ();
-  pushlevel (0);
-  clear_last_expr ();
-  push_momentary ();
-  expand_start_bindings (0);
-  emit_line_note (input_filename, lineno);
-
-  interface_unknown = old_interface_unknown;
-
-  pop_lang_context ();
-
-  return current_function_decl;
-}
-
-void
-end_anon_func ()
-{
-  expand_end_bindings (getdecls (), 1, 0);
-  poplevel (1, 0, 0);
-  pop_momentary ();
-
-  finish_function (lineno, 0, 0);
-
-  pop_from_top_level ();
-  pop_cp_function_context (NULL_TREE);
-}
-
-/* Return a pointer to a buffer for an exception object of type TYPE.  */
+#if 0
+/* Call __cxa_free_exception from a cleanup.  This is never invoked
+   directly.  */
 
 static tree
-alloc_eh_object (type)
-     tree type;
+do_free_exception (ptr)
+     tree ptr;
 {
-  tree fn, exp;
+  tree fn;
 
-  fn = get_identifier ("__eh_alloc");
+  fn = get_identifier ("__cxa_free_exception");
   if (IDENTIFIER_GLOBAL_VALUE (fn))
     fn = IDENTIFIER_GLOBAL_VALUE (fn);
   else
     {
-      /* Declare __eh_alloc (size_t), as defined in exception.cc.  */
-      tree tmp;
-      push_obstacks_nochange ();
-      end_temporary_allocation ();
-      tmp = tree_cons (NULL_TREE, sizetype, void_list_node);
-      fn = build_lang_decl (FUNCTION_DECL, fn,
-			    build_function_type (ptr_type_node, tmp));
-      DECL_EXTERNAL (fn) = 1;
-      TREE_PUBLIC (fn) = 1;
-      DECL_ARTIFICIAL (fn) = 1;
-      pushdecl_top_level (fn);
-      make_function_rtl (fn);
-      pop_obstacks ();
+      /* Declare void __cxa_free_exception (void *).  */
+      fn = push_void_library_fn (fn, tree_cons (NULL_TREE, ptr_type_node,
+						void_list_node));
     }
 
-  mark_used (fn);
-  exp = build_function_call (fn, expr_tree_cons
-			     (NULL_TREE, size_in_bytes (type), NULL_TREE));
-  exp = build1 (NOP_EXPR, build_pointer_type (type), exp);
-  return exp;
+  return build_function_call (fn, tree_cons (NULL_TREE, ptr, NULL_TREE));
 }
+#endif
 
-/* Expand a throw statement.  This follows the following
-   algorithm:
-
-	1. Allocate space to save the current PC onto the stack.
-	2. Generate and emit a label and save its address into the
-		newly allocated stack space since we can't save the pc directly.
-	3. If this is the first call to throw in this function:
-		generate a label for the throw block
-	4. jump to the throw block label.  */
+/* Build a throw expression.  */
 
-void
-expand_throw (exp)
+tree
+build_throw (exp)
      tree exp;
 {
   tree fn;
-  static tree cleanup_type;
 
-  if (! doing_eh (1))
-    return;
+  if (exp == error_mark_node)
+    return exp;
+
+  if (processing_template_decl)
+    return build_min (THROW_EXPR, void_type_node, exp);
 
-  if (exp)
+  if (exp == null_node)
+    warning ("throwing NULL, which has integral, not pointer type");
+  
+  if (exp != NULL_TREE)
     {
-      tree throw_type;
-      tree cleanup = NULL_TREE, e;
+      if (!is_admissible_throw_operand (exp))
+        return error_mark_node;
+    }
 
-      /* throw expression */
-      /* First, decay it.  */
-      exp = decay_conversion (exp);
+  if (! doing_eh (1))
+    return error_mark_node;
 
-      /* cleanup_type is void (*)(void *, int),
-	 the internal type of a destructor. */
-      if (cleanup_type == NULL_TREE)
+  if (exp && decl_is_java_type (TREE_TYPE (exp), 1))
+    {
+      tree fn = get_identifier ("_Jv_Throw");
+      if (IDENTIFIER_GLOBAL_VALUE (fn))
+	fn = IDENTIFIER_GLOBAL_VALUE (fn);
+      else
 	{
-	  push_obstacks_nochange ();
-	  end_temporary_allocation ();
-	  cleanup_type = build_pointer_type
-	    (build_function_type
-	     (void_type_node, tree_cons
-	      (NULL_TREE, ptr_type_node, tree_cons
-	       (NULL_TREE, integer_type_node, void_list_node))));
-	  pop_obstacks ();
+	  /* Declare void _Jv_Throw (void *).  */
+	  tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
+	  tmp = build_function_type (ptr_type_node, tmp);
+	  fn = push_throw_library_fn (fn, tmp);
 	}
 
-      if (TYPE_PTR_P (TREE_TYPE (exp)))
-	throw_type = build_eh_type (exp);
+      exp = build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE));
+    }
+  else if (exp)
+    {
+      tree throw_type;
+      tree cleanup;
+      tree stmt_expr;
+      tree compound_stmt;
+      tree object, ptr;
+      tree tmp;
+
+      fn = get_identifier ("__cxa_throw");
+      if (IDENTIFIER_GLOBAL_VALUE (fn))
+	fn = IDENTIFIER_GLOBAL_VALUE (fn);
       else
 	{
-	  tree object, ptr;
-
-	  /* OK, this is kind of wacky.  The WP says that we call
-	     terminate
-
-	     when the exception handling mechanism, after completing
-	     evaluation of the expression to be thrown but before the
-	     exception is caught (_except.throw_), calls a user function
-	     that exits via an uncaught exception.
-
-	     So we have to protect the actual initialization of the
-	     exception object with terminate(), but evaluate the expression
-	     first.  We also expand the call to __eh_alloc
-	     first.  Since there could be temps in the expression, we need
-	     to handle that, too.  */
-
-	  expand_start_target_temps ();
-
-#if 0
-	  /* Unfortunately, this doesn't work.  */
-	  preexpand_calls (exp);
-#else
-	  /* Store the throw expression into a temp.  This can be less
-	     efficient than storing it into the allocated space directly, but
-	     oh well.  To do this efficiently we would need to insinuate
-	     ourselves into expand_call.  */
-	  if (TREE_SIDE_EFFECTS (exp))
+	  /* The CLEANUP_TYPE is the internal type of a destructor.  */
+	  if (cleanup_type == NULL_TREE)
 	    {
-	      tree temp = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (exp));
-	      DECL_ARTIFICIAL (temp) = 1;
-	      DECL_RTL (temp) = assign_temp (TREE_TYPE (exp), 2, 0, 1);
-	      DECL_INITIAL (temp) = exp;
-	      cp_finish_decl (temp, exp, NULL_TREE, 0, LOOKUP_ONLYCONVERTING);
-	      exp = temp;
+	      tmp = void_list_node;
+	      tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
+	      tmp = build_function_type (void_type_node, tmp);
+	      cleanup_type = build_pointer_type (tmp);
 	    }
-#endif
 
-	  /* Allocate the space for the exception.  */
-	  ptr = save_expr (alloc_eh_object (TREE_TYPE (exp)));
-	  expand_expr (ptr, const0_rtx, VOIDmode, 0);
+	  /* Declare void __cxa_throw (void*, void*, void (*)(void*)).  */
+	  /* ??? Second argument is supposed to be "std::type_info*".  */
+	  tmp = void_list_node;
+	  tmp = tree_cons (NULL_TREE, cleanup_type, tmp);
+	  tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
+	  tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
+	  tmp = build_function_type (void_type_node, tmp);
+	  fn = push_throw_library_fn (fn, tmp);
+	}
 
-	  expand_eh_region_start ();
+      begin_init_stmts (&stmt_expr, &compound_stmt);
 
-	  object = build_indirect_ref (ptr, NULL_PTR);
-	  exp = build_modify_expr (object, INIT_EXPR, exp);
+      /* throw expression */
+      /* First, decay it.  */
+      exp = decay_conversion (exp);
 
-	  if (exp == error_mark_node)
-	    error ("  in thrown expression");
+      /* OK, this is kind of wacky.  The standard says that we call
+	 terminate when the exception handling mechanism, after
+	 completing evaluation of the expression to be thrown but
+	 before the exception is caught (_except.throw_), calls a
+	 user function that exits via an uncaught exception.
+
+	 So we have to protect the actual initialization of the
+	 exception object with terminate(), but evaluate the
+	 expression first.  Since there could be temps in the
+	 expression, we need to handle that, too.  We also expand
+	 the call to __cxa_allocate_exception first (which doesn't
+	 matter, since it can't throw).  */
+
+      my_friendly_assert (stmts_are_full_exprs_p () == 1, 19990926);
+
+      /* Store the throw expression into a temp.  This can be less
+	 efficient than storing it into the allocated space directly, but
+	 if we allocated the space first we would have to deal with
+	 cleaning it up if evaluating this expression throws.  */
+      if (TREE_SIDE_EFFECTS (exp))
+	{
+	  tmp = create_temporary_var (TREE_TYPE (exp));
+	  DECL_INITIAL (tmp) = exp;
+	  cp_finish_decl (tmp, exp, NULL_TREE, LOOKUP_ONLYCONVERTING);
+	  exp = tmp;
+	}
 
-	  expand_expr (exp, const0_rtx, VOIDmode, 0);
-	  expand_eh_region_end (build_terminate_handler ());
-	  expand_end_target_temps ();
+      /* Allocate the space for the exception.  */
+      ptr = create_temporary_var (ptr_type_node);
+      DECL_REGISTER (ptr) = 1;
+      cp_finish_decl (ptr, NULL_TREE, NULL_TREE, LOOKUP_ONLYCONVERTING);
+      tmp = do_allocate_exception (TREE_TYPE (exp));
+      tmp = build_modify_expr (ptr, INIT_EXPR, tmp);
+      finish_expr_stmt (tmp);
 
-	  throw_type = build_eh_type (object);
+      object = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (exp)), ptr);
+      object = build_indirect_ref (object, NULL);
 
-	  if (TYPE_HAS_DESTRUCTOR (TREE_TYPE (object)))
-	    {
-	      cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
-					 dtor_identifier, 0);
-	      cleanup = TREE_VALUE (cleanup);
-	      mark_used (cleanup);
-	      mark_addressable (cleanup);
-	      /* Pretend it's a normal function.  */
-	      cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
-	    }
+      exp = build_modify_expr (object, INIT_EXPR, exp);
+      if (exp == error_mark_node)
+	error ("  in thrown expression");
 
-	  exp = ptr;
-	}
+      exp = build1 (MUST_NOT_THROW_EXPR, TREE_TYPE (exp), exp);
+      finish_expr_stmt (exp);
 
-      /* Cast EXP to `void *' so that it will match the prototype for
-	 __cp_push_exception.  */
-      exp = convert (ptr_type_node, exp);
+      throw_type = build_eh_type_type (prepare_eh_type (TREE_TYPE (object)));
 
-      if (cleanup == NULL_TREE)
+      if (TYPE_HAS_DESTRUCTOR (TREE_TYPE (object)))
 	{
-	  cleanup = build_int_2 (0, 0);
-	  TREE_TYPE (cleanup) = cleanup_type;
+	  cleanup = lookup_fnfields (TYPE_BINFO (TREE_TYPE (object)),
+				     complete_dtor_identifier, 0);
+	  cleanup = TREE_VALUE (cleanup);
+	  mark_used (cleanup);
+	  mark_addressable (cleanup);
+	  /* Pretend it's a normal function.  */
+	  cleanup = build1 (ADDR_EXPR, cleanup_type, cleanup);
 	}
-
-      fn = get_identifier ("__cp_push_exception");
-      if (IDENTIFIER_GLOBAL_VALUE (fn))
-	fn = IDENTIFIER_GLOBAL_VALUE (fn);
       else
 	{
-	  /* Declare __cp_push_exception (void*, void*, void (*)(void*, int)),
-	     as defined in exception.cc.  */
-	  tree tmp;
-	  push_obstacks_nochange ();
-	  end_temporary_allocation ();
-	  tmp = tree_cons
-	    (NULL_TREE, ptr_type_node, tree_cons
-	     (NULL_TREE, ptr_type_node, tree_cons
-	      (NULL_TREE, cleanup_type, void_list_node)));
-	  fn = build_lang_decl (FUNCTION_DECL, fn,
-				build_function_type (void_type_node, tmp));
-	  DECL_EXTERNAL (fn) = 1;
-	  TREE_PUBLIC (fn) = 1;
-	  DECL_ARTIFICIAL (fn) = 1;
-	  pushdecl_top_level (fn);
-	  make_function_rtl (fn);
-	  pop_obstacks ();
+	  cleanup = build_int_2 (0, 0);
+	  TREE_TYPE (cleanup) = cleanup_type;
 	}
 
-      mark_used (fn);
-      e = expr_tree_cons (NULL_TREE, exp, expr_tree_cons
-			  (NULL_TREE, throw_type, expr_tree_cons
-			   (NULL_TREE, cleanup, NULL_TREE)));
-      e = build_function_call (fn, e);
-      expand_expr (e, const0_rtx, VOIDmode, 0);
+      tmp = tree_cons (NULL_TREE, cleanup, NULL_TREE);
+      tmp = tree_cons (NULL_TREE, throw_type, tmp);
+      tmp = tree_cons (NULL_TREE, ptr, tmp);
+      tmp = build_function_call (fn, tmp);
+
+      /* ??? Indicate that this function call throws throw_type.  */
+
+      finish_expr_stmt (tmp);
+
+      exp = finish_init_stmts (stmt_expr, compound_stmt);
     }
   else
     {
-      /* rethrow current exception; note that it's no longer caught.  */
+      /* Rethrow current exception.  */
 
-      tree fn = get_identifier ("__uncatch_exception");
+      tree fn = get_identifier ("__cxa_rethrow");
       if (IDENTIFIER_GLOBAL_VALUE (fn))
 	fn = IDENTIFIER_GLOBAL_VALUE (fn);
       else
 	{
-	  /* Declare void __uncatch_exception (void)
-	     as defined in exception.cc. */
-	  push_obstacks_nochange ();
-	  end_temporary_allocation ();
-	  fn = build_lang_decl (FUNCTION_DECL, fn,
-				build_function_type (void_type_node,
-						     void_list_node));
-	  DECL_EXTERNAL (fn) = 1;
-	  TREE_PUBLIC (fn) = 1;
-	  DECL_ARTIFICIAL (fn) = 1;
-	  pushdecl_top_level (fn);
-	  make_function_rtl (fn);
-	  pop_obstacks ();
+	  /* Declare void __cxa_rethrow (void).  */
+	  fn = push_throw_library_fn
+	    (fn, build_function_type (void_type_node, void_list_node));
 	}
 
-      mark_used (fn);
       exp = build_function_call (fn, NULL_TREE);
-      expand_expr (exp, const0_rtx, VOIDmode, EXPAND_NORMAL);
     }
 
-  expand_internal_throw ();
+  exp = build1 (THROW_EXPR, void_type_node, exp);
+
+  return exp;
 }
 
-/* Build a throw expression.  */
+/* Make sure TYPE is complete, pointer to complete, reference to
+   complete, or pointer to cv void. Issue diagnostic on failure.
+   Return the zero on failure and non-zero on success. FROM can be
+   the expr or decl from whence TYPE came, if available.  */
 
-tree
-build_throw (e)
-     tree e;
+static int
+complete_ptr_ref_or_void_ptr_p (type, from)
+     tree type;
+     tree from;
 {
-  if (e == error_mark_node)
-    return e;
+  int is_ptr;
+  
+  /* Check complete.  */
+  type = complete_type_or_else (type, from);
+  if (!type)
+    return 0;
+  
+  /* Or a pointer or ref to one, or cv void *.  */
+  is_ptr = TREE_CODE (type) == POINTER_TYPE;
+  if (is_ptr || TREE_CODE (type) == REFERENCE_TYPE)
+    {
+      tree core = TREE_TYPE (type);
+  
+      if (is_ptr && VOID_TYPE_P (core))
+        /* OK */;
+      else if (!complete_type_or_else (core, from))
+        return 0;
+    }
+  return 1;
+}
 
-  if (processing_template_decl)
-    return build_min (THROW_EXPR, void_type_node, e);
+/* Return truth-value if EXPRESSION is admissible in throw-expression,
+   i.e. if it is not of incomplete type or a pointer/reference to such
+   a type or of an abstract class type.  */
+
+static bool
+is_admissible_throw_operand (expr)
+     tree expr;
+{
+  tree type = TREE_TYPE (expr);
+
+  /* 15.1/4 [...] The type of the throw-expression shall not be an
+            incomplete type, or a pointer or a reference to an incomplete
+            type, other than void*, const void*, volatile void*, or
+            const volatile void*.  Except for these restriction and the
+            restrictions on type matching mentioned in 15.3, the operand
+            of throw is treated exactly as a function argument in a call
+            (5.2.2) or the operand of a return statement.  */
+  if (!complete_ptr_ref_or_void_ptr_p (type, expr))
+    return false;
+
+  /* 10.4/3 An abstract class shall not be used as a parameter type,
+            as a function return type or as type of an explicit
+            conversion.  */
+  else if (CLASS_TYPE_P (type) && CLASSTYPE_PURE_VIRTUALS (type))
+    {
+      error ("expression '%E' of abstract class type '%T' cannot be used in throw-expression", expr, type);
+      return false;
+    }
+
+  return true;
+}
+
+/* Returns nonzero if FN is a declaration of a standard C library
+   function which is known not to throw.
+
+   [lib.res.on.exception.handling]: None of the functions from the
+   Standard C library shall report an error by throwing an
+   exception, unless it calls a program-supplied function that
+   throws an exception.  */
+
+#include "cfns.h"
+
+int
+nothrow_libfn_p (fn)
+     tree fn;
+{
+  tree id;
+
+  if (TREE_PUBLIC (fn)
+      && DECL_EXTERNAL (fn)
+      && DECL_NAMESPACE_SCOPE_P (fn)
+      && DECL_EXTERN_C_P (fn))
+    /* OK */;
+  else
+    /* Can't be a C library function.  */
+    return 0;
+
+  id = DECL_ASSEMBLER_NAME (fn);
+  return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));
+}
+
+/* Returns nonzero if an exception of type FROM will be caught by a
+   handler for type TO, as per [except.handle].  */
+
+static int
+can_convert_eh (to, from)
+     tree to, from;
+{
+  if (TREE_CODE (to) == REFERENCE_TYPE)
+    to = TREE_TYPE (to);
+  if (TREE_CODE (from) == REFERENCE_TYPE)
+    from = TREE_TYPE (from);
+
+  if (TREE_CODE (to) == POINTER_TYPE && TREE_CODE (from) == POINTER_TYPE)
+    {
+      to = TREE_TYPE (to);
+      from = TREE_TYPE (from);
 
-  if (e == null_node)
-    cp_warning ("throwing NULL, which has integral, not pointer type");
+      if (! at_least_as_qualified_p (to, from))
+	return 0;
+
+      if (TREE_CODE (to) == VOID_TYPE)
+	return 1;
+
+      /* else fall through */
+    }
 
-  e = build1 (THROW_EXPR, void_type_node, e);
-  TREE_SIDE_EFFECTS (e) = 1;
-  TREE_USED (e) = 1;
+  if (CLASS_TYPE_P (to) && CLASS_TYPE_P (from)
+      && PUBLICLY_UNIQUELY_DERIVED_P (to, from))
+    return 1;
 
-  return e;
+  return 0;
+}
+
+/* Check whether any of HANDLERS are shadowed by another handler accepting
+   TYPE.  Note that the shadowing may not be complete; even if an exception
+   of type B would be caught by a handler for A, there could be a derived
+   class C for which A is an ambiguous base but B is not, so the handler
+   for B would catch an exception of type C.  */
+
+static void
+check_handlers_1 (master, handlers)
+     tree master;
+     tree handlers;
+{
+  tree type = TREE_TYPE (master);
+  tree handler;
+
+  for (handler = handlers; handler; handler = TREE_CHAIN (handler))
+    if (TREE_TYPE (handler)
+	&& can_convert_eh (type, TREE_TYPE (handler)))
+      {
+	lineno = STMT_LINENO (handler);
+	warning ("exception of type `%T' will be caught",
+		    TREE_TYPE (handler));
+	lineno = STMT_LINENO (master);
+	warning ("   by earlier handler for `%T'", type);
+	break;
+      }
+}
+
+/* Given a chain of HANDLERs, make sure that they're OK.  */
+
+void
+check_handlers (handlers)
+     tree handlers;
+{
+  tree handler;
+  int save_line = lineno;
+  for (handler = handlers; handler; handler = TREE_CHAIN (handler))
+    {
+      if (TREE_CHAIN (handler) == NULL_TREE)
+	/* No more handlers; nothing to shadow.  */;
+      else if (TREE_TYPE (handler) == NULL_TREE)
+	{
+	  lineno = STMT_LINENO (handler);
+	  pedwarn
+	    ("`...' handler must be the last handler for its try block");
+	}
+      else
+	check_handlers_1 (handler, TREE_CHAIN (handler));
+    }
+  lineno = save_line;
 }