X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fexcept.c;h=f8bacd5902bcd36cc92ee65c13e99014268cfc62;hb=498b39713afcac3f7e60903fdaca81a2ff0bbb96;hp=0ace54d872e79380f0dc46bb589cb5f541861e11;hpb=2f14b1f9d493c8f64d5ff6b284bfe91ad8433d37;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/except.c b/gcc/except.c
index 0ace54d872e..f8bacd5902b 100644
--- a/gcc/except.c
+++ b/gcc/except.c
@@ -1,13 +1,14 @@
 /* Implements exception handling.
    Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   Free Software Foundation, Inc.
    Contributed by Mike Stump <mrs@cygnus.com>.
 
 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
+Software Foundation; either version 3, or (at your option) any later
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
@@ -16,9 +17,8 @@ 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.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 
 /* An exception is an event that can be signaled from within a
@@ -84,7 +84,6 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
 #endif
 
-
 /* Protect cleanup actions with must-not-throw regions, with a call
    to the given failure handler.  */
 tree (*lang_protect_cleanup_actions) (void);
@@ -134,7 +133,7 @@ struct eh_region GTY(())
 
   /* Each region does exactly one thing.  */
   enum eh_region_type
-  { 
+  {
     ERT_UNKNOWN = 0,
     ERT_CLEANUP,
     ERT_TRY,
@@ -218,40 +217,10 @@ struct eh_status GTY(())
 
   /* The same information as an indexable array.  */
   VEC(eh_region,gc) *region_array;
-
-  /* The most recently open region.  */
-  struct eh_region *cur_region;
-
-  /* This is the region for which we are processing catch blocks.  */
-  struct eh_region *try_region;
-
-  rtx filter;
-  rtx exc_ptr;
-
-  int built_landing_pads;
   int last_region_number;
 
-  VEC(tree,gc) *ttype_data;
-  varray_type ehspec_data;
-  varray_type action_record_data;
-
-  htab_t GTY ((param_is (struct ehl_map_entry))) exception_handler_label_map;
-
-  struct call_site_record * GTY ((length ("%h.call_site_data_used")))
-    call_site_data;
-  int call_site_data_used;
-  int call_site_data_size;
-
-  rtx ehr_stackadj;
-  rtx ehr_handler;
-  rtx ehr_label;
-
-  rtx sjlj_fc;
-  rtx sjlj_exit_after;
-
   htab_t GTY((param_is (struct throw_stmt_node))) throw_stmt_table;
 };
-
 
 static int t2r_eq (const void *, const void *);
 static hashval_t t2r_hash (const void *);
@@ -442,7 +411,7 @@ init_eh_for_function (void)
   cfun->eh = ggc_alloc_cleared (sizeof (struct eh_status));
 }
 
-/* Routines to generate the exception tree somewhat directly.  
+/* Routines to generate the exception tree somewhat directly.
    These are used from tree-eh.c when processing exception related
    nodes during tree optimization.  */
 
@@ -588,41 +557,27 @@ note_eh_region_may_contain_throw (struct eh_region *region)
     }
 }
 
-void
-note_current_region_may_contain_throw (void)
-{
-  note_eh_region_may_contain_throw (cfun->eh->cur_region);
-}
-
 
 /* Return an rtl expression for a pointer to the exception object
    within a handler.  */
 
 rtx
-get_exception_pointer (struct function *fun)
+get_exception_pointer (void)
 {
-  rtx exc_ptr = fun->eh->exc_ptr;
-  if (fun == cfun && ! exc_ptr)
-    {
-      exc_ptr = gen_reg_rtx (ptr_mode);
-      fun->eh->exc_ptr = exc_ptr;
-    }
-  return exc_ptr;
+  if (! crtl->eh.exc_ptr)
+    crtl->eh.exc_ptr = gen_reg_rtx (ptr_mode);
+  return crtl->eh.exc_ptr;
 }
 
 /* Return an rtl expression for the exception dispatch filter
    within a handler.  */
 
 rtx
-get_exception_filter (struct function *fun)
+get_exception_filter (void)
 {
-  rtx filter = fun->eh->filter;
-  if (fun == cfun && ! filter)
-    {
-      filter = gen_reg_rtx (targetm.eh_return_filter_mode ());
-      fun->eh->filter = filter;
-    }
-  return filter;
+  if (! crtl->eh.filter)
+    crtl->eh.filter = gen_reg_rtx (targetm.eh_return_filter_mode ());
+  return crtl->eh.filter;
 }
 
 /* This section is for the exception handling specific optimization pass.  */
@@ -738,7 +693,7 @@ remove_unreachable_regions (rtx insns)
 	    default:
 	      break;
 	    }
-	      
+
 	  if (kill_it)
 	    remove_eh_handler (r);
 	}
@@ -784,13 +739,13 @@ add_ehl_entry (rtx label, struct eh_region *region)
   entry->region = region;
 
   slot = (struct ehl_map_entry **)
-    htab_find_slot (cfun->eh->exception_handler_label_map, entry, INSERT);
+    htab_find_slot (crtl->eh.exception_handler_label_map, entry, INSERT);
 
   /* Before landing pad creation, each exception handler has its own
      label.  After landing pad creation, the exception handlers may
      share landing pads.  This is ok, since maybe_remove_eh_handler
      only requires the 1-1 mapping before landing pad creation.  */
-  gcc_assert (!*slot || cfun->eh->built_landing_pads);
+  gcc_assert (!*slot || crtl->eh.built_landing_pads);
 
   *slot = entry;
 }
@@ -800,13 +755,13 @@ find_exception_handler_labels (void)
 {
   int i;
 
-  if (cfun->eh->exception_handler_label_map)
-    htab_empty (cfun->eh->exception_handler_label_map);
+  if (crtl->eh.exception_handler_label_map)
+    htab_empty (crtl->eh.exception_handler_label_map);
   else
     {
       /* ??? The expansion factor here (3/2) must be greater than the htab
 	 occupancy factor (4/3) to avoid unnecessary resizing.  */
-      cfun->eh->exception_handler_label_map
+      crtl->eh.exception_handler_label_map
         = htab_create_ggc (cfun->eh->last_region_number * 3 / 2,
 			   ehl_hash, ehl_eq, NULL);
     }
@@ -822,7 +777,7 @@ find_exception_handler_labels (void)
       region = VEC_index (eh_region, cfun->eh->region_array, i);
       if (! region || region->region_number != i)
 	continue;
-      if (cfun->eh->built_landing_pads)
+      if (crtl->eh.built_landing_pads)
 	lab = region->landing_pad;
       else
 	lab = region->label;
@@ -833,7 +788,7 @@ find_exception_handler_labels (void)
 
   /* For sjlj exceptions, need the return label to remain live until
      after landing pad generation.  */
-  if (USING_SJLJ_EXCEPTIONS && ! cfun->eh->built_landing_pads)
+  if (USING_SJLJ_EXCEPTIONS && ! crtl->eh.built_landing_pads)
     add_ehl_entry (return_label, NULL);
 }
 
@@ -858,85 +813,147 @@ current_function_has_exception_handlers (void)
   return false;
 }
 
-static struct eh_region *
-duplicate_eh_region_1 (struct eh_region *o)
+/* A subroutine of duplicate_eh_regions.  Search the region tree under O
+   for the minimum and maximum region numbers.  Update *MIN and *MAX.  */
+
+static void
+duplicate_eh_regions_0 (eh_region o, int *min, int *max)
 {
-  struct eh_region *n = ggc_alloc_cleared (sizeof (struct eh_region));
+  if (o->region_number < *min)
+    *min = o->region_number;
+  if (o->region_number > *max)
+    *max = o->region_number;
 
-  *n = *o;
-  
-  n->region_number = o->region_number + cfun->eh->last_region_number;
-  VEC_replace (eh_region, cfun->eh->region_array, n->region_number, n);
-  gcc_assert (!o->aka);
-  
-  return n;
+  if (o->inner)
+    {
+      o = o->inner;
+      duplicate_eh_regions_0 (o, min, max);
+      while (o->next_peer)
+	{
+	  o = o->next_peer;
+	  duplicate_eh_regions_0 (o, min, max);
+	}
+    }
 }
 
