Reorganize the gcc vendor import work area. This flattens out a bunch

of unnecessary path components that are relics of cvs2svn.

(These are directory moves)

1 files changed, 2106 insertions, 0 deletions

diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
new file mode 100644
index 0000000..d14e1ee
--- /dev/null
+++ b/gcc/tree-eh.c
@@ -0,0 +1,2106 @@
+/* Exception handling semantics and decomposition for trees.
+   Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING.  If not, write to
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "rtl.h"
+#include "tm_p.h"
+#include "flags.h"
+#include "function.h"
+#include "except.h"
+#include "tree-flow.h"
+#include "tree-dump.h"
+#include "tree-inline.h"
+#include "tree-iterator.h"
+#include "tree-pass.h"
+#include "timevar.h"
+#include "langhooks.h"
+#include "ggc.h"
+#include "toplev.h"
+
+
+/* Nonzero if we are using EH to handle cleanups.  */
+static int using_eh_for_cleanups_p = 0;
+
+void
+using_eh_for_cleanups (void)
+{
+  using_eh_for_cleanups_p = 1;
+}
+
+/* Misc functions used in this file.  */
+
+/* Compare and hash for any structure which begins with a canonical
+   pointer.  Assumes all pointers are interchangeable, which is sort
+   of already assumed by gcc elsewhere IIRC.  */
+
+static int
+struct_ptr_eq (const void *a, const void *b)
+{
+  const void * const * x = (const void * const *) a;
+  const void * const * y = (const void * const *) b;
+  return *x == *y;
+}
+
+static hashval_t
+struct_ptr_hash (const void *a)
+{
+  const void * const * x = (const void * const *) a;
+  return (size_t)*x >> 4;
+}
+
+
+/* Remember and lookup EH region data for arbitrary statements.
+   Really this means any statement that could_throw_p.  We could
+   stuff this information into the stmt_ann data structure, but:
+
+   (1) We absolutely rely on this information being kept until
+   we get to rtl.  Once we're done with lowering here, if we lose
+   the information there's no way to recover it!
+
+   (2) There are many more statements that *cannot* throw as
+   compared to those that can.  We should be saving some amount
+   of space by only allocating memory for those that can throw.  */
+
+static void
+record_stmt_eh_region (struct eh_region *region, tree t)
+{
+  if (!region)
+    return;
+
+  add_stmt_to_eh_region (t, get_eh_region_number (region));
+}
+
+void
+add_stmt_to_eh_region_fn (struct function *ifun, tree t, int num)
+{
+  struct throw_stmt_node *n;
+  void **slot;
+
+  gcc_assert (num >= 0);
+  gcc_assert (TREE_CODE (t) != RESX_EXPR);
+
+  n = GGC_NEW (struct throw_stmt_node);
+  n->stmt = t;
+  n->region_nr = num;
+
+  if (!get_eh_throw_stmt_table (ifun))
+    set_eh_throw_stmt_table (ifun, htab_create_ggc (31, struct_ptr_hash,
+						    struct_ptr_eq,
+						    ggc_free));
+
+  slot = htab_find_slot (get_eh_throw_stmt_table (ifun), n, INSERT);
+  gcc_assert (!*slot);
+  *slot = n;
+  /* ??? For the benefit of calls.c, converting all this to rtl,
+     we need to record the call expression, not just the outer
+     modify statement.  */
+  if (TREE_CODE (t) == MODIFY_EXPR
+      && (t = get_call_expr_in (t)))
+    add_stmt_to_eh_region_fn (ifun, t, num);
+}
+
+void
+add_stmt_to_eh_region (tree t, int num)
+{
+  add_stmt_to_eh_region_fn (cfun, t, num);
+}
+
+bool
+remove_stmt_from_eh_region_fn (struct function *ifun, tree t)
+{
+  struct throw_stmt_node dummy;
+  void **slot;
+
+  if (!get_eh_throw_stmt_table (ifun))
+    return false;
+
+  dummy.stmt = t;
+  slot = htab_find_slot (get_eh_throw_stmt_table (ifun), &dummy,
+                        NO_INSERT);
+  if (slot)
+    {
+      htab_clear_slot (get_eh_throw_stmt_table (ifun), slot);
+      /* ??? For the benefit of calls.c, converting all this to rtl,
+	 we need to record the call expression, not just the outer
+	 modify statement.  */
+      if (TREE_CODE (t) == MODIFY_EXPR
+	  && (t = get_call_expr_in (t)))
+	remove_stmt_from_eh_region_fn (ifun, t);
+      return true;
+    }
+  else
+    return false;
+}
+
+bool
+remove_stmt_from_eh_region (tree t)
+{
+  return remove_stmt_from_eh_region_fn (cfun, t);
+}
+
+int
+lookup_stmt_eh_region_fn (struct function *ifun, tree t)
+{
+  struct throw_stmt_node *p, n;
+
+  if (!get_eh_throw_stmt_table (ifun))
+    return -2;
+
+  n.stmt = t;
+  p = (struct throw_stmt_node *) htab_find (get_eh_throw_stmt_table (ifun),
+                                            &n);
+
+  return (p ? p->region_nr : -1);
+}
+
+int
+lookup_stmt_eh_region (tree t)
+{
+  /* We can get called from initialized data when -fnon-call-exceptions
+     is on; prevent crash.  */
+  if (!cfun)
+    return -1;
+  return lookup_stmt_eh_region_fn (cfun, t);
+}
+
+
+/* First pass of EH node decomposition.  Build up a tree of TRY_FINALLY_EXPR
+   nodes and LABEL_DECL nodes.  We will use this during the second phase to
+   determine if a goto leaves the body of a TRY_FINALLY_EXPR node.  */
+
+struct finally_tree_node
+{
+  tree child, parent;
+};
+
+/* Note that this table is *not* marked GTY.  It is short-lived.  */
+static htab_t finally_tree;
+
+static void
+record_in_finally_tree (tree child, tree parent)
+{
+  struct finally_tree_node *n;
+  void **slot;
+
+  n = XNEW (struct finally_tree_node);
+  n->child = child;
+  n->parent = parent;
+
+  slot = htab_find_slot (finally_tree, n, INSERT);
+  gcc_assert (!*slot);
+  *slot = n;
+}
+
+static void
+collect_finally_tree (tree t, tree region)
+{
+ tailrecurse:
+  switch (TREE_CODE (t))
+    {
+    case LABEL_EXPR:
+      record_in_finally_tree (LABEL_EXPR_LABEL (t), region);
+      break;
+
+    case TRY_FINALLY_EXPR:
+      record_in_finally_tree (t, region);
+      collect_finally_tree (TREE_OPERAND (t, 0), t);
+      t = TREE_OPERAND (t, 1);
+      goto tailrecurse;
+
+    case TRY_CATCH_EXPR:
+      collect_finally_tree (TREE_OPERAND (t, 0), region);
+      t = TREE_OPERAND (t, 1);
+      goto tailrecurse;
+
+    case CATCH_EXPR:
+      t = CATCH_BODY (t);
+      goto tailrecurse;
+
+    case EH_FILTER_EXPR:
+      t = EH_FILTER_FAILURE (t);
+      goto tailrecurse;
+
+    case STATEMENT_LIST:
+      {
+	tree_stmt_iterator i;
+	for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
+	  collect_finally_tree (tsi_stmt (i), region);
+      }
+      break;
+
+    default:
+      /* A type, a decl, or some kind of statement that we're not
+	 interested in.  Don't walk them.  */
+      break;
+    }
+}
+
+/* Use the finally tree to determine if a jump from START to TARGET
+   would leave the try_finally node that START lives in.  */
+
+static bool
+outside_finally_tree (tree start, tree target)
+{
+  struct finally_tree_node n, *p;
+
+  do
+    {
+      n.child = start;
+      p = (struct finally_tree_node *) htab_find (finally_tree, &n);
+      if (!p)
+	return true;
+      start = p->parent;
+    }
+  while (start != target);
+
+  return false;
+}
+
+/* Second pass of EH node decomposition.  Actually transform the TRY_FINALLY
+   and TRY_CATCH nodes into a set of gotos, magic labels, and eh regions.
+   The eh region creation is straight-forward, but frobbing all the gotos
+   and such into shape isn't.  */
+
+/* State of the world while lowering.  */
+
+struct leh_state
+{
+  /* What's "current" while constructing the eh region tree.  These
+     correspond to variables of the same name in cfun->eh, which we
+     don't have easy access to.  */
+  struct eh_region *cur_region;
+  struct eh_region *prev_try;
+
+  /* Processing of TRY_FINALLY requires a bit more state.  This is
+     split out into a separate structure so that we don't have to
+     copy so much when processing other nodes.  */
+  struct leh_tf_state *tf;
+};
+
+struct leh_tf_state
+{
+  /* Pointer to the TRY_FINALLY node under discussion.  The try_finally_expr
+     is the original TRY_FINALLY_EXPR.  We need to retain this so that
+     outside_finally_tree can reliably reference the tree used in the
+     collect_finally_tree data structures.  */
+  tree try_finally_expr;
+  tree *top_p;
+
+  /* The state outside this try_finally node.  */
+  struct leh_state *outer;
+
+  /* The exception region created for it.  */
+  struct eh_region *region;
+
+  /* The GOTO_QUEUE is is an array of GOTO_EXPR and RETURN_EXPR statements
+     that are seen to escape this TRY_FINALLY_EXPR node.  */
+  struct goto_queue_node {
+    tree stmt;
+    tree repl_stmt;
+    tree cont_stmt;
+    int index;
+  } *goto_queue;
+  size_t goto_queue_size;
+  size_t goto_queue_active;
+
+  /* The set of unique labels seen as entries in the goto queue.  */
+  VEC(tree,heap) *dest_array;
+
+  /* A label to be added at the end of the completed transformed
+     sequence.  It will be set if may_fallthru was true *at one time*,
+     though subsequent transformations may have cleared that flag.  */
+  tree fallthru_label;
+
+  /* A label that has been registered with except.c to be the
+     landing pad for this try block.  */
+  tree eh_label;
+
+  /* True if it is possible to fall out the bottom of the try block.
+     Cleared if the fallthru is converted to a goto.  */
+  bool may_fallthru;
+
+  /* True if any entry in goto_queue is a RETURN_EXPR.  */
+  bool may_return;
+
+  /* True if the finally block can receive an exception edge.
+     Cleared if the exception case is handled by code duplication.  */
+  bool may_throw;
+};
+
+static void lower_eh_filter (struct leh_state *, tree *);
+static void lower_eh_constructs_1 (struct leh_state *, tree *);
+
+/* Comparison function for qsort/bsearch.  We're interested in
+   searching goto queue elements for source statements.  */
+
+static int
+goto_queue_cmp (const void *x, const void *y)
+{
+  tree a = ((const struct goto_queue_node *)x)->stmt;
+  tree b = ((const struct goto_queue_node *)y)->stmt;
+  return (a == b ? 0 : a < b ? -1 : 1);
+}
+
+/* Search for STMT in the goto queue.  Return the replacement,
+   or null if the statement isn't in the queue.  */
+
+static tree
+find_goto_replacement (struct leh_tf_state *tf, tree stmt)
+{
+  struct goto_queue_node tmp, *ret;
+  tmp.stmt = stmt;
+  ret = (struct goto_queue_node *)
+     bsearch (&tmp, tf->goto_queue, tf->goto_queue_active,
+		 sizeof (struct goto_queue_node), goto_queue_cmp);
+  return (ret ? ret->repl_stmt : NULL);
+}
+
+/* A subroutine of replace_goto_queue_1.  Handles the sub-clauses of a
+   lowered COND_EXPR.  If, by chance, the replacement is a simple goto,
+   then we can just splat it in, otherwise we add the new stmts immediately
+   after the COND_EXPR and redirect.  */
+
+static void
+replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf,
+				tree_stmt_iterator *tsi)
+{
+  tree new, one, label;
+
+  new = find_goto_replacement (tf, *tp);
+  if (!new)
+    return;
+
+  one = expr_only (new);
+  if (one && TREE_CODE (one) == GOTO_EXPR)
+    {
+      *tp = one;
+      return;
+    }
+
+  label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
+  *tp = build_and_jump (&LABEL_EXPR_LABEL (label));
+
+  tsi_link_after (tsi, label, TSI_CONTINUE_LINKING);
+  tsi_link_after (tsi, new, TSI_CONTINUE_LINKING);
+}
+
+/* The real work of replace_goto_queue.  Returns with TSI updated to
+   point to the next statement.  */
+
+static void replace_goto_queue_stmt_list (tree, struct leh_tf_state *);
+
+static void
+replace_goto_queue_1 (tree t, struct leh_tf_state *tf, tree_stmt_iterator *tsi)
+{
+  switch (TREE_CODE (t))
+    {
+    case GOTO_EXPR:
+    case RETURN_EXPR:
+      t = find_goto_replacement (tf, t);
+      if (t)
+	{
+	  tsi_link_before (tsi, t, TSI_SAME_STMT);
+	  tsi_delink (tsi);
+	  return;
+	}
+      break;
+
+    case COND_EXPR:
+      replace_goto_queue_cond_clause (&COND_EXPR_THEN (t), tf, tsi);
+      replace_goto_queue_cond_clause (&COND_EXPR_ELSE (t), tf, tsi);
+      break;
+
+    case TRY_FINALLY_EXPR:
+    case TRY_CATCH_EXPR:
+      replace_goto_queue_stmt_list (TREE_OPERAND (t, 0), tf);
+      replace_goto_queue_stmt_list (TREE_OPERAND (t, 1), tf);
+      break;
+    case CATCH_EXPR:
+      replace_goto_queue_stmt_list (CATCH_BODY (t), tf);
+      break;
+    case EH_FILTER_EXPR:
+      replace_goto_queue_stmt_list (EH_FILTER_FAILURE (t), tf);
+      break;
+
+    case STATEMENT_LIST:
+      gcc_unreachable ();
+
+    default:
+      /* These won't have gotos in them.  */
+      break;
+    }
+
+  tsi_next (tsi);
+}
+
+/* A subroutine of replace_goto_queue.  Handles STATEMENT_LISTs.  */
+
+static void
+replace_goto_queue_stmt_list (tree t, struct leh_tf_state *tf)
+{
+  tree_stmt_iterator i = tsi_start (t);
+  while (!tsi_end_p (i))
+    replace_goto_queue_1 (tsi_stmt (i), tf, &i);
+}
+
+/* Replace all goto queue members.  */
+
+static void
+replace_goto_queue (struct leh_tf_state *tf)
+{
+  if (tf->goto_queue_active == 0)
+    return;
+  replace_goto_queue_stmt_list (*tf->top_p, tf);
+}
+
+/* For any GOTO_EXPR or RETURN_EXPR, decide whether it leaves a try_finally
+   node, and if so record that fact in the goto queue associated with that
+   try_finally node.  */
+
+static void
+maybe_record_in_goto_queue (struct leh_state *state, tree stmt)
+{
+  struct leh_tf_state *tf = state->tf;
+  struct goto_queue_node *q;
+  size_t active, size;
+  int index;
+
+  if (!tf)
+    return;
+
+  switch (TREE_CODE (stmt))
+    {
+    case GOTO_EXPR:
+      {
+	tree lab = GOTO_DESTINATION (stmt);
+
+	/* Computed and non-local gotos do not get processed.  Given
+	   their nature we can neither tell whether we've escaped the
+	   finally block nor redirect them if we knew.  */
+	if (TREE_CODE (lab) != LABEL_DECL)
+	  return;
+
+	/* No need to record gotos that don't leave the try block.  */
+	if (! outside_finally_tree (lab, tf->try_finally_expr))
+	  return;
+
+	if (! tf->dest_array)
+	  {
+	    tf->dest_array = VEC_alloc (tree, heap, 10);
+	    VEC_quick_push (tree, tf->dest_array, lab);
+	    index = 0;
+	  }
+	else
+	  {
+	    int n = VEC_length (tree, tf->dest_array);
+	    for (index = 0; index < n; ++index)
+	      if (VEC_index (tree, tf->dest_array, index) == lab)
+		break;
+	    if (index == n)
+	      VEC_safe_push (tree, heap, tf->dest_array, lab);
+	  }
+      }
+      break;
+
+    case RETURN_EXPR:
+      tf->may_return = true;
+      index = -1;
+      break;
+
+    default:
+      gcc_unreachable ();
+    }
+
+  active = tf->goto_queue_active;
+  size = tf->goto_queue_size;
+  if (active >= size)
+    {
+      size = (size ? size * 2 : 32);
+      tf->goto_queue_size = size;
+      tf->goto_queue
+         = XRESIZEVEC (struct goto_queue_node, tf->goto_queue, size);
+    }
+
+  q = &tf->goto_queue[active];
+  tf->goto_queue_active = active + 1;
+
+  memset (q, 0, sizeof (*q));
+  q->stmt = stmt;
+  q->index = index;
+}
+
+#ifdef ENABLE_CHECKING
+/* We do not process SWITCH_EXPRs for now.  As long as the original source
+   was in fact structured, and we've not yet done jump threading, then none
+   of the labels will leave outer TRY_FINALLY_EXPRs.  Verify this.  */
+
+static void
+verify_norecord_switch_expr (struct leh_state *state, tree switch_expr)
+{
+  struct leh_tf_state *tf = state->tf;
+  size_t i, n;
+  tree vec;
+
+  if (!tf)
+    return;
+
+  vec = SWITCH_LABELS (switch_expr);
+  n = TREE_VEC_LENGTH (vec);
+
+  for (i = 0; i < n; ++i)
+    {
+      tree lab = CASE_LABEL (TREE_VEC_ELT (vec, i));
+      gcc_assert (!outside_finally_tree (lab, tf->try_finally_expr));
+    }
+}
+#else
+#define verify_norecord_switch_expr(state, switch_expr)
+#endif
+
+/* Redirect a RETURN_EXPR pointed to by STMT_P to FINLAB.  Place in CONT_P
+   whatever is needed to finish the return.  If MOD is non-null, insert it
+   before the new branch.  RETURN_VALUE_P is a cache containing a temporary
+   variable to be used in manipulating the value returned from the function.  */
+
+static void
+do_return_redirection (struct goto_queue_node *q, tree finlab, tree mod,
+		       tree *return_value_p)
+{
+  tree ret_expr = TREE_OPERAND (q->stmt, 0);
+  tree x;
+
+  if (ret_expr)
+    {
+      /* The nasty part about redirecting the return value is that the
+	 return value itself is to be computed before the FINALLY block
+	 is executed.  e.g.
+
+		int x;
+		int foo (void)
+		{
+		  x = 0;
+		  try {
+		    return x;
+		  } finally {
+		    x++;
+		  }
+		}
+
+	  should return 0, not 1.  Arrange for this to happen by copying
+	  computed the return value into a local temporary.  This also
+	  allows us to redirect multiple return statements through the
+	  same destination block; whether this is a net win or not really
+	  depends, I guess, but it does make generation of the switch in
+	  lower_try_finally_switch easier.  */
+
+      switch (TREE_CODE (ret_expr))
+	{
+	case RESULT_DECL:
+	  if (!*return_value_p)
+	    *return_value_p = ret_expr;
+	  else
+	    gcc_assert (*return_value_p == ret_expr);
+	  q->cont_stmt = q->stmt;
+	  break;
+
+	case MODIFY_EXPR:
+	  {
+	    tree result = TREE_OPERAND (ret_expr, 0);
+	    tree new, old = TREE_OPERAND (ret_expr, 1);
+
+	    if (!*return_value_p)
+	      {
+		if (aggregate_value_p (TREE_TYPE (result),
+				      TREE_TYPE (current_function_decl)))
+		  /* If this function returns in memory, copy the argument
+		    into the return slot now.  Otherwise, we might need to
+		    worry about magic return semantics, so we need to use a
+		    temporary to hold the value until we're actually ready
+		    to return.  */
+		  new = result;
+		else
+		  new = create_tmp_var (TREE_TYPE (old), "rettmp");
+		*return_value_p = new;
+	      }
+	    else
+	      new = *return_value_p;
+
+	    x = build2 (MODIFY_EXPR, TREE_TYPE (new), new, old);
+	    append_to_statement_list (x, &q->repl_stmt);
+
+	    if (new == result)
+	      x = result;
+	    else
+	      x = build2 (MODIFY_EXPR, TREE_TYPE (result), result, new);
+	    q->cont_stmt = build1 (RETURN_EXPR, void_type_node, x);
+	  }
+
+	default:
+	  gcc_unreachable ();
+	}
+    }
+  else
+    {
+      /* If we don't return a value, all return statements are the same.  */
+      q->cont_stmt = q->stmt;
+    }
+
+  if (mod)
+    append_to_statement_list (mod, &q->repl_stmt);
+
+  x = build1 (GOTO_EXPR, void_type_node, finlab);
+  append_to_statement_list (x, &q->repl_stmt);
+}
+
+/* Similar, but easier, for GOTO_EXPR.  */
+
+static void
+do_goto_redirection (struct goto_queue_node *q, tree finlab, tree mod)
+{
+  tree x;
+
+  q->cont_stmt = q->stmt;
+  if (mod)
+    append_to_statement_list (mod, &q->repl_stmt);
+
+  x = build1 (GOTO_EXPR, void_type_node, finlab);
+  append_to_statement_list (x, &q->repl_stmt);
+}
+
+/* We want to transform
+	try { body; } catch { stuff; }
+   to
+	body; goto over; lab: stuff; over:
+
+   T is a TRY_FINALLY or TRY_CATCH node.  LAB is the label that
+   should be placed before the second operand, or NULL.  OVER is
+   an existing label that should be put at the exit, or NULL.  */
+
+static void
+frob_into_branch_around (tree *tp, tree lab, tree over)
+{
+  tree x, op1;
+
+  op1 = TREE_OPERAND (*tp, 1);
+  *tp = TREE_OPERAND (*tp, 0);
+
+  if (block_may_fallthru (*tp))
+    {
+      if (!over)
+	over = create_artificial_label ();
+      x = build1 (GOTO_EXPR, void_type_node, over);
+      append_to_statement_list (x, tp);
+    }
+
+  if (lab)
+    {
+      x = build1 (LABEL_EXPR, void_type_node, lab);
+      append_to_statement_list (x, tp);
+    }
+
+  append_to_statement_list (op1, tp);
+
+  if (over)
+    {
+      x = build1 (LABEL_EXPR, void_type_node, over);
+      append_to_statement_list (x, tp);
+    }
+}
+
+/* A subroutine of lower_try_finally.  Duplicate the tree rooted at T.
+   Make sure to record all new labels found.  */
+
+static tree
+lower_try_finally_dup_block (tree t, struct leh_state *outer_state)
+{
+  tree region = NULL;
+
+  t = unsave_expr_now (t);
+
+  if (outer_state->tf)
+    region = outer_state->tf->try_finally_expr;
+  collect_finally_tree (t, region);
+
+  return t;
+}
+
+/* A subroutine of lower_try_finally.  Create a fallthru label for
+   the given try_finally state.  The only tricky bit here is that
+   we have to make sure to record the label in our outer context.  */
+
+static tree
+lower_try_finally_fallthru_label (struct leh_tf_state *tf)
+{
+  tree label = tf->fallthru_label;
+  if (!label)
+    {
+      label = create_artificial_label ();
+      tf->fallthru_label = label;
+      if (tf->outer->tf)
+        record_in_finally_tree (label, tf->outer->tf->try_finally_expr);
+    }
+  return label;
+}
+
+/* A subroutine of lower_try_finally.  If lang_protect_cleanup_actions
+   returns non-null, then the language requires that the exception path out
+   of a try_finally be treated specially.  To wit: the code within the
+   finally block may not itself throw an exception.  We have two choices here.
+   First we can duplicate the finally block and wrap it in a must_not_throw
+   region.  Second, we can generate code like
+
+	try {
+	  finally_block;
+	} catch {
+	  if (fintmp == eh_edge)
+	    protect_cleanup_actions;
+	}
+
+   where "fintmp" is the temporary used in the switch statement generation
+   alternative considered below.  For the nonce, we always choose the first
+   option.
+
+   THIS_STATE may be null if this is a try-cleanup, not a try-finally.  */
+
+static void
+honor_protect_cleanup_actions (struct leh_state *outer_state,
+			       struct leh_state *this_state,
+			       struct leh_tf_state *tf)
+{
+  tree protect_cleanup_actions, finally, x;
+  tree_stmt_iterator i;
+  bool finally_may_fallthru;
+
+  /* First check for nothing to do.  */
+  if (lang_protect_cleanup_actions)
+    protect_cleanup_actions = lang_protect_cleanup_actions ();
+  else
+    protect_cleanup_actions = NULL;
+
+  finally = TREE_OPERAND (*tf->top_p, 1);
+
+  /* If the EH case of the finally block can fall through, this may be a
+     structure of the form
+	try {
+	  try {
+	    throw ...;
+	  } cleanup {
+	    try {
+	      throw ...;
+	    } catch (...) {
+	    }
+	  }
+	} catch (...) {
+	  yyy;
+	}
+    E.g. with an inline destructor with an embedded try block.  In this
+    case we must save the runtime EH data around the nested exception.
+
+    This complication means that any time the previous runtime data might
+    be used (via fallthru from the finally) we handle the eh case here,
+    whether or not protect_cleanup_actions is active.  */
+
+  finally_may_fallthru = block_may_fallthru (finally);
+  if (!finally_may_fallthru && !protect_cleanup_actions)
+    return;
+
+  /* Duplicate the FINALLY block.  Only need to do this for try-finally,
+     and not for cleanups.  */
+  if (this_state)
+    finally = lower_try_finally_dup_block (finally, outer_state);
+
+  /* Resume execution after the exception.  Adding this now lets
+     lower_eh_filter not add unnecessary gotos, as it is clear that
+     we never fallthru from this copy of the finally block.  */
+  if (finally_may_fallthru)
+    {
+      tree save_eptr, save_filt;
+
+      save_eptr = create_tmp_var (ptr_type_node, "save_eptr");
+      save_filt = create_tmp_var (integer_type_node, "save_filt");
+
+      i = tsi_start (finally);
+      x = build0 (EXC_PTR_EXPR, ptr_type_node);
+      x = build2 (MODIFY_EXPR, void_type_node, save_eptr, x);
+      tsi_link_before (&i, x, TSI_CONTINUE_LINKING);
+
+      x = build0 (FILTER_EXPR, integer_type_node);
+      x = build2 (MODIFY_EXPR, void_type_node, save_filt, x);
+      tsi_link_before (&i, x, TSI_CONTINUE_LINKING);
+
+      i = tsi_last (finally);
+      x = build0 (EXC_PTR_EXPR, ptr_type_node);
+      x = build2 (MODIFY_EXPR, void_type_node, x, save_eptr);
+      tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
+
+      x = build0 (FILTER_EXPR, integer_type_node);
+      x = build2 (MODIFY_EXPR, void_type_node, x, save_filt);
+      tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
+
+      x = build_resx (get_eh_region_number (tf->region));
+      tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
+    }
+
+  /* Wrap the block with protect_cleanup_actions as the action.  */
+  if (protect_cleanup_actions)
+    {
+      x = build2 (EH_FILTER_EXPR, void_type_node, NULL, NULL);
+      append_to_statement_list (protect_cleanup_actions, &EH_FILTER_FAILURE (x));
+      EH_FILTER_MUST_NOT_THROW (x) = 1;
+      finally = build2 (TRY_CATCH_EXPR, void_type_node, finally, x);
+      lower_eh_filter (outer_state, &finally);
+    }
+  else
+    lower_eh_constructs_1 (outer_state, &finally);
+
+  /* Hook this up to the end of the existing try block.  If we
+     previously fell through the end, we'll have to branch around.
+     This means adding a new goto, and adding it to the queue.  */
+
+  i = tsi_last (TREE_OPERAND (*tf->top_p, 0));
+
+  if (tf->may_fallthru)
+    {
+      x = lower_try_finally_fallthru_label (tf);
+      x = build1 (GOTO_EXPR, void_type_node, x);
+      tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
+
+      if (this_state)
+        maybe_record_in_goto_queue (this_state, x);
+
+      tf->may_fallthru = false;
+    }
+
+  x = build1 (LABEL_EXPR, void_type_node, tf->eh_label);
+  tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
+  tsi_link_after (&i, finally, TSI_CONTINUE_LINKING);
+
+  /* Having now been handled, EH isn't to be considered with
+     the rest of the outgoing edges.  */
+  tf->may_throw = false;
+}
+
+/* A subroutine of lower_try_finally.  We have determined that there is
+   no fallthru edge out of the finally block.  This means that there is
+   no outgoing edge corresponding to any incoming edge.  Restructure the
+   try_finally node for this special case.  */
+
+static void
+lower_try_finally_nofallthru (struct leh_state *state, struct leh_tf_state *tf)
+{
+  tree x, finally, lab, return_val;
+  struct goto_queue_node *q, *qe;
+
+  if (tf->may_throw)
+    lab = tf->eh_label;
+  else
+    lab = create_artificial_label ();
+
+  finally = TREE_OPERAND (*tf->top_p, 1);
+  *tf->top_p = TREE_OPERAND (*tf->top_p, 0);
+
+  x = build1 (LABEL_EXPR, void_type_node, lab);
+  append_to_statement_list (x, tf->top_p);
+
+  return_val = NULL;
+  q = tf->goto_queue;
+  qe = q + tf->goto_queue_active;
+  for (; q < qe; ++q)
+    if (q->index < 0)
+      do_return_redirection (q, lab, NULL, &return_val);
+    else
+      do_goto_redirection (q, lab, NULL);
+
+  replace_goto_queue (tf);
+
+  lower_eh_constructs_1 (state, &finally);
+  append_to_statement_list (finally, tf->top_p);
+}
+
+/* A subroutine of lower_try_finally.  We have determined that there is
+   exactly one destination of the finally block.  Restructure the
+   try_finally node for this special case.  */
+
+static void
+lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
+{
+  struct goto_queue_node *q, *qe;
+  tree x, finally, finally_label;
+
+  finally = TREE_OPERAND (*tf->top_p, 1);
+  *tf->top_p = TREE_OPERAND (*tf->top_p, 0);
+
+  lower_eh_constructs_1 (state, &finally);
+
+  if (tf->may_throw)
+    {
+      /* Only reachable via the exception edge.  Add the given label to
+         the head of the FINALLY block.  Append a RESX at the end.  */
+
+      x = build1 (LABEL_EXPR, void_type_node, tf->eh_label);
+      append_to_statement_list (x, tf->top_p);
+
+      append_to_statement_list (finally, tf->top_p);
+
+      x = build_resx (get_eh_region_number (tf->region));
+
+      append_to_statement_list (x, tf->top_p);
+
+      return;
+    }
+
+  if (tf->may_fallthru)
+    {
+      /* Only reachable via the fallthru edge.  Do nothing but let
+	 the two blocks run together; we'll fall out the bottom.  */
+      append_to_statement_list (finally, tf->top_p);
+      return;
+    }
+
+  finally_label = create_artificial_label ();
+  x = build1 (LABEL_EXPR, void_type_node, finally_label);
+  append_to_statement_list (x, tf->top_p);
+
+  append_to_statement_list (finally, tf->top_p);
+
+  q = tf->goto_queue;
+  qe = q + tf->goto_queue_active;
+
+  if (tf->may_return)
+    {
+      /* Reachable by return expressions only.  Redirect them.  */
+      tree return_val = NULL;
+      for (; q < qe; ++q)
+	do_return_redirection (q, finally_label, NULL, &return_val);
+      replace_goto_queue (tf);
+    }
+  else
+    {
+      /* Reachable by goto expressions only.  Redirect them.  */
+      for (; q < qe; ++q)
+	do_goto_redirection (q, finally_label, NULL);
+      replace_goto_queue (tf);
+
+      if (VEC_index (tree, tf->dest_array, 0) == tf->fallthru_label)
+	{
+	  /* Reachable by goto to fallthru label only.  Redirect it
+	     to the new label (already created, sadly), and do not
+	     emit the final branch out, or the fallthru label.  */
+	  tf->fallthru_label = NULL;
+	  return;
+	}
+    }
+
+  append_to_statement_list (tf->goto_queue[0].cont_stmt, tf->top_p);
+  maybe_record_in_goto_queue (state, tf->goto_queue[0].cont_stmt);
+}
+
+/* A subroutine of lower_try_finally.  There are multiple edges incoming
+   and outgoing from the finally block.  Implement this by duplicating the
+   finally block for every destination.  */
+
+static void
+lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
+{
+  tree finally, new_stmt;
+  tree x;
+
+  finally = TREE_OPERAND (*tf->top_p, 1);
+  *tf->top_p = TREE_OPERAND (*tf->top_p, 0);
+
+  new_stmt = NULL_TREE;
+
+  if (tf->may_fallthru)
+    {
+      x = lower_try_finally_dup_block (finally, state);
+      lower_eh_constructs_1 (state, &x);
+      append_to_statement_list (x, &new_stmt);
+
+      x = lower_try_finally_fallthru_label (tf);
+      x = build1 (GOTO_EXPR, void_type_node, x);
+      append_to_statement_list (x, &new_stmt);
+    }
+
+  if (tf->may_throw)
+    {
+      x = build1 (LABEL_EXPR, void_type_node, tf->eh_label);
+      append_to_statement_list (x, &new_stmt);
+
+      x = lower_try_finally_dup_block (finally, state);
+      lower_eh_constructs_1 (state, &x);
+      append_to_statement_list (x, &new_stmt);
+
+      x = build_resx (get_eh_region_number (tf->region));
+      append_to_statement_list (x, &new_stmt);
+    }
+
+  if (tf->goto_queue)
+    {
+      struct goto_queue_node *q, *qe;
+      tree return_val = NULL;
+      int return_index, index;
+      struct labels_s
+      {
+	struct goto_queue_node *q;
+	tree label;
+      } *labels;
+
+      return_index = VEC_length (tree, tf->dest_array);
+      labels = XCNEWVEC (struct labels_s, return_index + 1);
+
+      q = tf->goto_queue;
+      qe = q + tf->goto_queue_active;
+      for (; q < qe; q++)
+	{
+	  index = q->index < 0 ? return_index : q->index;
+
+	  if (!labels[index].q)
+	    labels[index].q = q;
+	}
+
+      for (index = 0; index < return_index + 1; index++)
+	{
+	  tree lab;
+
+	  q = labels[index].q;
+	  if (! q)
+	    continue;
+
+	  lab = labels[index].label = create_artificial_label ();
+
+	  if (index == return_index)
+	    do_return_redirection (q, lab, NULL, &return_val);
+	  else
+	    do_goto_redirection (q, lab, NULL);
+
+	  x = build1 (LABEL_EXPR, void_type_node, lab);
+	  append_to_statement_list (x, &new_stmt);
+
+	  x = lower_try_finally_dup_block (finally, state);
+	  lower_eh_constructs_1 (state, &x);
+	  append_to_statement_list (x, &new_stmt);
+
+	  append_to_statement_list (q->cont_stmt, &new_stmt);
+	  maybe_record_in_goto_queue (state, q->cont_stmt);
+	}
+
+      for (q = tf->goto_queue; q < qe; q++)
+	{
+	  tree lab;
+
+	  index = q->index < 0 ? return_index : q->index;
+
+	  if (labels[index].q == q)
+	    continue;
+
+	  lab = labels[index].label;
+
+	  if (index == return_index)
+	    do_return_redirection (q, lab, NULL, &return_val);
+	  else
+	    do_goto_redirection (q, lab, NULL);
+	}
+	
+      replace_goto_queue (tf);
+      free (labels);
+    }
+
+  /* Need to link new stmts after running replace_goto_queue due
+     to not wanting to process the same goto stmts twice.  */
+  append_to_statement_list (new_stmt, tf->top_p);
+}
+
+/* A subroutine of lower_try_finally.  There are multiple edges incoming
+   and outgoing from the finally block.  Implement this by instrumenting
+   each incoming edge and creating a switch statement at the end of the
+   finally block that branches to the appropriate destination.  */
+
+static void
+lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
+{
+  struct goto_queue_node *q, *qe;
+  tree return_val = NULL;
+  tree finally, finally_tmp, finally_label;
+  int return_index, eh_index, fallthru_index;
+  int nlabels, ndests, j, last_case_index;
+  tree case_label_vec, switch_stmt, last_case, switch_body;
+  tree x;
+
+  /* Mash the TRY block to the head of the chain.  */
+  finally = TREE_OPERAND (*tf->top_p, 1);
+  *tf->top_p = TREE_OPERAND (*tf->top_p, 0);
+
+  /* Lower the finally block itself.  */
+  lower_eh_constructs_1 (state, &finally);
+
+  /* Prepare for switch statement generation.  */
+  nlabels = VEC_length (tree, tf->dest_array);
+  return_index = nlabels;
+  eh_index = return_index + tf->may_return;
+  fallthru_index = eh_index + tf->may_throw;
+  ndests = fallthru_index + tf->may_fallthru;
+
+  finally_tmp = create_tmp_var (integer_type_node, "finally_tmp");
+  finally_label = create_artificial_label ();
+
+  case_label_vec = make_tree_vec (ndests);
+  switch_stmt = build3 (SWITCH_EXPR, integer_type_node, finally_tmp,
+		        NULL_TREE, case_label_vec);
+  switch_body = NULL;
+  last_case = NULL;
+  last_case_index = 0;
+
+  /* Begin inserting code for getting to the finally block.  Things
+     are done in this order to correspond to the sequence the code is
+     layed out.  */
+
+  if (tf->may_fallthru)
+    {
+      x = build2 (MODIFY_EXPR, void_type_node, finally_tmp,
+		  build_int_cst (NULL_TREE, fallthru_index));
+      append_to_statement_list (x, tf->top_p);
+
+      if (tf->may_throw)
+	{
+	  x = build1 (GOTO_EXPR, void_type_node, finally_label);
+	  append_to_statement_list (x, tf->top_p);
+	}
+
+
+      last_case = build3 (CASE_LABEL_EXPR, void_type_node,
+			  build_int_cst (NULL_TREE, fallthru_index), NULL,
+			  create_artificial_label ());
+      TREE_VEC_ELT (case_label_vec, last_case_index) = last_case;
+      last_case_index++;
+
+      x = build1 (LABEL_EXPR, void_type_node, CASE_LABEL (last_case));
+      append_to_statement_list (x, &switch_body);
+
+      x = lower_try_finally_fallthru_label (tf);
+      x = build1 (GOTO_EXPR, void_type_node, x);
+      append_to_statement_list (x, &switch_body);
+    }
+
+  if (tf->may_throw)
+    {
+      x = build1 (LABEL_EXPR, void_type_node, tf->eh_label);
+      append_to_statement_list (x, tf->top_p);
+
+      x = build2 (MODIFY_EXPR, void_type_node, finally_tmp,
+		  build_int_cst (NULL_TREE, eh_index));
+      append_to_statement_list (x, tf->top_p);
+
+      last_case = build3 (CASE_LABEL_EXPR, void_type_node,
+			  build_int_cst (NULL_TREE, eh_index), NULL,
+			  create_artificial_label ());
+      TREE_VEC_ELT (case_label_vec, last_case_index) = last_case;
+      last_case_index++;
+
+      x = build1 (LABEL_EXPR, void_type_node, CASE_LABEL (last_case));
+      append_to_statement_list (x, &switch_body);
+      x = build_resx (get_eh_region_number (tf->region));
+      append_to_statement_list (x, &switch_body);
+    }
+
+  x = build1 (LABEL_EXPR, void_type_node, finally_label);
+  append_to_statement_list (x, tf->top_p);
+
+  append_to_statement_list (finally, tf->top_p);
+
+  /* Redirect each incoming goto edge.  */
+  q = tf->goto_queue;
+  qe = q + tf->goto_queue_active;
+  j = last_case_index + tf->may_return;
+  for (; q < qe; ++q)
+    {
+      tree mod;
+      int switch_id, case_index;
+
+      if (q->index < 0)
+	{
+	  mod = build2 (MODIFY_EXPR, void_type_node, finally_tmp,
+		        build_int_cst (NULL_TREE, return_index));
+	  do_return_redirection (q, finally_label, mod, &return_val);
+	  switch_id = return_index;
+	}
+      else
+	{
+	  mod = build2 (MODIFY_EXPR, void_type_node, finally_tmp,
+		        build_int_cst (NULL_TREE, q->index));
+	  do_goto_redirection (q, finally_label, mod);
+	  switch_id = q->index;
+	}
+
+      case_index = j + q->index;
+      if (!TREE_VEC_ELT (case_label_vec, case_index))
+	TREE_VEC_ELT (case_label_vec, case_index)
+	  = build3 (CASE_LABEL_EXPR, void_type_node,
+		    build_int_cst (NULL_TREE, switch_id), NULL,
+		    /* We store the cont_stmt in the
+		       CASE_LABEL, so that we can recover it
+		       in the loop below.  We don't create
+		       the new label while walking the
+		       goto_queue because pointers don't
+		       offer a stable order.  */
+		    q->cont_stmt);
+    }
+  for (j = last_case_index; j < last_case_index + nlabels; j++)
+    {
+      tree label;
+      tree cont_stmt;
+
+      last_case = TREE_VEC_ELT (case_label_vec, j);
+
+      gcc_assert (last_case);
+
+      cont_stmt = CASE_LABEL (last_case);
+
+      label = create_artificial_label ();
+      CASE_LABEL (last_case) = label;
+
+      x = build1 (LABEL_EXPR, void_type_node, label);
+      append_to_statement_list (x, &switch_body);
+      append_to_statement_list (cont_stmt, &switch_body);
+      maybe_record_in_goto_queue (state, cont_stmt);
+    }
+  replace_goto_queue (tf);
+
+  /* Make sure that the last case is the default label, as one is required.
+     Then sort the labels, which is also required in GIMPLE.  */
+  CASE_LOW (last_case) = NULL;
+  sort_case_labels (case_label_vec);
+
+  /* Need to link switch_stmt after running replace_goto_queue due
+     to not wanting to process the same goto stmts twice.  */
+  append_to_statement_list (switch_stmt, tf->top_p);
+  append_to_statement_list (switch_body, tf->top_p);
+}
+
+/* Decide whether or not we are going to duplicate the finally block.
+   There are several considerations.
+
+   First, if this is Java, then the finally block contains code
+   written by the user.  It has line numbers associated with it,
+   so duplicating the block means it's difficult to set a breakpoint.
+   Since controlling code generation via -g is verboten, we simply
+   never duplicate code without optimization.
+
+   Second, we'd like to prevent egregious code growth.  One way to
+   do this is to estimate the size of the finally block, multiply
+   that by the number of copies we'd need to make, and compare against
+   the estimate of the size of the switch machinery we'd have to add.  */
+
+static bool
+decide_copy_try_finally (int ndests, tree finally)
+{
+  int f_estimate, sw_estimate;
+
+  if (!optimize)
+    return false;
+
+  /* Finally estimate N times, plus N gotos.  */
+  f_estimate = estimate_num_insns (finally);
+  f_estimate = (f_estimate + 1) * ndests;
+
+  /* Switch statement (cost 10), N variable assignments, N gotos.  */
+  sw_estimate = 10 + 2 * ndests;
+
+  /* Optimize for size clearly wants our best guess.  */
+  if (optimize_size)
+    return f_estimate < sw_estimate;
+
+  /* ??? These numbers are completely made up so far.  */
+  if (optimize > 1)
+    return f_estimate < 100 || f_estimate < sw_estimate * 2;
+  else
+    return f_estimate < 40 || f_estimate * 2 < sw_estimate * 3;
+}
+
+/* A subroutine of lower_eh_constructs_1.  Lower a TRY_FINALLY_EXPR nodes
+   to a sequence of labels and blocks, plus the exception region trees
+   that record all the magic.  This is complicated by the need to
+   arrange for the FINALLY block to be executed on all exits.  */
+
+static void
+lower_try_finally (struct leh_state *state, tree *tp)
+{
+  struct leh_tf_state this_tf;
+  struct leh_state this_state;
+  int ndests;
+
+  /* Process the try block.  */
+
+  memset (&this_tf, 0, sizeof (this_tf));
+  this_tf.try_finally_expr = *tp;
+  this_tf.top_p = tp;
+  this_tf.outer = state;
+  if (using_eh_for_cleanups_p)
+    this_tf.region
+      = gen_eh_region_cleanup (state->cur_region, state->prev_try);
+  else
+    this_tf.region = NULL;
+
+  this_state.cur_region = this_tf.region;
+  this_state.prev_try = state->prev_try;
+  this_state.tf = &this_tf;
+
+  lower_eh_constructs_1 (&this_state, &TREE_OPERAND (*tp, 0));
+
+  /* Determine if the try block is escaped through the bottom.  */
+  this_tf.may_fallthru = block_may_fallthru (TREE_OPERAND (*tp, 0));
+
+  /* Determine if any exceptions are possible within the try block.  */
+  if (using_eh_for_cleanups_p)
+    this_tf.may_throw = get_eh_region_may_contain_throw (this_tf.region);
+  if (this_tf.may_throw)
+    {
+      this_tf.eh_label = create_artificial_label ();
+      set_eh_region_tree_label (this_tf.region, this_tf.eh_label);
+      honor_protect_cleanup_actions (state, &this_state, &this_tf);
+    }
+
+  /* Sort the goto queue for efficient searching later.  */
+  if (this_tf.goto_queue_active > 1)
+    qsort (this_tf.goto_queue, this_tf.goto_queue_active,
+	   sizeof (struct goto_queue_node), goto_queue_cmp);
+
+  /* Determine how many edges (still) reach the finally block.  Or rather,
+     how many destinations are reached by the finally block.  Use this to
+     determine how we process the finally block itself.  */
+
+  ndests = VEC_length (tree, this_tf.dest_array);
+  ndests += this_tf.may_fallthru;
+  ndests += this_tf.may_return;
+  ndests += this_tf.may_throw;
+
+  /* If the FINALLY block is not reachable, dike it out.  */
+  if (ndests == 0)
+    *tp = TREE_OPERAND (*tp, 0);
+
+  /* If the finally block doesn't fall through, then any destination
+     we might try to impose there isn't reached either.  There may be
+     some minor amount of cleanup and redirection still needed.  */
+  else if (!block_may_fallthru (TREE_OPERAND (*tp, 1)))
+    lower_try_finally_nofallthru (state, &this_tf);
+
+  /* We can easily special-case redirection to a single destination.  */
+  else if (ndests == 1)
+    lower_try_finally_onedest (state, &this_tf);
+
+  else if (decide_copy_try_finally (ndests, TREE_OPERAND (*tp, 1)))
+    lower_try_finally_copy (state, &this_tf);
+  else
+    lower_try_finally_switch (state, &this_tf);
+
+  /* If someone requested we add a label at the end of the transformed
+     block, do so.  */
+  if (this_tf.fallthru_label)
+    {
+      tree x = build1 (LABEL_EXPR, void_type_node, this_tf.fallthru_label);
+      append_to_statement_list (x, tp);
+    }
+
+  VEC_free (tree, heap, this_tf.dest_array);
+  if (this_tf.goto_queue)
+    free (this_tf.goto_queue);
+}
+
+/* A subroutine of lower_eh_constructs_1.  Lower a TRY_CATCH_EXPR with a
+   list of CATCH_EXPR nodes to a sequence of labels and blocks, plus the
+   exception region trees that record all the magic.  */
+
+static void
+lower_catch (struct leh_state *state, tree *tp)
+{
+  struct eh_region *try_region;
+  struct leh_state this_state;
+  tree_stmt_iterator i;
+  tree out_label;
+
+  try_region = gen_eh_region_try (state->cur_region);
+  this_state.cur_region = try_region;
+  this_state.prev_try = try_region;
+  this_state.tf = state->tf;
+
+  lower_eh_constructs_1 (&this_state, &TREE_OPERAND (*tp, 0));
+
+  if (!get_eh_region_may_contain_throw (try_region))
+    {
+      *tp = TREE_OPERAND (*tp, 0);
+      return;
+    }
+
+  out_label = NULL;
+  for (i = tsi_start (TREE_OPERAND (*tp, 1)); !tsi_end_p (i); )
+    {
+      struct eh_region *catch_region;
+      tree catch, x, eh_label;
+
+      catch = tsi_stmt (i);
+      catch_region = gen_eh_region_catch (try_region, CATCH_TYPES (catch));
+
+      this_state.cur_region = catch_region;
+      this_state.prev_try = state->prev_try;
+      lower_eh_constructs_1 (&this_state, &CATCH_BODY (catch));
+
+      eh_label = create_artificial_label ();
+      set_eh_region_tree_label (catch_region, eh_label);
+
+      x = build1 (LABEL_EXPR, void_type_node, eh_label);
+      tsi_link_before (&i, x, TSI_SAME_STMT);
+
+      if (block_may_fallthru (CATCH_BODY (catch)))
+	{
+	  if (!out_label)
+	    out_label = create_artificial_label ();
+
+	  x = build1 (GOTO_EXPR, void_type_node, out_label);
+	  append_to_statement_list (x, &CATCH_BODY (catch));
+	}
+
+      tsi_link_before (&i, CATCH_BODY (catch), TSI_SAME_STMT);
+      tsi_delink (&i);
+    }
+
+  frob_into_branch_around (tp, NULL, out_label);
+}
+
+/* A subroutine of lower_eh_constructs_1.  Lower a TRY_CATCH_EXPR with a
+   EH_FILTER_EXPR to a sequence of labels and blocks, plus the exception
+   region trees that record all the magic.  */
+
+static void
+lower_eh_filter (struct leh_state *state, tree *tp)
+{
+  struct leh_state this_state;
+  struct eh_region *this_region;
+  tree inner = expr_first (TREE_OPERAND (*tp, 1));
+  tree eh_label;
+
+  if (EH_FILTER_MUST_NOT_THROW (inner))
+    this_region = gen_eh_region_must_not_throw (state->cur_region);
+  else
+    this_region = gen_eh_region_allowed (state->cur_region,
+					 EH_FILTER_TYPES (inner));
+  this_state = *state;
+  this_state.cur_region = this_region;
+  /* For must not throw regions any cleanup regions inside it
+     can't reach outer catch regions.  */
+  if (EH_FILTER_MUST_NOT_THROW (inner))
+    this_state.prev_try = NULL;
+
+  lower_eh_constructs_1 (&this_state, &TREE_OPERAND (*tp, 0));
+
+  if (!get_eh_region_may_contain_throw (this_region))
+    {
+      *tp = TREE_OPERAND (*tp, 0);
+      return;
+    }
+
+  lower_eh_constructs_1 (state, &EH_FILTER_FAILURE (inner));
+  TREE_OPERAND (*tp, 1) = EH_FILTER_FAILURE (inner);
+
+  eh_label = create_artificial_label ();
+  set_eh_region_tree_label (this_region, eh_label);
+
+  frob_into_branch_around (tp, eh_label, NULL);
+}
+
+/* Implement a cleanup expression.  This is similar to try-finally,
+   except that we only execute the cleanup block for exception edges.  */
+
+static void
+lower_cleanup (struct leh_state *state, tree *tp)
+{
+  struct leh_state this_state;
+  struct eh_region *this_region;
+  struct leh_tf_state fake_tf;
+
+  /* If not using eh, then exception-only cleanups are no-ops.  */
+  if (!flag_exceptions)
+    {
+      *tp = TREE_OPERAND (*tp, 0);
+      lower_eh_constructs_1 (state, tp);
+      return;
+    }
+
+  this_region = gen_eh_region_cleanup (state->cur_region, state->prev_try);
+  this_state = *state;
+  this_state.cur_region = this_region;
+
+  lower_eh_constructs_1 (&this_state, &TREE_OPERAND (*tp, 0));
+
+  if (!get_eh_region_may_contain_throw (this_region))
+    {
+      *tp = TREE_OPERAND (*tp, 0);
+      return;
+    }
+
+  /* Build enough of a try-finally state so that we can reuse
+     honor_protect_cleanup_actions.  */
+  memset (&fake_tf, 0, sizeof (fake_tf));
+  fake_tf.top_p = tp;
+  fake_tf.outer = state;
+  fake_tf.region = this_region;
+  fake_tf.may_fallthru = block_may_fallthru (TREE_OPERAND (*tp, 0));
+  fake_tf.may_throw = true;
+
+  fake_tf.eh_label = create_artificial_label ();
+  set_eh_region_tree_label (this_region, fake_tf.eh_label);
+
+  honor_protect_cleanup_actions (state, NULL, &fake_tf);
+
+  if (fake_tf.may_throw)
+    {
+      /* In this case honor_protect_cleanup_actions had nothing to do,
+	 and we should process this normally.  */
+      lower_eh_constructs_1 (state, &TREE_OPERAND (*tp, 1));
+      frob_into_branch_around (tp, fake_tf.eh_label, fake_tf.fallthru_label);
+    }
+  else
+    {
+      /* In this case honor_protect_cleanup_actions did nearly all of
+	 the work.  All we have left is to append the fallthru_label.  */
+
+      *tp = TREE_OPERAND (*tp, 0);
+      if (fake_tf.fallthru_label)
+	{
+	  tree x = build1 (LABEL_EXPR, void_type_node, fake_tf.fallthru_label);
+	  append_to_statement_list (x, tp);
+	}
+    }
+}
+
+/* Main loop for lowering eh constructs.  */
+
+static void
+lower_eh_constructs_1 (struct leh_state *state, tree *tp)
+{
+  tree_stmt_iterator i;
+  tree t = *tp;
+
+  switch (TREE_CODE (t))
+    {
+    case COND_EXPR:
+      lower_eh_constructs_1 (state, &COND_EXPR_THEN (t));
+      lower_eh_constructs_1 (state, &COND_EXPR_ELSE (t));
+      break;
+
+    case CALL_EXPR:
+      /* Look for things that can throw exceptions, and record them.  */
+      if (state->cur_region && tree_could_throw_p (t))
+	{
+	  record_stmt_eh_region (state->cur_region, t);
+	  note_eh_region_may_contain_throw (state->cur_region);
+	}
+      break;
+
+    case MODIFY_EXPR:
+      /* Look for things that can throw exceptions, and record them.  */
+      if (state->cur_region && tree_could_throw_p (t))
+	{
+	  record_stmt_eh_region (state->cur_region, t);
+	  note_eh_region_may_contain_throw (state->cur_region);
+	}
+      break;
+
+    case GOTO_EXPR:
+    case RETURN_EXPR:
+      maybe_record_in_goto_queue (state, t);
+      break;
+    case SWITCH_EXPR:
+      verify_norecord_switch_expr (state, t);
+      break;
+
+    case TRY_FINALLY_EXPR:
+      lower_try_finally (state, tp);
+      break;
+
+    case TRY_CATCH_EXPR:
+      i = tsi_start (TREE_OPERAND (t, 1));
+      switch (TREE_CODE (tsi_stmt (i)))
+	{
+	case CATCH_EXPR:
+	  lower_catch (state, tp);
+	  break;
+	case EH_FILTER_EXPR:
+	  lower_eh_filter (state, tp);
+	  break;
+	default:
+	  lower_cleanup (state, tp);
+	  break;
+	}
+      break;
+
+    case STATEMENT_LIST:
+      for (i = tsi_start (t); !tsi_end_p (i); )
+	{
+	  lower_eh_constructs_1 (state, tsi_stmt_ptr (i));
+	  t = tsi_stmt (i);
+	  if (TREE_CODE (t) == STATEMENT_LIST)
+	    {
+	      tsi_link_before (&i, t, TSI_SAME_STMT);
+	      tsi_delink (&i);
+	    }
+	  else
+	    tsi_next (&i);
+	}
+      break;
+
+    default:
+      /* A type, a decl, or some kind of statement that we're not
+	 interested in.  Don't walk them.  */
+      break;
+    }
+}
+
+static unsigned int
+lower_eh_constructs (void)
+{
+  struct leh_state null_state;
+  tree *tp = &DECL_SAVED_TREE (current_function_decl);
+
+  finally_tree = htab_create (31, struct_ptr_hash, struct_ptr_eq, free);
+
+  collect_finally_tree (*tp, NULL);
+
+  memset (&null_state, 0, sizeof (null_state));
+  lower_eh_constructs_1 (&null_state, tp);
+
+  htab_delete (finally_tree);
+
+  collect_eh_region_array ();
+  return 0;
+}
+
+struct tree_opt_pass pass_lower_eh =
+{
+  "eh",					/* name */
+  NULL,					/* gate */
+  lower_eh_constructs,			/* execute */
+  NULL,					/* sub */
+  NULL,					/* next */
+  0,					/* static_pass_number */
+  TV_TREE_EH,				/* tv_id */
+  PROP_gimple_lcf,			/* properties_required */
+  PROP_gimple_leh,			/* properties_provided */
+  0,					/* properties_destroyed */
+  0,					/* todo_flags_start */
+  TODO_dump_func,			/* todo_flags_finish */
+  0					/* letter */
+};
+
+
+/* Construct EH edges for STMT.  */
+
+static void
+make_eh_edge (struct eh_region *region, void *data)
+{
+  tree stmt, lab;
+  basic_block src, dst;
+
+  stmt = (tree) data;
+  lab = get_eh_region_tree_label (region);
+
+  src = bb_for_stmt (stmt);
+  dst = label_to_block (lab);
+
+  make_edge (src, dst, EDGE_ABNORMAL | EDGE_EH);
+}
+
+void
+make_eh_edges (tree stmt)
+{
+  int region_nr;
+  bool is_resx;
+
+  if (TREE_CODE (stmt) == RESX_EXPR)
+    {
+      region_nr = TREE_INT_CST_LOW (TREE_OPERAND (stmt, 0));
+      is_resx = true;
+    }
+  else
+    {
+      region_nr = lookup_stmt_eh_region (stmt);
+      if (region_nr < 0)
+	return;
+      is_resx = false;
+    }
+
+  foreach_reachable_handler (region_nr, is_resx, make_eh_edge, stmt);
+}
+
+static bool mark_eh_edge_found_error;
+
+/* Mark edge make_eh_edge would create for given region by setting it aux
+   field, output error if something goes wrong.  */
+static void
+mark_eh_edge (struct eh_region *region, void *data)
+{
+  tree stmt, lab;
+  basic_block src, dst;
+  edge e;
+
+  stmt = (tree) data;
+  lab = get_eh_region_tree_label (region);
+
+  src = bb_for_stmt (stmt);
+  dst = label_to_block (lab);
+
+  e = find_edge (src, dst);
+  if (!e)
+    {
+      error ("EH edge %i->%i is missing", src->index, dst->index);
+      mark_eh_edge_found_error = true;
+    }
+  else if (!(e->flags & EDGE_EH))
+    {
+      error ("EH edge %i->%i miss EH flag", src->index, dst->index);
+      mark_eh_edge_found_error = true;
+    }
+  else if (e->aux)
+    {
+      /* ??? might not be mistake.  */
+      error ("EH edge %i->%i has duplicated regions", src->index, dst->index);
+      mark_eh_edge_found_error = true;
+    }
+  else
+    e->aux = (void *)1;
+}
+
+/* Verify that BB containing stmt as last stmt has precisely the edges
+   make_eh_edges would create.  */
+bool
+verify_eh_edges (tree stmt)
+{
+  int region_nr;
+  bool is_resx;
+  basic_block bb = bb_for_stmt (stmt);
+  edge_iterator ei;
+  edge e;
+
+  FOR_EACH_EDGE (e, ei, bb->succs)
+    gcc_assert (!e->aux);
+  mark_eh_edge_found_error = false;
+  if (TREE_CODE (stmt) == RESX_EXPR)
+    {
+      region_nr = TREE_INT_CST_LOW (TREE_OPERAND (stmt, 0));
+      is_resx = true;
+    }
+  else
+    {
+      region_nr = lookup_stmt_eh_region (stmt);
+      if (region_nr < 0)
+	{
+	  FOR_EACH_EDGE (e, ei, bb->succs)
+	    if (e->flags & EDGE_EH)
+	      {
+		error ("BB %i can not throw but has EH edges", bb->index);
+		return true;
+	      }
+	   return false;
+	}
+      if (!tree_could_throw_p (stmt))
+	{
+	  error ("BB %i last statement has incorrectly set region", bb->index);
+	  return true;
+	}
+      is_resx = false;
+    }
+
+  foreach_reachable_handler (region_nr, is_resx, mark_eh_edge, stmt);
+  FOR_EACH_EDGE (e, ei, bb->succs)
+    {
+      if ((e->flags & EDGE_EH) && !e->aux)
+	{
+	  error ("unnecessary EH edge %i->%i", bb->index, e->dest->index);
+	  mark_eh_edge_found_error = true;
+	  return true;
+	}
+      e->aux = NULL;
+    }
+  return mark_eh_edge_found_error;
+}
+
+
+/* Return true if the expr can trap, as in dereferencing an invalid pointer
+   location or floating point arithmetic.  C.f. the rtl version, may_trap_p.
+   This routine expects only GIMPLE lhs or rhs input.  */
+
+bool
+tree_could_trap_p (tree expr)
+{
+  enum tree_code code = TREE_CODE (expr);
+  bool honor_nans = false;
+  bool honor_snans = false;
+  bool fp_operation = false;
+  bool honor_trapv = false;
+  tree t, base;
+
+  if (TREE_CODE_CLASS (code) == tcc_comparison
+      || TREE_CODE_CLASS (code) == tcc_unary
+      || TREE_CODE_CLASS (code) == tcc_binary)
+    {
+      t = TREE_TYPE (expr);
+      fp_operation = FLOAT_TYPE_P (t);
+      if (fp_operation)
+	{
+	  honor_nans = flag_trapping_math && !flag_finite_math_only;
+	  honor_snans = flag_signaling_nans != 0;
+	}
+      else if (INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t))
+	honor_trapv = true;
+    }
+
+ restart:
+  switch (code)
+    {
+    case TARGET_MEM_REF:
+      /* For TARGET_MEM_REFs use the information based on the original
+	 reference.  */
+      expr = TMR_ORIGINAL (expr);
+      code = TREE_CODE (expr);
+      goto restart;
+
+    case COMPONENT_REF:
+    case REALPART_EXPR:
+    case IMAGPART_EXPR:
+    case BIT_FIELD_REF:
+    case VIEW_CONVERT_EXPR:
+    case WITH_SIZE_EXPR:
+      expr = TREE_OPERAND (expr, 0);
+      code = TREE_CODE (expr);
+      goto restart;
+
+    case ARRAY_RANGE_REF:
+      base = TREE_OPERAND (expr, 0);
+      if (tree_could_trap_p (base))
+	return true;
+
+      if (TREE_THIS_NOTRAP (expr))
+	return false;
+
+      return !range_in_array_bounds_p (expr);
+
+    case ARRAY_REF:
+      base = TREE_OPERAND (expr, 0);
+      if (tree_could_trap_p (base))
+	return true;
+
+      if (TREE_THIS_NOTRAP (expr))
+	return false;
+
+      return !in_array_bounds_p (expr);
+
+    case INDIRECT_REF:
+    case ALIGN_INDIRECT_REF:
+    case MISALIGNED_INDIRECT_REF:
+      return !TREE_THIS_NOTRAP (expr);
+
+    case ASM_EXPR:
+      return TREE_THIS_VOLATILE (expr);
+
+    case TRUNC_DIV_EXPR:
+    case CEIL_DIV_EXPR:
+    case FLOOR_DIV_EXPR:
+    case ROUND_DIV_EXPR:
+    case EXACT_DIV_EXPR:
+    case CEIL_MOD_EXPR:
+    case FLOOR_MOD_EXPR:
+    case ROUND_MOD_EXPR:
+    case TRUNC_MOD_EXPR:
+    case RDIV_EXPR:
+      if (honor_snans || honor_trapv)
+	return true;
+      if (fp_operation)
+	return flag_trapping_math;
+      t = TREE_OPERAND (expr, 1);
+      if (!TREE_CONSTANT (t) || integer_zerop (t))
+        return true;
+      return false;
+
+    case LT_EXPR:
+    case LE_EXPR:
+    case GT_EXPR:
+    case GE_EXPR:
+    case LTGT_EXPR:
+      /* Some floating point comparisons may trap.  */
+      return honor_nans;
+
+    case EQ_EXPR:
+    case NE_EXPR:
+    case UNORDERED_EXPR:
+    case ORDERED_EXPR:
+    case UNLT_EXPR:
+    case UNLE_EXPR:
+    case UNGT_EXPR:
+    case UNGE_EXPR:
+    case UNEQ_EXPR:
+      return honor_snans;
+
+    case CONVERT_EXPR:
+    case FIX_TRUNC_EXPR:
+    case FIX_CEIL_EXPR:
+    case FIX_FLOOR_EXPR:
+    case FIX_ROUND_EXPR:
+      /* Conversion of floating point might trap.  */
+      return honor_nans;
+
+    case NEGATE_EXPR:
+    case ABS_EXPR:
+    case CONJ_EXPR:
+      /* These operations don't trap with floating point.  */
+      if (honor_trapv)
+	return true;
+      return false;
+
+    case PLUS_EXPR:
+    case MINUS_EXPR:
+    case MULT_EXPR:
+      /* Any floating arithmetic may trap.  */
+      if (fp_operation && flag_trapping_math)
+	return true;
+      if (honor_trapv)
+	return true;
+      return false;
+
+    case CALL_EXPR:
+      t = get_callee_fndecl (expr);
+      /* Assume that calls to weak functions may trap.  */
+      if (!t || !DECL_P (t) || DECL_WEAK (t))
+	return true;
+      return false;
+
+    default:
+      /* Any floating arithmetic may trap.  */
+      if (fp_operation && flag_trapping_math)
+	return true;
+      return false;
+    }
+}
+
+bool
+tree_could_throw_p (tree t)
+{
+  if (!flag_exceptions)
+    return false;
+  if (TREE_CODE (t) == MODIFY_EXPR)
+    {
+      if (flag_non_call_exceptions
+	  && tree_could_trap_p (TREE_OPERAND (t, 0)))
+	return true;
+      t = TREE_OPERAND (t, 1);
+    }
+
+  if (TREE_CODE (t) == WITH_SIZE_EXPR)
+    t = TREE_OPERAND (t, 0);
+  if (TREE_CODE (t) == CALL_EXPR)
+    return (call_expr_flags (t) & ECF_NOTHROW) == 0;
+  if (flag_non_call_exceptions)
+    return tree_could_trap_p (t);
+  return false;
+}
+
+bool
+tree_can_throw_internal (tree stmt)
+{
+  int region_nr;
+  bool is_resx = false;
+
+  if (TREE_CODE (stmt) == RESX_EXPR)
+    region_nr = TREE_INT_CST_LOW (TREE_OPERAND (stmt, 0)), is_resx = true;
+  else
+    region_nr = lookup_stmt_eh_region (stmt);
+  if (region_nr < 0)
+    return false;
+  return can_throw_internal_1 (region_nr, is_resx);
+}
+
+bool
+tree_can_throw_external (tree stmt)
+{
+  int region_nr;
+  bool is_resx = false;
+
+  if (TREE_CODE (stmt) == RESX_EXPR)
+    region_nr = TREE_INT_CST_LOW (TREE_OPERAND (stmt, 0)), is_resx = true;
+  else
+    region_nr = lookup_stmt_eh_region (stmt);
+  if (region_nr < 0)
+    return tree_could_throw_p (stmt);
+  else
+    return can_throw_external_1 (region_nr, is_resx);
+}
+
+/* Given a statement OLD_STMT and a new statement NEW_STMT that has replaced
+   OLD_STMT in the function, remove OLD_STMT from the EH table and put NEW_STMT
+   in the table if it should be in there.  Return TRUE if a replacement was
+   done that my require an EH edge purge.  */
+
+bool 
+maybe_clean_or_replace_eh_stmt (tree old_stmt, tree new_stmt) 
+{
+  int region_nr = lookup_stmt_eh_region (old_stmt);
+
+  if (region_nr >= 0)
+    {
+      bool new_stmt_could_throw = tree_could_throw_p (new_stmt);
+
+      if (new_stmt == old_stmt && new_stmt_could_throw)
+	return false;
+
+      remove_stmt_from_eh_region (old_stmt);
+      if (new_stmt_could_throw)
+	{
+	  add_stmt_to_eh_region (new_stmt, region_nr);
+	  return false;
+	}
+      else
+	return true;
+    }
+
+  return false;
+}
+
+#ifdef ENABLE_CHECKING
+static int
+verify_eh_throw_stmt_node (void **slot, void *data ATTRIBUTE_UNUSED)
+{
+  struct throw_stmt_node *node = (struct throw_stmt_node *)*slot;
+
+  gcc_assert (node->stmt->common.ann == NULL);
+  return 1;
+}
+
+void
+verify_eh_throw_table_statements (void)
+{
+  if (!get_eh_throw_stmt_table (cfun))
+    return;
+  htab_traverse (get_eh_throw_stmt_table (cfun),
+		 verify_eh_throw_stmt_node,
+		 NULL);
+}
+
+#endif