-static void
-duplicate_eh_region_2 (struct eh_region *o, struct eh_region **n_array,
-		       struct eh_region *prev_try)
+/* A subroutine of duplicate_eh_regions.  Copy the region tree under OLD.
+   Root it at OUTER, and apply EH_OFFSET to the region number.  Don't worry
+   about the other internal pointers just yet, just the tree-like pointers.  */
+
+static eh_region
+duplicate_eh_regions_1 (eh_region old, eh_region outer, int eh_offset)
 {
-  struct eh_region *n = n_array[o->region_number];
-  
-  switch (n->type)
-    {
-    case ERT_TRY:
-      if (o->u.try.catch)
-        n->u.try.catch = n_array[o->u.try.catch->region_number];
-      if (o->u.try.last_catch)
-        n->u.try.last_catch = n_array[o->u.try.last_catch->region_number];
-      break;
-      
-    case ERT_CATCH:
-      if (o->u.catch.next_catch)
-	n->u.catch.next_catch = n_array[o->u.catch.next_catch->region_number];
-      if (o->u.catch.prev_catch)
-	n->u.catch.prev_catch = n_array[o->u.catch.prev_catch->region_number];
-      break;
+  eh_region ret, n;
 
-    case ERT_CLEANUP:
-      if (o->u.cleanup.prev_try)
-	n->u.cleanup.prev_try = n_array[o->u.cleanup.prev_try->region_number];
-      else
-        n->u.cleanup.prev_try = prev_try;
-      break;
-      
-    default:
-      break;
+  ret = n = ggc_alloc (sizeof (struct eh_region));
+
+  *n = *old;
+  n->outer = outer;
+  n->next_peer = NULL;
+  gcc_assert (!old->aka);
+
+  n->region_number += eh_offset;
+  VEC_replace (eh_region, cfun->eh->region_array, n->region_number, n);
+
+  if (old->inner)
+    {
+      old = old->inner;
+      n = n->inner = duplicate_eh_regions_1 (old, ret, eh_offset);
+      while (old->next_peer)
+	{
+	  old = old->next_peer;
+	  n = n->next_peer = duplicate_eh_regions_1 (old, ret, eh_offset);
+	}
     }
-  
-  if (o->outer)
-    n->outer = n_array[o->outer->region_number];
-  if (o->inner)
-    n->inner = n_array[o->inner->region_number];
-  if (o->next_peer)
-    n->next_peer = n_array[o->next_peer->region_number];
+
+  return ret;
 }
 
-/* Duplicate the EH regions of IFUN into current function, root the tree in
-   OUTER_REGION and remap labels using MAP callback.  */
+/* Duplicate the EH regions of IFUN, rooted at COPY_REGION, into current
+   function and root the tree below OUTER_REGION.  Remap labels using MAP
+   callback.  The special case of COPY_REGION of 0 means all regions.  */
+
 int
 duplicate_eh_regions (struct function *ifun, duplicate_eh_regions_map map,
-		      void *data, int outer_region)
+		      void *data, int copy_region, int outer_region)
 {
-  int ifun_last_region_number = ifun->eh->last_region_number;
-  struct eh_region **n_array, *root, *cur, *prev_try;
-  int i;
-  
-  if (ifun_last_region_number == 0 || !ifun->eh->region_tree)
+  eh_region cur, prev_try, outer, *splice;
+  int i, min_region, max_region, eh_offset, cfun_last_region_number;
+  int num_regions;
+
+  if (!ifun->eh->region_tree)
     return 0;
-  
-  n_array = xcalloc (ifun_last_region_number + 1, sizeof (*n_array));
+
+  /* Find the range of region numbers to be copied.  The interface we 
+     provide here mandates a single offset to find new number from old,
+     which means we must look at the numbers present, instead of the
+     count or something else.  */
+  if (copy_region > 0)
+    {
+      min_region = INT_MAX;
+      max_region = 0;
+
+      cur = VEC_index (eh_region, ifun->eh->region_array, copy_region);
+      duplicate_eh_regions_0 (cur, &min_region, &max_region);
+    }
+  else
+    min_region = 1, max_region = ifun->eh->last_region_number;
+  num_regions = max_region - min_region + 1;
+  cfun_last_region_number = cfun->eh->last_region_number;
+  eh_offset = cfun_last_region_number + 1 - min_region;
+
+  /* If we've not yet created a region array, do so now.  */
   VEC_safe_grow (eh_region, gc, cfun->eh->region_array,
-		 cfun->eh->last_region_number + 1 + ifun_last_region_number);
+		 cfun_last_region_number + 1 + num_regions);
+  cfun->eh->last_region_number = max_region + eh_offset;
 
-  /* We might've created new cfun->eh->region_array so zero out nonexisting region 0.  */
+  /* We may have just allocated the array for the first time.
+     Make sure that element zero is null.  */
   VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
 
-  for (i = cfun->eh->last_region_number + 1;
-       i < cfun->eh->last_region_number + 1 + ifun_last_region_number; i++)
-    VEC_replace (eh_region, cfun->eh->region_array, i, 0);
-    
+  /* Zero all entries in the range allocated.  */
+  memset (VEC_address (eh_region, cfun->eh->region_array)
+	  + cfun_last_region_number + 1, 0, num_regions * sizeof (eh_region));
+
+  /* Locate the spot at which to insert the new tree.  */
+  if (outer_region > 0)
+    {
+      outer = VEC_index (eh_region, cfun->eh->region_array, outer_region);
+      splice = &outer->inner;
+    }
+  else
+    {
+      outer = NULL;
+      splice = &cfun->eh->region_tree;
+    }
+  while (*splice)
+    splice = &(*splice)->next_peer;
+
+  /* Copy all the regions in the subtree.  */
+  if (copy_region > 0)
+    {
+      cur = VEC_index (eh_region, ifun->eh->region_array, copy_region);
+      *splice = duplicate_eh_regions_1 (cur, outer, eh_offset);
+    }
+  else
+    {
+      eh_region n;
+
+      cur = ifun->eh->region_tree;
+      *splice = n = duplicate_eh_regions_1 (cur, outer, eh_offset);
+      while (cur->next_peer)
+	{
+	  cur = cur->next_peer;
+	  n = n->next_peer = duplicate_eh_regions_1 (cur, outer, eh_offset);
+	}
+    }
+
+  /* Remap all the labels in the new regions.  */
+  for (i = cfun_last_region_number + 1;
+       VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i)
+    if (cur && cur->tree_label)
+      cur->tree_label = map (cur->tree_label, data);
+
   /* Search for the containing ERT_TRY region to fix up
      the prev_try short-cuts for ERT_CLEANUP regions.  */
   prev_try = NULL;
@@ -944,76 +961,134 @@ duplicate_eh_regions (struct function *ifun, duplicate_eh_regions_map map,
     for (prev_try = VEC_index (eh_region, cfun->eh->region_array, outer_region);
          prev_try && prev_try->type != ERT_TRY;
 	 prev_try = prev_try->outer)
-      ;
+      if (prev_try->type == ERT_MUST_NOT_THROW
+	  || (prev_try->type == ERT_ALLOWED_EXCEPTIONS
+	      && !prev_try->u.allowed.type_list))
+	{
+	  prev_try = NULL;
+	  break;
+	}
 
-  for (i = 1; i <= ifun_last_region_number; ++i)
+  /* Remap all of the internal catch and cleanup linkages.  Since we 
+     duplicate entire subtrees, all of the referenced regions will have
+     been copied too.  And since we renumbered them as a block, a simple
+     bit of arithmetic finds us the index for the replacement region.  */
+  for (i = cfun_last_region_number + 1;
+       VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i)
     {
-      cur = VEC_index (eh_region, ifun->eh->region_array, i);
-      if (!cur || cur->region_number != i)
+      if (cur == NULL)
 	continue;
-      n_array[i] = duplicate_eh_region_1 (cur);
-      if (cur->tree_label)
+
+#define REMAP(REG) \
+	(REG) = VEC_index (eh_region, cfun->eh->region_array, \
+			   (REG)->region_number + eh_offset)
+
+      switch (cur->type)
 	{
-	  tree newlabel = map (cur->tree_label, data);
-	  n_array[i]->tree_label = newlabel;
+	case ERT_TRY:
+	  if (cur->u.try.catch)
+	    REMAP (cur->u.try.catch);
+	  if (cur->u.try.last_catch)
+	    REMAP (cur->u.try.last_catch);
+	  break;
+
+	case ERT_CATCH:
+	  if (cur->u.catch.next_catch)
+	    REMAP (cur->u.catch.next_catch);
+	  if (cur->u.catch.prev_catch)
+	    REMAP (cur->u.catch.prev_catch);
+	  break;
+
+	case ERT_CLEANUP:
+	  if (cur->u.cleanup.prev_try)
+	    REMAP (cur->u.cleanup.prev_try);
+	  else
+	    cur->u.cleanup.prev_try = prev_try;
+	  break;
+
+	default:
+	  break;
 	}
-      else
-	n_array[i]->tree_label = NULL;
+
+#undef REMAP
     }
-  for (i = 1; i <= ifun_last_region_number; ++i)
+
+  return eh_offset;
+}
+
+/* Return true if REGION_A is outer to REGION_B in IFUN.  */
+
+bool
+eh_region_outer_p (struct function *ifun, int region_a, int region_b)
+{
+  struct eh_region *rp_a, *rp_b;
+
+  gcc_assert (ifun->eh->last_region_number > 0);
+  gcc_assert (ifun->eh->region_tree);
+
+  rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a);
+  rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b);
+  gcc_assert (rp_a != NULL);
+  gcc_assert (rp_b != NULL);
+
+  do
     {
-      cur = VEC_index (eh_region, ifun->eh->region_array, i);
-      if (!cur || cur->region_number != i)
-	continue;
-      duplicate_eh_region_2 (cur, n_array, prev_try);
+      if (rp_a == rp_b)
+	return true;
+      rp_b = rp_b->outer;
     }
-  
-  root = n_array[ifun->eh->region_tree->region_number];
-  gcc_assert (root->outer == NULL);
-  if (outer_region > 0)
-    {
-      struct eh_region *cur
-         = VEC_index (eh_region, cfun->eh->region_array, outer_region);
-      struct eh_region *p = cur->inner;
+  while (rp_b);
 
-      if (p)
-	{
-	  while (p->next_peer)
-	    p = p->next_peer;
-	  p->next_peer = root;
-	}
-      else
-        cur->inner = root;
-      for (i = 1; i <= ifun_last_region_number; ++i)
-	if (n_array[i] && n_array[i]->outer == NULL)
-	  n_array[i]->outer = cur;
+  return false;
+}
+
+/* Return region number of region that is outer to both if REGION_A and
+   REGION_B in IFUN.  */
+
+int
+eh_region_outermost (struct function *ifun, int region_a, int region_b)
+{
+  struct eh_region *rp_a, *rp_b;
+  sbitmap b_outer;
+
+  gcc_assert (ifun->eh->last_region_number > 0);
+  gcc_assert (ifun->eh->region_tree);
+
+  rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a);
+  rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b);
+  gcc_assert (rp_a != NULL);
+  gcc_assert (rp_b != NULL);
+
+  b_outer = sbitmap_alloc (ifun->eh->last_region_number + 1);
+  sbitmap_zero (b_outer);
+
+  do
+    {
+      SET_BIT (b_outer, rp_b->region_number);
+      rp_b = rp_b->outer;
     }
-  else
+  while (rp_b);
+
+  do
     {
-      struct eh_region *p = cfun->eh->region_tree;
-      if (p)
+      if (TEST_BIT (b_outer, rp_a->region_number))
 	{
-	  while (p->next_peer)
-	    p = p->next_peer;
-	  p->next_peer = root;
+	  sbitmap_free (b_outer);
+	  return rp_a->region_number;
 	}
-      else
-        cfun->eh->region_tree = root;
+      rp_a = rp_a->outer;
     }
-  
-  free (n_array);
-  
-  i = cfun->eh->last_region_number;
-  cfun->eh->last_region_number = i + ifun_last_region_number;
-  
-  return i;
+  while (rp_a);
+
+  sbitmap_free (b_outer);
+  return -1;
 }
 
 static int
 t2r_eq (const void *pentry, const void *pdata)
 {
-  tree entry = (tree) pentry;
-  tree data = (tree) pdata;
+  const_tree const entry = (const_tree) pentry;
+  const_tree const data = (const_tree) pdata;
 
   return TREE_PURPOSE (entry) == data;
 }
@@ -1021,7 +1096,7 @@ t2r_eq (const void *pentry, const void *pdata)
 static hashval_t
 t2r_hash (const void *pentry)
 {
-  tree entry = (tree) pentry;
+  const_tree const entry = (const_tree) pentry;
   return TREE_HASH (TREE_PURPOSE (entry));
 }
 
@@ -1066,8 +1141,9 @@ struct ttypes_filter GTY(())
 static int
 ttypes_filter_eq (const void *pentry, const void *pdata)
 {
-  const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
-  tree data = (tree) pdata;
+  const struct ttypes_filter *const entry
+    = (const struct ttypes_filter *) pentry;
+  const_tree const data = (const_tree) pdata;
 
   return entry->t == data;
 }
@@ -1107,7 +1183,7 @@ ehspec_filter_hash (const void *pentry)
   return h;
 }
 
-/* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
+/* Add TYPE (which may be NULL) to crtl->eh.ttype_data, using TYPES_HASH
    to speed up the search.  Return the filter value to be used.  */
 
 static int
@@ -1122,18 +1198,18 @@ add_ttypes_entry (htab_t ttypes_hash, tree type)
     {
       /* Filter value is a 1 based table index.  */
 
-      n = xmalloc (sizeof (*n));
+      n = XNEW (struct ttypes_filter);
       n->t = type;
-      n->filter = VEC_length (tree, cfun->eh->ttype_data) + 1;
+      n->filter = VEC_length (tree, crtl->eh.ttype_data) + 1;
       *slot = n;
 
-      VEC_safe_push (tree, gc, cfun->eh->ttype_data, type);
+      VEC_safe_push (tree, gc, crtl->eh.ttype_data, type);
     }
 
   return n->filter;
 }
 
-/* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
+/* Add LIST to crtl->eh.ehspec_data, using EHSPEC_HASH and TYPES_HASH
    to speed up the search.  Return the filter value to be used.  */
 
 static int
@@ -1150,28 +1226,28 @@ add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list)
     {
       /* Filter value is a -1 based byte index into a uleb128 buffer.  */
 
-      n = xmalloc (sizeof (*n));
+      n = XNEW (struct ttypes_filter);
       n->t = list;
-      n->filter = -(VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) + 1);
+      n->filter = -(VARRAY_ACTIVE_SIZE (crtl->eh.ehspec_data) + 1);
       *slot = n;
 
       /* Generate a 0 terminated list of filter values.  */
       for (; list ; list = TREE_CHAIN (list))
 	{
 	  if (targetm.arm_eabi_unwinder)
-	    VARRAY_PUSH_TREE (cfun->eh->ehspec_data, TREE_VALUE (list));
+	    VARRAY_PUSH_TREE (crtl->eh.ehspec_data, TREE_VALUE (list));
 	  else
 	    {
 	      /* Look up each type in the list and encode its filter
 		 value as a uleb128.  */
-	      push_uleb128 (&cfun->eh->ehspec_data,
+	      push_uleb128 (&crtl->eh.ehspec_data,
 		  add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
 	    }
 	}
       if (targetm.arm_eabi_unwinder)
-	VARRAY_PUSH_TREE (cfun->eh->ehspec_data, NULL_TREE);
+	VARRAY_PUSH_TREE (crtl->eh.ehspec_data, NULL_TREE);
       else
-	VARRAY_PUSH_UCHAR (cfun->eh->ehspec_data, 0);
+	VARRAY_PUSH_UCHAR (crtl->eh.ehspec_data, 0);
     }
 
   return n->filter;
@@ -1188,11 +1264,11 @@ assign_filter_values (void)
   int i;
   htab_t ttypes, ehspec;
 
-  cfun->eh->ttype_data = VEC_alloc (tree, gc, 16);
+  crtl->eh.ttype_data = VEC_alloc (tree, gc, 16);
   if (targetm.arm_eabi_unwinder)
-    VARRAY_TREE_INIT (cfun->eh->ehspec_data, 64, "ehspec_data");
+    VARRAY_TREE_INIT (crtl->eh.ehspec_data, 64, "ehspec_data");
   else
-    VARRAY_UCHAR_INIT (cfun->eh->ehspec_data, 64, "ehspec_data");
+    VARRAY_UCHAR_INIT (crtl->eh.ehspec_data, 64, "ehspec_data");
 
   ttypes = htab_create (31, ttypes_filter_hash, ttypes_filter_eq, free);
   ehspec = htab_create (31, ehspec_filter_hash, ehspec_filter_eq, free);
@@ -1268,7 +1344,7 @@ emit_to_new_bb_before (rtx seq, rtx insn)
   edge_iterator ei;
 
   /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
-     call), we don't want it to go into newly created landing pad or other EH 
+     call), we don't want it to go into newly created landing pad or other EH
      construct.  */
   for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); )
     if (e->flags & EDGE_FALLTHRU)
@@ -1337,9 +1413,9 @@ build_post_landing_pads (void)
 		    for (; tp_node; )
 		      {
 			emit_cmp_and_jump_insns
-			  (cfun->eh->filter,
+			  (crtl->eh.filter,
 			   GEN_INT (tree_low_cst (TREE_VALUE (flt_node), 0)),
-			   EQ, NULL_RTX, 
+			   EQ, NULL_RTX,
 			   targetm.eh_return_filter_mode (), 0, c->label);
 
 			tp_node = TREE_CHAIN (tp_node);
@@ -1370,9 +1446,9 @@ build_post_landing_pads (void)
 
 	  emit_label (region->post_landing_pad);
 
-	  emit_cmp_and_jump_insns (cfun->eh->filter,
+	  emit_cmp_and_jump_insns (crtl->eh.filter,
 				   GEN_INT (region->u.allowed.filter),
-				   EQ, NULL_RTX, 
+				   EQ, NULL_RTX,
 				   targetm.eh_return_filter_mode (), 0, region->label);
 
 	  /* We delay the generation of the _Unwind_Resume until we generate
@@ -1453,7 +1529,7 @@ connect_post_landing_pads (void)
       else
 	{
 	  emit_library_call (unwind_resume_libfunc, LCT_THROW,
-			     VOIDmode, 1, cfun->eh->exc_ptr, ptr_mode);
+			     VOIDmode, 1, crtl->eh.exc_ptr, ptr_mode);
 
 	  /* What we just emitted was a throwing libcall, so it got a
 	     barrier automatically added after it.  If the last insn in
@@ -1488,14 +1564,12 @@ static void
 dw2_build_landing_pads (void)
 {
   int i;
-  unsigned int j;
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
       struct eh_region *region;
       rtx seq;
       basic_block bb;
-      bool clobbers_hard_regs = false;
       edge e;
 
       region = VEC_index (eh_region, cfun->eh->region_array, i);
@@ -1525,34 +1599,10 @@ dw2_build_landing_pads (void)
 #endif
 	  { /* Nothing */ }
 
-      /* If the eh_return data registers are call-saved, then we
-	 won't have considered them clobbered from the call that
-	 threw.  Kill them now.  */
-      for (j = 0; ; ++j)
-	{
-	  unsigned r = EH_RETURN_DATA_REGNO (j);
-	  if (r == INVALID_REGNUM)
-	    break;
-	  if (! call_used_regs[r])
-	    {
-	      emit_insn (gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, r)));
-	      clobbers_hard_regs = true;
-	    }
-	}
-
-      if (clobbers_hard_regs)
-	{
-	  /* @@@ This is a kludge.  Not all machine descriptions define a
-	     blockage insn, but we must not allow the code we just generated
-	     to be reordered by scheduling.  So emit an ASM_INPUT to act as
-	     blockage insn.  */
-	  emit_insn (gen_rtx_ASM_INPUT (VOIDmode, ""));
-	}
-
-      emit_move_insn (cfun->eh->exc_ptr,
+      emit_move_insn (crtl->eh.exc_ptr,
 		      gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
-      emit_move_insn (cfun->eh->filter,
-		      gen_rtx_REG (targetm.eh_return_filter_mode (), 
+      emit_move_insn (crtl->eh.filter,
+		      gen_rtx_REG (targetm.eh_return_filter_mode (),
 				   EH_RETURN_DATA_REGNO (1)));
 
       seq = get_insns ();
@@ -1630,7 +1680,7 @@ sjlj_assign_call_site_values (rtx dispatch_label, struct sjlj_lp_info *lp_info)
 
   /* First task: build the action table.  */
 
-  VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data");
+  VARRAY_UCHAR_INIT (crtl->eh.action_record_data, 64, "action_record_data");
   ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
@@ -1641,7 +1691,7 @@ sjlj_assign_call_site_values (rtx dispatch_label, struct sjlj_lp_info *lp_info)
 	r->landing_pad = dispatch_label;
 	lp_info[i].action_index = collect_one_action_chain (ar_hash, r);
 	if (lp_info[i].action_index != -1)
-	  cfun->uses_eh_lsda = 1;
+	  crtl->uses_eh_lsda = 1;
       }
 
   htab_delete (ar_hash);
@@ -1736,7 +1786,7 @@ sjlj_mark_call_sites (struct sjlj_lp_info *lp_info)
 	before = find_first_parameter_load (insn, NULL_RTX);
 
       start_sequence ();
-      mem = adjust_address (cfun->eh->sjlj_fc, TYPE_MODE (integer_type_node),
+      mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node),
 			    sjlj_fc_call_site_ofs);
       emit_move_insn (mem, GEN_INT (this_call_site));
       p = get_insns ();
@@ -1755,7 +1805,7 @@ sjlj_emit_function_enter (rtx dispatch_label)
   rtx fn_begin, fc, mem, seq;
   bool fn_begin_outside_block;
 
-  fc = cfun->eh->sjlj_fc;
+  fc = crtl->eh.sjlj_fc;
 
   start_sequence ();
 
@@ -1767,7 +1817,7 @@ sjlj_emit_function_enter (rtx dispatch_label)
   emit_move_insn (mem, eh_personality_libfunc);
 
   mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
-  if (cfun->uses_eh_lsda)
+  if (crtl->uses_eh_lsda)
     {
       char buf[20];
       rtx sym;
@@ -1782,17 +1832,15 @@ sjlj_emit_function_enter (rtx dispatch_label)
 
 #ifdef DONT_USE_BUILTIN_SETJMP
   {
-    rtx x, note;
+    rtx x;
     x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE,
 				 TYPE_MODE (integer_type_node), 1,
 				 plus_constant (XEXP (fc, 0),
 						sjlj_fc_jbuf_ofs), Pmode);
 
-    note = emit_note (NOTE_INSN_EXPECTED_VALUE);
-    NOTE_EXPECTED_VALUE (note) = gen_rtx_EQ (VOIDmode, x, const0_rtx);
-
     emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
 			     TYPE_MODE (integer_type_node), 0, dispatch_label);
+    add_reg_br_prob_note (get_insns (), REG_BR_PROB_BASE/100);
   }
 #else
   expand_builtin_setjmp_setup (plus_constant (XEXP (fc, 0), sjlj_fc_jbuf_ofs),
@@ -1813,9 +1861,9 @@ sjlj_emit_function_enter (rtx dispatch_label)
   for (fn_begin = get_insns (); ; fn_begin = NEXT_INSN (fn_begin))
     if (NOTE_P (fn_begin))
       {
-	if (NOTE_LINE_NUMBER (fn_begin) == NOTE_INSN_FUNCTION_BEG)
+	if (NOTE_KIND (fn_begin) == NOTE_INSN_FUNCTION_BEG)
 	  break;
-	else if (NOTE_LINE_NUMBER (fn_begin) == NOTE_INSN_BASIC_BLOCK)
+	else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin))
 	  fn_begin_outside_block = false;
       }
 
@@ -1831,7 +1879,7 @@ sjlj_emit_function_enter (rtx dispatch_label)
 void
 sjlj_emit_function_exit_after (rtx after)
 {
-  cfun->eh->sjlj_exit_after = after;
+  crtl->eh.sjlj_exit_after = after;
 }
 
 static void
@@ -1844,7 +1892,7 @@ sjlj_emit_function_exit (void)
   start_sequence ();
 
   emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
-		     1, XEXP (cfun->eh->sjlj_fc, 0), Pmode);
+		     1, XEXP (crtl->eh.sjlj_fc, 0), Pmode);
 
   seq = get_insns ();
   end_sequence ();
@@ -1866,7 +1914,7 @@ sjlj_emit_function_exit (void)
       gcc_assert (e->src->next_bb == EXIT_BLOCK_PTR);
       for (insn = BB_HEAD (e->src); ; insn = NEXT_INSN (insn))
 	{
-	  if (insn == cfun->eh->sjlj_exit_after)
+	  if (insn == crtl->eh.sjlj_exit_after)
 	    {
 	      if (LABEL_P (insn))
 		insn = NEXT_INSN (insn);
@@ -1889,7 +1937,7 @@ sjlj_emit_dispatch_table (rtx dispatch_label, struct sjlj_lp_info *lp_info)
   basic_block bb;
   edge e;
 
-  fc = cfun->eh->sjlj_fc;
+  fc = crtl->eh.sjlj_fc;
 
   start_sequence ();
 
@@ -1914,10 +1962,10 @@ sjlj_emit_dispatch_table (rtx dispatch_label, struct sjlj_lp_info *lp_info)
       mem = convert_to_mode (ptr_mode, mem, 0);
 #endif
     }
-  emit_move_insn (cfun->eh->exc_ptr, mem);
+  emit_move_insn (crtl->eh.exc_ptr, mem);
 
   mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs + UNITS_PER_WORD);
-  emit_move_insn (cfun->eh->filter, mem);
+  emit_move_insn (crtl->eh.filter, mem);
 
   /* Jump to one of the directly reachable regions.  */
   /* ??? This really ought to be using a switch statement.  */
@@ -1957,14 +2005,13 @@ sjlj_build_landing_pads (void)
 {
   struct sjlj_lp_info *lp_info;
 
-  lp_info = xcalloc (cfun->eh->last_region_number + 1,
-		     sizeof (struct sjlj_lp_info));
+  lp_info = XCNEWVEC (struct sjlj_lp_info, cfun->eh->last_region_number + 1);
 
   if (sjlj_find_directly_reachable_regions (lp_info))
     {
       rtx dispatch_label = gen_label_rtx ();
 
-      cfun->eh->sjlj_fc
+      crtl->eh.sjlj_fc
 	= assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
 			      int_size_in_bytes (sjlj_fc_type_node),
 			      TYPE_ALIGN (sjlj_fc_type_node));
@@ -2000,8 +2047,8 @@ finish_eh_generation (void)
 
   /* These registers are used by the landing pads.  Make sure they
      have been generated.  */
-  get_exception_pointer (cfun);
-  get_exception_filter (cfun);
+  get_exception_pointer ();
+  get_exception_filter ();
 
   /* Construct the landing pads.  */
 
@@ -2013,12 +2060,14 @@ finish_eh_generation (void)
   else
     dw2_build_landing_pads ();
 
-  cfun->eh->built_landing_pads = 1;
+  crtl->eh.built_landing_pads = 1;
 
   /* We've totally changed the CFG.  Start over.  */
   find_exception_handler_labels ();
   break_superblocks ();
-  if (USING_SJLJ_EXCEPTIONS)
+  if (USING_SJLJ_EXCEPTIONS
+      /* Kludge for Alpha/Tru64 (see alpha_gp_save_rtx).  */
+      || single_succ_edge (ENTRY_BLOCK_PTR)->insns.r)
     commit_edge_insertions ();
   FOR_EACH_BB (bb)
     {
@@ -2043,7 +2092,8 @@ finish_eh_generation (void)
 static hashval_t
 ehl_hash (const void *pentry)
 {
-  struct ehl_map_entry *entry = (struct ehl_map_entry *) pentry;
+  const struct ehl_map_entry *const entry
+    = (const struct ehl_map_entry *) pentry;
 
   /* 2^32 * ((sqrt(5) - 1) / 2) */
   const hashval_t scaled_golden_ratio = 0x9e3779b9;
@@ -2053,8 +2103,10 @@ ehl_hash (const void *pentry)
 static int
 ehl_eq (const void *pentry, const void *pdata)
 {
-  struct ehl_map_entry *entry = (struct ehl_map_entry *) pentry;
-  struct ehl_map_entry *data = (struct ehl_map_entry *) pdata;
+  const struct ehl_map_entry *const entry
+    = (const struct ehl_map_entry *) pentry;
+  const struct ehl_map_entry *const data
+    = (const struct ehl_map_entry *) pdata;
 
   return entry->label == data->label;
 }
@@ -2070,15 +2122,15 @@ remove_exception_handler_label (rtx label)
 
   /* If exception_handler_label_map was not built yet,
      there is nothing to do.  */
-  if (cfun->eh->exception_handler_label_map == NULL)
+  if (crtl->eh.exception_handler_label_map == NULL)
     return;
 
   tmp.label = label;
   slot = (struct ehl_map_entry **)
-    htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
+    htab_find_slot (crtl->eh.exception_handler_label_map, &tmp, NO_INSERT);
   gcc_assert (slot);
 
-  htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
+  htab_clear_slot (crtl->eh.exception_handler_label_map, (void **) slot);
 }
 
 /* Splice REGION from the region tree etc.  */
@@ -2117,7 +2169,7 @@ remove_eh_handler (struct eh_region *region)
       bitmap_set_bit (outer->aka, region->region_number);
     }
 
-  if (cfun->eh->built_landing_pads)
+  if (crtl->eh.built_landing_pads)
     lab = region->landing_pad;
   else
     lab = region->label;
@@ -2185,12 +2237,12 @@ maybe_remove_eh_handler (rtx label)
      if the region data is completely unused.  One must examine the
      landing pad and the post landing pad, and whether an inner try block
      is referencing the catch handlers directly.  */
-  if (cfun->eh->built_landing_pads)
+  if (crtl->eh.built_landing_pads)
     return;
 
   tmp.label = label;
   slot = (struct ehl_map_entry **)
-    htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
+    htab_find_slot (crtl->eh.exception_handler_label_map, &tmp, NO_INSERT);
   if (! slot)
     return;
   region = (*slot)->region;
@@ -2203,7 +2255,7 @@ maybe_remove_eh_handler (rtx label)
      are no more contained calls, which we don't see here.  */
   if (region->type == ERT_MUST_NOT_THROW)
     {
-      htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
+      htab_clear_slot (crtl->eh.exception_handler_label_map, (void **) slot);
       region->label = NULL_RTX;
     }
   else
@@ -2216,7 +2268,7 @@ maybe_remove_eh_handler (rtx label)
 void
 for_each_eh_label (void (*callback) (rtx))
 {
-  htab_traverse (cfun->eh->exception_handler_label_map, for_each_eh_label_1,
+  htab_traverse (crtl->eh.exception_handler_label_map, for_each_eh_label_1,
 		 (void *) &callback);
 }
 
@@ -2300,7 +2352,7 @@ add_reachable_handler (struct reachable_info *info,
 
   info->saw_any_handlers = true;
 
-  if (cfun->eh->built_landing_pads)
+  if (crtl->eh.built_landing_pads)
     info->callback (lp_region, info->callback_data);
   else
     info->callback (region, info->callback_data);
@@ -2451,7 +2503,7 @@ reachable_next_level (struct eh_region *region, tree type_thrown,
       /* Here we end our search, since no exceptions may propagate.
 	 If we've touched down at some landing pad previous, then the
 	 explicit function call we generated may be used.  Otherwise
-	 the call is made by the runtime. 
+	 the call is made by the runtime.
 
          Before inlining, do not perform this optimization.  We may
 	 inline a subroutine that contains handlers, and that will
@@ -2562,7 +2614,7 @@ reachable_handlers (rtx insn)
     }
 
   foreach_reachable_handler (region_number, is_resx,
-			     (cfun->eh->built_landing_pads
+			     (crtl->eh.built_landing_pads
 			      ? arh_to_landing_pad
 			      : arh_to_label),
 			     &handlers);
@@ -2606,7 +2658,7 @@ can_throw_internal_1 (int region_number, bool is_resx)
 }
 
 bool
-can_throw_internal (rtx insn)
+can_throw_internal (const_rtx insn)
 {
   rtx note;
 
@@ -2660,7 +2712,7 @@ can_throw_external_1 (int region_number, bool is_resx)
 }
 
 bool
-can_throw_external (rtx insn)
+can_throw_external (const_rtx insn)
 {
   rtx note;
 
@@ -2694,25 +2746,31 @@ can_throw_external (rtx insn)
   return can_throw_external_1 (INTVAL (XEXP (note, 0)), false);
 }
 
-/* Set TREE_NOTHROW and cfun->all_throwers_are_sibcalls.  */
+/* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls.  */
 
-void
+unsigned int
 set_nothrow_function_flags (void)
 {
   rtx insn;
 
+  /* If we don't know that this implementation of the function will
+     actually be used, then we must not set TREE_NOTHROW, since
+     callers must not assume that this function does not throw.  */
+  if (DECL_REPLACEABLE_P (current_function_decl))
+    return 0;
+
   TREE_NOTHROW (current_function_decl) = 1;
 
-  /* Assume cfun->all_throwers_are_sibcalls until we encounter
+  /* Assume crtl->all_throwers_are_sibcalls until we encounter
      something that can throw an exception.  We specifically exempt
      CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
      and can't throw.  Most CALL_INSNs are not SIBLING_CALL_P, so this
      is optimistic.  */
 
-  cfun->all_throwers_are_sibcalls = 1;
+  crtl->all_throwers_are_sibcalls = 1;
 
   if (! flag_exceptions)
-    return;
+    return 0;
 
   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
     if (can_throw_external (insn))
@@ -2721,12 +2779,12 @@ set_nothrow_function_flags (void)
 
 	if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
 	  {
-	    cfun->all_throwers_are_sibcalls = 0;
-	    return;
+	    crtl->all_throwers_are_sibcalls = 0;
+	    return 0;
 	  }
       }
 
-  for (insn = current_function_epilogue_delay_list; insn;
+  for (insn = crtl->epilogue_delay_list; insn;
        insn = XEXP (insn, 1))
     if (can_throw_external (insn))
       {
@@ -2734,14 +2792,17 @@ set_nothrow_function_flags (void)
 
 	if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
 	  {
-	    cfun->all_throwers_are_sibcalls = 0;
-	    return;
+	    crtl->all_throwers_are_sibcalls = 0;
+	    return 0;
 	  }
       }
+  return 0;
 }
 
-struct tree_opt_pass pass_set_nothrow_function_flags =
+struct rtl_opt_pass pass_set_nothrow_function_flags =
 {
+ {
+  RTL_PASS,
   NULL,                                 /* name */
   NULL,                                 /* gate */
   set_nothrow_function_flags,           /* execute */
@@ -2754,7 +2815,7 @@ struct tree_opt_pass pass_set_nothrow_function_flags =
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   0,                                    /* todo_flags_finish */
-  0                                     /* letter */
+ }
 };
 
 
@@ -2768,7 +2829,7 @@ expand_builtin_unwind_init (void)
 {
   /* Set this so all the registers get saved in our frame; we need to be
      able to copy the saved values for any registers from frames we unwind.  */
-  current_function_has_nonlocal_label = 1;
+  crtl->saves_all_registers = 1;
 
 #ifdef SETUP_FRAME_ADDRESSES
   SETUP_FRAME_ADDRESSES ();
@@ -2776,9 +2837,9 @@ expand_builtin_unwind_init (void)
 }
 
 rtx
-expand_builtin_eh_return_data_regno (tree arglist)
+expand_builtin_eh_return_data_regno (tree exp)
 {
-  tree which = TREE_VALUE (arglist);
+  tree which = CALL_EXPR_ARG (exp, 0);
   unsigned HOST_WIDE_INT iwhich;
 
   if (TREE_CODE (which) != INTEGER_CST)
@@ -2807,7 +2868,7 @@ expand_builtin_eh_return_data_regno (tree arglist)
 rtx
 expand_builtin_extract_return_addr (tree addr_tree)
 {
-  rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
+  rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
 
   if (GET_MODE (addr) != Pmode
       && GET_MODE (addr) != VOIDmode)
@@ -2839,7 +2900,7 @@ expand_builtin_extract_return_addr (tree addr_tree)
 rtx
 expand_builtin_frob_return_addr (tree addr_tree)
 {
-  rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, 0);
+  rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
 
   addr = convert_memory_address (Pmode, addr);
 
@@ -2861,24 +2922,26 @@ expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED,
   rtx tmp;
 
 #ifdef EH_RETURN_STACKADJ_RTX
-  tmp = expand_expr (stackadj_tree, cfun->eh->ehr_stackadj, VOIDmode, 0);
+  tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj,
+		     VOIDmode, EXPAND_NORMAL);
   tmp = convert_memory_address (Pmode, tmp);
-  if (!cfun->eh->ehr_stackadj)
-    cfun->eh->ehr_stackadj = copy_to_reg (tmp);
-  else if (tmp != cfun->eh->ehr_stackadj)
-    emit_move_insn (cfun->eh->ehr_stackadj, tmp);
+  if (!crtl->eh.ehr_stackadj)
+    crtl->eh.ehr_stackadj = copy_to_reg (tmp);
+  else if (tmp != crtl->eh.ehr_stackadj)
+    emit_move_insn (crtl->eh.ehr_stackadj, tmp);
 #endif
 
-  tmp = expand_expr (handler_tree, cfun->eh->ehr_handler, VOIDmode, 0);
+  tmp = expand_expr (handler_tree, crtl->eh.ehr_handler,
+		     VOIDmode, EXPAND_NORMAL);
   tmp = convert_memory_address (Pmode, tmp);
-  if (!cfun->eh->ehr_handler)
-    cfun->eh->ehr_handler = copy_to_reg (tmp);
-  else if (tmp != cfun->eh->ehr_handler)
-    emit_move_insn (cfun->eh->ehr_handler, tmp);
+  if (!crtl->eh.ehr_handler)
+    crtl->eh.ehr_handler = copy_to_reg (tmp);
+  else if (tmp != crtl->eh.ehr_handler)
+    emit_move_insn (crtl->eh.ehr_handler, tmp);
 
-  if (!cfun->eh->ehr_label)
-    cfun->eh->ehr_label = gen_label_rtx ();
-  emit_jump (cfun->eh->ehr_label);
+  if (!crtl->eh.ehr_label)
+    crtl->eh.ehr_label = gen_label_rtx ();
+  emit_jump (crtl->eh.ehr_label);
 }
 
 void
@@ -2886,10 +2949,10 @@ expand_eh_return (void)
 {
   rtx around_label;
 
-  if (! cfun->eh->ehr_label)
+  if (! crtl->eh.ehr_label)
     return;
 
-  current_function_calls_eh_return = 1;
+  crtl->calls_eh_return = 1;
 
 #ifdef EH_RETURN_STACKADJ_RTX
   emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx);
@@ -2898,21 +2961,21 @@ expand_eh_return (void)
   around_label = gen_label_rtx ();
   emit_jump (around_label);
 
-  emit_label (cfun->eh->ehr_label);
+  emit_label (crtl->eh.ehr_label);
   clobber_return_register ();
 
 #ifdef EH_RETURN_STACKADJ_RTX
-  emit_move_insn (EH_RETURN_STACKADJ_RTX, cfun->eh->ehr_stackadj);
+  emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj);
 #endif
 
 #ifdef HAVE_eh_return
   if (HAVE_eh_return)
-    emit_insn (gen_eh_return (cfun->eh->ehr_handler));
+    emit_insn (gen_eh_return (crtl->eh.ehr_handler));
   else
 #endif
     {
 #ifdef EH_RETURN_HANDLER_RTX
-      emit_move_insn (EH_RETURN_HANDLER_RTX, cfun->eh->ehr_handler);
+      emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler);
 #else
       error ("__builtin_eh_return not supported on this target");
 #endif
@@ -2927,7 +2990,7 @@ expand_eh_return (void)
 rtx
 expand_builtin_extend_pointer (tree addr_tree)
 {
-  rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, 0);
+  rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
   int extend;
 
 #ifdef POINTERS_EXTEND_UNSIGNED
@@ -2986,7 +3049,7 @@ add_action_record (htab_t ar_hash, int filter, int next)
   if ((new = *slot) == NULL)
     {
       new = xmalloc (sizeof (*new));
-      new->offset = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
+      new->offset = VARRAY_ACTIVE_SIZE (crtl->eh.action_record_data) + 1;
       new->filter = filter;
       new->next = next;
       *slot = new;
@@ -2996,10 +3059,10 @@ add_action_record (htab_t ar_hash, int filter, int next)
 	 that there is no next record.  So convert the absolute 1 based
 	 indices we've been carrying around into a displacement.  */
 
-      push_sleb128 (&cfun->eh->action_record_data, filter);
+      push_sleb128 (&crtl->eh.action_record_data, filter);
       if (next)
-	next -= VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
-      push_sleb128 (&cfun->eh->action_record_data, next);
+	next -= VARRAY_ACTIVE_SIZE (crtl->eh.action_record_data) + 1;
+      push_sleb128 (&crtl->eh.action_record_data, next);
     }
 
   return new->offset;
@@ -3095,7 +3158,7 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
 	 Add a cleanup action to the chain to catch these.  */
       else if (next <= 0)
 	next = add_action_record (ar_hash, 0, 0);
-      
+
       return add_action_record (ar_hash, region->u.allowed.filter, next);
 
     case ERT_MUST_NOT_THROW:
@@ -3119,31 +3182,22 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
 static int
 add_call_site (rtx landing_pad, int action)
 {
-  struct call_site_record *data = cfun->eh->call_site_data;
-  int used = cfun->eh->call_site_data_used;
-  int size = cfun->eh->call_site_data_size;
-
-  if (used >= size)
-    {
-      size = (size ? size * 2 : 64);
-      data = ggc_realloc (data, sizeof (*data) * size);
-      cfun->eh->call_site_data = data;
-      cfun->eh->call_site_data_size = size;
-    }
-
-  data[used].landing_pad = landing_pad;
-  data[used].action = action;
+  call_site_record record;
+  
+  record = ggc_alloc (sizeof (struct call_site_record));
+  record->landing_pad = landing_pad;
+  record->action = action;
 
-  cfun->eh->call_site_data_used = used + 1;
+  VEC_safe_push (call_site_record, gc, crtl->eh.call_site_record, record);
 
-  return used + call_site_base;
+  return call_site_base + VEC_length (call_site_record, crtl->eh.call_site_record) - 1;
 }
 
 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
    The new note numbers will not refer to region numbers, but
    instead to call site entries.  */
 
-void
+unsigned int
 convert_to_eh_region_ranges (void)
 {
   rtx insn, iter, note;
@@ -3155,9 +3209,9 @@ convert_to_eh_region_ranges (void)
   int call_site = 0;
 
   if (USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL)
-    return;
+    return 0;
 
-  VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data");
+  VARRAY_UCHAR_INIT (crtl->eh.action_record_data, 64, "action_record_data");
 
   ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
 
@@ -3194,7 +3248,7 @@ convert_to_eh_region_ranges (void)
 	/* Existence of catch handlers, or must-not-throw regions
 	   implies that an lsda is needed (even if empty).  */
 	if (this_action != -1)
-	  cfun->uses_eh_lsda = 1;
+	  crtl->uses_eh_lsda = 1;
 
 	/* Delay creation of region notes for no-action regions
 	   until we're sure that an lsda will be required.  */
@@ -3264,10 +3318,13 @@ convert_to_eh_region_ranges (void)
     }
 
   htab_delete (ar_hash);
+  return 0;
 }
 
-struct tree_opt_pass pass_convert_to_eh_region_ranges =
+struct rtl_opt_pass pass_convert_to_eh_region_ranges =
 {
+ {
+  RTL_PASS,
   "eh-ranges",                          /* name */
   NULL,                                 /* gate */
   convert_to_eh_region_ranges,          /* execute */
@@ -3280,7 +3337,7 @@ struct tree_opt_pass pass_convert_to_eh_region_ranges =
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   TODO_dump_func,			/* todo_flags_finish */
-  0                                     /* letter */
+ }
 };
 
 
@@ -3322,13 +3379,13 @@ push_sleb128 (varray_type *data_area, int value)
 static int
 dw2_size_of_call_site_table (void)
 {
-  int n = cfun->eh->call_site_data_used;
+  int n = VEC_length (call_site_record, crtl->eh.call_site_record);
   int size = n * (4 + 4 + 4);
   int i;
 
   for (i = 0; i < n; ++i)
     {
-      struct call_site_record *cs = &cfun->eh->call_site_data[i];
+      struct call_site_record *cs = VEC_index (call_site_record, crtl->eh.call_site_record, i);
       size += size_of_uleb128 (cs->action);
     }
 
@@ -3338,13 +3395,13 @@ dw2_size_of_call_site_table (void)
 static int
 sjlj_size_of_call_site_table (void)
 {
-  int n = cfun->eh->call_site_data_used;
+  int n = VEC_length (call_site_record, crtl->eh.call_site_record);
   int size = 0;
   int i;
 
   for (i = 0; i < n; ++i)
     {
-      struct call_site_record *cs = &cfun->eh->call_site_data[i];
+      struct call_site_record *cs = VEC_index (call_site_record, crtl->eh.call_site_record, i);
       size += size_of_uleb128 (INTVAL (cs->landing_pad));
       size += size_of_uleb128 (cs->action);
     }
@@ -3356,12 +3413,12 @@ sjlj_size_of_call_site_table (void)
 static void
 dw2_output_call_site_table (void)
 {
-  int n = cfun->eh->call_site_data_used;
+  int n = VEC_length (call_site_record, crtl->eh.call_site_record);
   int i;
 
   for (i = 0; i < n; ++i)
     {
-      struct call_site_record *cs = &cfun->eh->call_site_data[i];
+      struct call_site_record *cs = VEC_index (call_site_record, crtl->eh.call_site_record, i);
       char reg_start_lab[32];
       char reg_end_lab[32];
       char landing_pad_lab[32];
@@ -3410,12 +3467,12 @@ dw2_output_call_site_table (void)
 static void
 sjlj_output_call_site_table (void)
 {
-  int n = cfun->eh->call_site_data_used;
+  int n = VEC_length (call_site_record, crtl->eh.call_site_record);
   int i;
 
   for (i = 0; i < n; ++i)
     {
-      struct call_site_record *cs = &cfun->eh->call_site_data[i];
+      struct call_site_record *cs = VEC_index (call_site_record, crtl->eh.call_site_record, i);
 
       dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
 				   "region %d landing pad", i);
@@ -3425,35 +3482,61 @@ sjlj_output_call_site_table (void)
   call_site_base += n;
 }
 
-/* Return the default value of exception_section.  */
+#ifndef TARGET_UNWIND_INFO
+/* Switch to the section that should be used for exception tables.  */
 
-section *
-default_exception_section (void)
+static void
+switch_to_exception_section (const char * ARG_UNUSED (fnname))
 {
-  if (targetm.have_named_sections)
-    {
-      int flags;
+  section *s;
 
-      if (EH_TABLES_CAN_BE_READ_ONLY)
+  if (exception_section)
+    s = exception_section;
+  else
+    {
+      /* Compute the section and cache it into exception_section,
+	 unless it depends on the function name.  */
+      if (targetm.have_named_sections)
 	{
-	  int tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
-	  
-	  flags = (! flag_pic
-		   || ((tt_format & 0x70) != DW_EH_PE_absptr
-		       && (tt_format & 0x70) != DW_EH_PE_aligned))
-	    ? 0 : SECTION_WRITE;
+	  int flags;
+
+	  if (EH_TABLES_CAN_BE_READ_ONLY)
+	    {
+	      int tt_format =
+		ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
+	      flags = ((! flag_pic
+			|| ((tt_format & 0x70) != DW_EH_PE_absptr
+			    && (tt_format & 0x70) != DW_EH_PE_aligned))
+		       ? 0 : SECTION_WRITE);
+	    }
+	  else
+	    flags = SECTION_WRITE;
+
+#ifdef HAVE_LD_EH_GC_SECTIONS
+	  if (flag_function_sections)
+	    {
+	      char *section_name = xmalloc (strlen (fnname) + 32);
+	      sprintf (section_name, ".gcc_except_table.%s", fnname);
+	      s = get_section (section_name, flags, NULL);
+	      free (section_name);
+	    }
+	  else
+#endif
+	    exception_section
+	      = s = get_section (".gcc_except_table", flags, NULL);
 	}
       else
-	flags = SECTION_WRITE;
-      return get_section (".gcc_except_table", flags, NULL);
+	exception_section
+	  = s = flag_pic ? data_section : readonly_data_section;
     }
-  else
-    return flag_pic ? data_section : readonly_data_section;
+
+  switch_to_section (s);
 }
+#endif
 
 
 /* Output a reference from an exception table to the type_info object TYPE.
-   TT_FORMAT and TT_FORMAT_SIZE descibe the DWARF encoding method used for
+   TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
    the value.  */
 
 static void
@@ -3466,7 +3549,7 @@ output_ttype (tree type, int tt_format, int tt_format_size)
     value = const0_rtx;
   else
     {
-      struct cgraph_varpool_node *node;
+      struct varpool_node *node;
 
       type = lookup_type_for_runtime (type);
       value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
@@ -3480,14 +3563,14 @@ output_ttype (tree type, int tt_format, int tt_format_size)
 	  type = TREE_OPERAND (type, 0);
 	  if (TREE_CODE (type) == VAR_DECL)
 	    {
-	      node = cgraph_varpool_node (type);
+	      node = varpool_node (type);
 	      if (node)
-		cgraph_varpool_mark_needed_node (node);
+		varpool_mark_needed_node (node);
 	      public = TREE_PUBLIC (type);
 	    }
 	}
-      else if (TREE_CODE (type) != INTEGER_CST)
-	abort ();
+      else
+	gcc_assert (TREE_CODE (type) == INTEGER_CST);
     }
 
   /* Allow the target to override the type table entry format.  */
@@ -3502,7 +3585,7 @@ output_ttype (tree type, int tt_format, int tt_format_size)
 }
 
 void
-output_function_exception_table (void)
+output_function_exception_table (const char * ARG_UNUSED (fnname))
 {
   int tt_format, cs_format, lp_format, i, n;
 #ifdef HAVE_AS_LEB128
@@ -3515,13 +3598,13 @@ output_function_exception_table (void)
   int have_tt_data;
   int tt_format_size = 0;
 
-  if (eh_personality_libfunc)
-    assemble_external_libcall (eh_personality_libfunc);
-
   /* Not all functions need anything.  */
-  if (! cfun->uses_eh_lsda)
+  if (! crtl->uses_eh_lsda)
     return;
 
+  if (eh_personality_libfunc)
+    assemble_external_libcall (eh_personality_libfunc);
+
 #ifdef TARGET_UNWIND_INFO
   /* TODO: Move this into target file.  */
   fputs ("\t.personality\t", asm_out_file);
@@ -3530,11 +3613,14 @@ output_function_exception_table (void)
   /* Note that varasm still thinks we're in the function's code section.
      The ".endp" directive that will immediately follow will take us back.  */
 #else
-  switch_to_section (exception_section);
+  switch_to_exception_section (fnname);
 #endif
 
-  have_tt_data = (VEC_length (tree, cfun->eh->ttype_data) > 0
-		  || VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) > 0);
+  /* If the target wants a label to begin the table, emit it here.  */
+  targetm.asm_out.except_table_label (asm_out_file);
+
+  have_tt_data = (VEC_length (tree, crtl->eh.ttype_data) > 0
+		  || VARRAY_ACTIVE_SIZE (crtl->eh.ehspec_data) > 0);
 
   /* Indicate the format of the @TType entries.  */
   if (! have_tt_data)
@@ -3595,8 +3681,8 @@ output_function_exception_table (void)
       before_disp = 1 + 1;
       after_disp = (1 + size_of_uleb128 (call_site_len)
 		    + call_site_len
-		    + VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data)
-		    + (VEC_length (tree, cfun->eh->ttype_data)
+		    + VARRAY_ACTIVE_SIZE (crtl->eh.action_record_data)
+		    + (VEC_length (tree, crtl->eh.ttype_data)
 		       * tt_format_size));
 
       disp = after_disp;
@@ -3650,18 +3736,18 @@ output_function_exception_table (void)
 #endif
 
   /* ??? Decode and interpret the data for flag_debug_asm.  */
-  n = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data);
+  n = VARRAY_ACTIVE_SIZE (crtl->eh.action_record_data);
   for (i = 0; i < n; ++i)
-    dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->action_record_data, i),
+    dw2_asm_output_data (1, VARRAY_UCHAR (crtl->eh.action_record_data, i),
 			 (i ? NULL : "Action record table"));
 
   if (have_tt_data)
     assemble_align (tt_format_size * BITS_PER_UNIT);
 
-  i = VEC_length (tree, cfun->eh->ttype_data);
+  i = VEC_length (tree, crtl->eh.ttype_data);
   while (i-- > 0)
     {
-      tree type = VEC_index (tree, cfun->eh->ttype_data, i);
+      tree type = VEC_index (tree, crtl->eh.ttype_data, i);
       output_ttype (type, tt_format, tt_format_size);
     }
 
@@ -3671,16 +3757,16 @@ output_function_exception_table (void)
 #endif
 
   /* ??? Decode and interpret the data for flag_debug_asm.  */
-  n = VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data);
+  n = VARRAY_ACTIVE_SIZE (crtl->eh.ehspec_data);
   for (i = 0; i < n; ++i)
     {
       if (targetm.arm_eabi_unwinder)
 	{
-	  tree type = VARRAY_TREE (cfun->eh->ehspec_data, i);
+	  tree type = VARRAY_TREE (crtl->eh.ehspec_data, i);
 	  output_ttype (type, tt_format, tt_format_size);
 	}
       else
-	dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->ehspec_data, i),
+	dw2_asm_output_data (1, VARRAY_UCHAR (crtl->eh.ehspec_data, i),
 			     (i ? NULL : "Exception specification table"));
     }
 
@@ -3700,7 +3786,7 @@ get_eh_throw_stmt_table (struct function *fun)
 }
 
 /* Dump EH information to OUT.  */
-void 
+void
 dump_eh_tree (FILE *out, struct function *fun)
 {
   struct eh_region *i;
@@ -3746,7 +3832,7 @@ dump_eh_tree (FILE *out, struct function *fun)
 
 /* Verify some basic invariants on EH datastructures.  Could be extended to
    catch more.  */
-void 
+void
 verify_eh_tree (struct function *fun)
 {
   struct eh_region *i, *outer = NULL;
@@ -3851,19 +3937,22 @@ gate_handle_eh (void)
 }
 
 /* Complete generation of exception handling code.  */
-static void
+static unsigned int
 rest_of_handle_eh (void)
 {
-  cleanup_cfg (CLEANUP_PRE_LOOP | CLEANUP_NO_INSN_DEL);
+  cleanup_cfg (CLEANUP_NO_INSN_DEL);
   finish_eh_generation ();
-  cleanup_cfg (CLEANUP_PRE_LOOP | CLEANUP_NO_INSN_DEL);
+  cleanup_cfg (CLEANUP_NO_INSN_DEL);
+  return 0;
 }
 
-struct tree_opt_pass pass_rtl_eh =
+struct rtl_opt_pass pass_rtl_eh =
 {
+ {
+  RTL_PASS,
   "eh",                                 /* name */
-  gate_handle_eh,                       /* gate */   
-  rest_of_handle_eh,			/* execute */       
+  gate_handle_eh,                       /* gate */
+  rest_of_handle_eh,			/* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
@@ -3872,8 +3961,8 @@ struct tree_opt_pass pass_rtl_eh =
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
-  TODO_dump_func,                       /* todo_flags_finish */
-  'h'                                   /* letter */
+  TODO_dump_func                        /* todo_flags_finish */
+ }
 };
 
 #include "gt-except.h"