Index: gcc/tree-eh.c
===================================================================
--- gcc/tree-eh.c	(revision 124739)
+++ gcc/tree-eh.c	(working copy)
@@ -83,7 +83,7 @@ struct_ptr_hash (const void *a)
    of space by only allocating memory for those that can throw.  */
 
 static void
-record_stmt_eh_region (struct eh_region *region, tree t)
+record_stmt_eh_region (eh_region region, tree t)
 {
   if (!region)
     return;
@@ -277,8 +277,8 @@ 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;
+  eh_region cur_region;
+  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
@@ -286,6 +286,15 @@ struct leh_state
   struct leh_tf_state *tf;
 };
 
+/* 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;
+};
+
 struct leh_tf_state
 {
   /* Pointer to the TRY_FINALLY node under discussion.  The try_finally_expr
@@ -299,16 +308,11 @@ struct leh_tf_state
   struct leh_state *outer;
 
   /* The exception region created for it.  */
-  struct eh_region *region;
+  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;
+  struct goto_queue_node *goto_queue;
   size_t goto_queue_size;
   size_t goto_queue_active;
 
@@ -373,13 +377,13 @@ static void
 replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf,
 				tree_stmt_iterator *tsi)
 {
-  tree new, one, label;
+  tree new_tree, one, label;
 
-  new = find_goto_replacement (tf, *tp);
-  if (!new)
+  new_tree = find_goto_replacement (tf, *tp);
+  if (!new_tree)
     return;
 
-  one = expr_only (new);
+  one = expr_only (new_tree);
   if (one && TREE_CODE (one) == GOTO_EXPR)
     {
       *tp = one;
@@ -390,7 +394,7 @@ replace_goto_queue_cond_clause (tree *tp
   *tp = build_and_jump (&LABEL_EXPR_LABEL (label));
 
   tsi_link_after (tsi, label, TSI_CONTINUE_LINKING);
-  tsi_link_after (tsi, new, TSI_CONTINUE_LINKING);
+  tsi_link_after (tsi, new_tree, TSI_CONTINUE_LINKING);
 }
 
 /* The real work of replace_goto_queue.  Returns with TSI updated to
@@ -615,7 +619,7 @@ do_return_redirection (struct goto_queue
 	case GIMPLE_MODIFY_STMT:
 	  {
 	    tree result = GIMPLE_STMT_OPERAND (ret_expr, 0);
-	    tree new, old = GIMPLE_STMT_OPERAND (ret_expr, 1);
+	    tree new_tree, old = GIMPLE_STMT_OPERAND (ret_expr, 1);
 
 	    if (!*return_value_p)
 	      {
@@ -626,21 +630,21 @@ do_return_redirection (struct goto_queue
 		    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;
+		  new_tree = result;
 		else
-		  new = create_tmp_var (TREE_TYPE (old), "rettmp");
-		*return_value_p = new;
+		  new_tree = create_tmp_var (TREE_TYPE (old), "rettmp");
+		*return_value_p = new_tree;
 	      }
 	    else
-	      new = *return_value_p;
+	      new_tree = *return_value_p;
 
-	    x = build_gimple_modify_stmt (new, old);
+	    x = build_gimple_modify_stmt (new_tree, old);
 	    append_to_statement_list (x, &q->repl_stmt);
 
-	    if (new == result)
+	    if (new_tree == result)
 	      x = result;
 	    else
-	      x = build_gimple_modify_stmt (result, new);
+	      x = build_gimple_modify_stmt (result, new_tree);
 	    q->cont_stmt = build1 (RETURN_EXPR, void_type_node, x);
 	  }
 
@@ -1425,7 +1429,7 @@ lower_try_finally (struct leh_state *sta
 static void
 lower_catch (struct leh_state *state, tree *tp)
 {
-  struct eh_region *try_region;
+  eh_region try_region;
   struct leh_state this_state;
   tree_stmt_iterator i;
   tree out_label;
@@ -1446,15 +1450,15 @@ lower_catch (struct leh_state *state, tr
   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;
+      eh_region catch_region;
+      tree catch_tree, x, eh_label;
 
-      catch = tsi_stmt (i);
-      catch_region = gen_eh_region_catch (try_region, CATCH_TYPES (catch));
+      catch_tree = tsi_stmt (i);
+      catch_region = gen_eh_region_catch (try_region, CATCH_TYPES (catch_tree));
 
       this_state.cur_region = catch_region;
       this_state.prev_try = state->prev_try;
-      lower_eh_constructs_1 (&this_state, &CATCH_BODY (catch));
+      lower_eh_constructs_1 (&this_state, &CATCH_BODY (catch_tree));
 
       eh_label = create_artificial_label ();
       set_eh_region_tree_label (catch_region, eh_label);
@@ -1462,16 +1466,16 @@ lower_catch (struct leh_state *state, tr
       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 (block_may_fallthru (CATCH_BODY (catch_tree)))
 	{
 	  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));
+	  append_to_statement_list (x, &CATCH_BODY (catch_tree));
 	}
 
-      tsi_link_before (&i, CATCH_BODY (catch), TSI_SAME_STMT);
+      tsi_link_before (&i, CATCH_BODY (catch_tree), TSI_SAME_STMT);
       tsi_delink (&i);
     }
 
@@ -1486,7 +1490,7 @@ static void
 lower_eh_filter (struct leh_state *state, tree *tp)
 {
   struct leh_state this_state;
-  struct eh_region *this_region;
+  eh_region this_region;
   tree inner = expr_first (TREE_OPERAND (*tp, 1));
   tree eh_label;
 
@@ -1526,7 +1530,7 @@ static void
 lower_cleanup (struct leh_state *state, tree *tp)
 {
   struct leh_state this_state;
-  struct eh_region *this_region;
+  eh_region this_region;
   struct leh_tf_state fake_tf;
 
   /* If not using eh, then exception-only cleanups are no-ops.  */
@@ -1707,7 +1711,7 @@ struct tree_opt_pass pass_lower_eh =
 /* Construct EH edges for STMT.  */
 
 static void
-make_eh_edge (struct eh_region *region, void *data)
+make_eh_edge (eh_region region, void *data)
 {
   tree stmt, lab;
   basic_block src, dst;
@@ -1748,7 +1752,7 @@ 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)
+mark_eh_edge (eh_region region, void *data)
 {
   tree stmt, lab;
   basic_block src, dst;
Index: gcc/except.c
===================================================================
--- gcc/except.c	(revision 124739)
+++ gcc/except.c	(working copy)
@@ -100,7 +100,7 @@ tree (*lang_eh_runtime_type) (tree);
 struct ehl_map_entry GTY(())
 {
   rtx label;
-  struct eh_region *region;
+  struct eh_region_def *region;
 };
 
 static GTY(()) int call_site_base;
@@ -114,16 +114,28 @@ static int sjlj_fc_data_ofs;
 static int sjlj_fc_personality_ofs;
 static int sjlj_fc_lsda_ofs;
 static int sjlj_fc_jbuf_ofs;
+
+/* Each region does exactly one thing.  */
+enum eh_region_type
+{
+  ERT_UNKNOWN = 0,
+  ERT_CLEANUP,
+  ERT_TRY,
+  ERT_CATCH,
+  ERT_ALLOWED_EXCEPTIONS,
+  ERT_MUST_NOT_THROW,
+  ERT_THROW
+};
 
 /* Describes one exception region.  */
-struct eh_region GTY(())
+struct eh_region_def GTY(())
 {
   /* The immediately surrounding region.  */
-  struct eh_region *outer;
+  struct eh_region_def *outer;
 
   /* The list of immediately contained regions.  */
-  struct eh_region *inner;
-  struct eh_region *next_peer;
+  struct eh_region_def *inner;
+  struct eh_region_def *next_peer;
 
   /* An identifier for this region.  */
   int region_number;
@@ -133,34 +145,25 @@ struct eh_region GTY(())
   bitmap aka;
 
   /* Each region does exactly one thing.  */
-  enum eh_region_type
-  {
-    ERT_UNKNOWN = 0,
-    ERT_CLEANUP,
-    ERT_TRY,
-    ERT_CATCH,
-    ERT_ALLOWED_EXCEPTIONS,
-    ERT_MUST_NOT_THROW,
-    ERT_THROW
-  } type;
+  enum eh_region_type type;
 
   /* Holds the action to perform based on the preceding type.  */
   union eh_region_u {
     /* A list of catch blocks, a surrounding try block,
        and the label for continuing after a catch.  */
     struct eh_region_u_try {
-      struct eh_region *catch;
-      struct eh_region *last_catch;
-    } GTY ((tag ("ERT_TRY"))) try;
+      struct eh_region_def *current_catch;
+      struct eh_region_def *last_catch;
+    } GTY ((tag ("ERT_TRY"))) try_list;
 
     /* The list through the catch handlers, the list of type objects
        matched, and the list of associated filters.  */
     struct eh_region_u_catch {
-      struct eh_region *next_catch;
-      struct eh_region *prev_catch;
+      struct eh_region_def *next_catch;
+      struct eh_region_def *prev_catch;
       tree type_list;
       tree filter_list;
-    } GTY ((tag ("ERT_CATCH"))) catch;
+    } GTY ((tag ("ERT_CATCH"))) catch_list;
 
     /* A tree_list of allowed types.  */
     struct eh_region_u_allowed {
@@ -172,12 +175,12 @@ struct eh_region GTY(())
        for a throw.  */
     struct eh_region_u_throw {
       tree type;
-    } GTY ((tag ("ERT_THROW"))) throw;
+    } GTY ((tag ("ERT_THROW"))) throw_type;
 
     /* Retain the cleanup expression even after expansion so that
        we can match up fixup regions.  */
     struct eh_region_u_cleanup {
-      struct eh_region *prev_try;
+      struct eh_region_def *prev_try;
     } GTY ((tag ("ERT_CLEANUP"))) cleanup;
   } GTY ((desc ("%0.type"))) u;
 
@@ -199,7 +202,11 @@ struct eh_region GTY(())
   unsigned may_contain_throw : 1;
 };
 
-typedef struct eh_region *eh_region;
+#ifdef __GENGTYPE__
+/* This dummy typdef is required by gengtype which does not handle the
+   forward declaration in except.h */
+typedef struct eh_region_def * eh_region;
+#endif
 
 struct call_site_record GTY(())
 {
@@ -214,16 +221,16 @@ DEF_VEC_ALLOC_P(eh_region, gc);
 struct eh_status GTY(())
 {
   /* The tree of all regions for this function.  */
-  struct eh_region *region_tree;
+  eh_region region_tree;
 
   /* The same information as an indexable array.  */
   VEC(eh_region,gc) *region_array;
 
   /* The most recently open region.  */
-  struct eh_region *cur_region;
+  eh_region cur_region;
 
   /* This is the region for which we are processing catch blocks.  */
-  struct eh_region *try_region;
+  eh_region try_region;
 
   rtx filter;
   rtx exc_ptr;
@@ -281,9 +288,9 @@ static void sjlj_build_landing_pads (voi
 
 static hashval_t ehl_hash (const void *);
 static int ehl_eq (const void *, const void *);
-static void add_ehl_entry (rtx, struct eh_region *);
+static void add_ehl_entry (rtx, eh_region);
 static void remove_exception_handler_label (rtx);
-static void remove_eh_handler (struct eh_region *);
+static void remove_eh_handler (eh_region);
 static int for_each_eh_label_1 (void **, void *);
 
 /* The return value of reachable_next_level.  */
@@ -300,13 +307,13 @@ enum reachable_code
 };
 
 struct reachable_info;
-static enum reachable_code reachable_next_level (struct eh_region *, tree,
+static enum reachable_code reachable_next_level (eh_region, tree,
 						 struct reachable_info *);
 
 static int action_record_eq (const void *, const void *);
 static hashval_t action_record_hash (const void *);
 static int add_action_record (htab_t, int, int);
-static int collect_one_action_chain (htab_t, struct eh_region *);
+static int collect_one_action_chain (htab_t, eh_region);
 static int add_call_site (rtx, int);
 
 static void push_uleb128 (varray_type *, unsigned int);
@@ -438,60 +445,60 @@ init_eh (void)
 void
 init_eh_for_function (void)
 {
-  cfun->eh = ggc_alloc_cleared (sizeof (struct eh_status));
+  cfun->eh = GGC_CNEW (struct eh_status);
 }
 
 /* Routines to generate the exception tree somewhat directly.
    These are used from tree-eh.c when processing exception related
    nodes during tree optimization.  */
 
-static struct eh_region *
-gen_eh_region (enum eh_region_type type, struct eh_region *outer)
+static eh_region
+gen_eh_region (enum eh_region_type type, eh_region outer)
 {
-  struct eh_region *new;
+  eh_region new_region;
 
 #ifdef ENABLE_CHECKING
   gcc_assert (doing_eh (0));
 #endif
 
   /* Insert a new blank region as a leaf in the tree.  */
-  new = ggc_alloc_cleared (sizeof (*new));
-  new->type = type;
-  new->outer = outer;
+  new_region = GGC_CNEW (struct eh_region_def);
+  new_region->type = type;
+  new_region->outer = outer;
   if (outer)
     {
-      new->next_peer = outer->inner;
-      outer->inner = new;
+      new_region->next_peer = outer->inner;
+      outer->inner = new_region;
     }
   else
     {
-      new->next_peer = cfun->eh->region_tree;
-      cfun->eh->region_tree = new;
+      new_region->next_peer = cfun->eh->region_tree;
+      cfun->eh->region_tree = new_region;
     }
 
-  new->region_number = ++cfun->eh->last_region_number;
+  new_region->region_number = ++cfun->eh->last_region_number;
 
-  return new;
+  return new_region;
 }
 
-struct eh_region *
-gen_eh_region_cleanup (struct eh_region *outer, struct eh_region *prev_try)
+eh_region
+gen_eh_region_cleanup (eh_region outer, eh_region prev_try)
 {
-  struct eh_region *cleanup = gen_eh_region (ERT_CLEANUP, outer);
+  eh_region cleanup = gen_eh_region (ERT_CLEANUP, outer);
   cleanup->u.cleanup.prev_try = prev_try;
   return cleanup;
 }
 
-struct eh_region *
-gen_eh_region_try (struct eh_region *outer)
+eh_region
+gen_eh_region_try (eh_region outer)
 {
   return gen_eh_region (ERT_TRY, outer);
 }
 
-struct eh_region *
-gen_eh_region_catch (struct eh_region *t, tree type_or_list)
+eh_region
+gen_eh_region_catch (eh_region t, tree type_or_list)
 {
-  struct eh_region *c, *l;
+  eh_region c, l;
   tree type_list, type_node;
 
   /* Ensure to always end up with a type list to normalize further
@@ -508,22 +515,22 @@ gen_eh_region_catch (struct eh_region *t
     }
 
   c = gen_eh_region (ERT_CATCH, t->outer);
-  c->u.catch.type_list = type_list;
-  l = t->u.try.last_catch;
-  c->u.catch.prev_catch = l;
+  c->u.catch_list.type_list = type_list;
+  l = t->u.try_list.last_catch;
+  c->u.catch_list.prev_catch = l;
   if (l)
-    l->u.catch.next_catch = c;
+    l->u.catch_list.next_catch = c;
   else
-    t->u.try.catch = c;
-  t->u.try.last_catch = c;
+    t->u.try_list.current_catch = c;
+  t->u.try_list.last_catch = c;
 
   return c;
 }
 
-struct eh_region *
-gen_eh_region_allowed (struct eh_region *outer, tree allowed)
+eh_region
+gen_eh_region_allowed (eh_region outer, tree allowed)
 {
-  struct eh_region *region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
+  eh_region region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
   region->u.allowed.type_list = allowed;
 
   for (; allowed ; allowed = TREE_CHAIN (allowed))
@@ -532,32 +539,32 @@ gen_eh_region_allowed (struct eh_region 
   return region;
 }
 
-struct eh_region *
-gen_eh_region_must_not_throw (struct eh_region *outer)
+eh_region
+gen_eh_region_must_not_throw (eh_region outer)
 {
   return gen_eh_region (ERT_MUST_NOT_THROW, outer);
 }
 
 int
-get_eh_region_number (struct eh_region *region)
+get_eh_region_number (eh_region region)
 {
   return region->region_number;
 }
 
 bool
-get_eh_region_may_contain_throw (struct eh_region *region)
+get_eh_region_may_contain_throw (eh_region region)
 {
   return region->may_contain_throw;
 }
 
 tree
-get_eh_region_tree_label (struct eh_region *region)
+get_eh_region_tree_label (eh_region region)
 {
   return region->tree_label;
 }
 
 void
-set_eh_region_tree_label (struct eh_region *region, tree lab)
+set_eh_region_tree_label (eh_region region, tree lab)
 {
   region->tree_label = lab;
 }
@@ -566,8 +573,8 @@ void
 expand_resx_expr (tree exp)
 {
   int region_nr = TREE_INT_CST_LOW (TREE_OPERAND (exp, 0));
-  struct eh_region *reg = VEC_index (eh_region,
-				     cfun->eh->region_array, region_nr);
+  eh_region reg = VEC_index (eh_region,
+			     cfun->eh->region_array, region_nr);
 
   gcc_assert (!reg->resume);
   reg->resume = emit_jump_insn (gen_rtx_RESX (VOIDmode, region_nr));
@@ -578,7 +585,7 @@ expand_resx_expr (tree exp)
    call to a function which itself may contain a throw.  */
 
 void
-note_eh_region_may_contain_throw (struct eh_region *region)
+note_eh_region_may_contain_throw (eh_region region)
 {
   while (region && !region->may_contain_throw)
     {
@@ -631,7 +638,7 @@ get_exception_filter (struct function *f
 void
 collect_eh_region_array (void)
 {
-  struct eh_region *i;
+  eh_region i;
 
   i = cfun->eh->region_tree;
   if (! i)
@@ -671,11 +678,11 @@ remove_unreachable_regions (rtx insns)
 {
   int i, *uid_region_num;
   bool *reachable;
-  struct eh_region *r;
+  eh_region r;
   rtx insn;
 
-  uid_region_num = xcalloc (get_max_uid (), sizeof(int));
-  reachable = xcalloc (cfun->eh->last_region_number + 1, sizeof(bool));
+  uid_region_num = XCNEWVEC (int, get_max_uid ());
+  reachable = XCNEWVEC (bool, cfun->eh->last_region_number + 1);
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
@@ -724,8 +731,9 @@ remove_unreachable_regions (rtx insns)
 	      {
 		/* TRY regions are reachable if any of its CATCH regions
 		   are reachable.  */
-		struct eh_region *c;
-		for (c = r->u.try.catch; c ; c = c->u.catch.next_catch)
+		eh_region c;
+		for (c = r->u.try_list.current_catch; c ;
+		     c = c->u.catch_list.next_catch)
 		  if (reachable[c->region_number])
 		    {
 		      kill_it = false;
@@ -761,7 +769,7 @@ convert_from_eh_region_ranges (void)
      we allocated earlier.  */
   for (i = 1; i <= n; ++i)
     {
-      struct eh_region *region;
+      eh_region region;
 
       region = VEC_index (eh_region, cfun->eh->region_array, i);
       if (region && region->tree_label)
@@ -772,13 +780,13 @@ convert_from_eh_region_ranges (void)
 }
 
 static void
-add_ehl_entry (rtx label, struct eh_region *region)
+add_ehl_entry (rtx label, eh_region region)
 {
   struct ehl_map_entry **slot, *entry;
 
   LABEL_PRESERVE_P (label) = 1;
 
-  entry = ggc_alloc (sizeof (*entry));
+  entry = GGC_NEW (struct ehl_map_entry);
   entry->label = label;
   entry->region = region;
 
@@ -815,7 +823,7 @@ find_exception_handler_labels (void)
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
-      struct eh_region *region;
+      eh_region region;
       rtx lab;
 
       region = VEC_index (eh_region, cfun->eh->region_array, i);
@@ -845,7 +853,7 @@ current_function_has_exception_handlers 
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
-      struct eh_region *region;
+      eh_region region;
 
       region = VEC_index (eh_region, cfun->eh->region_array, i);
       if (region
@@ -885,11 +893,12 @@ duplicate_eh_regions_0 (eh_region o, int
    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)
+duplicate_eh_regions_1 (eh_region old, eh_region outer,
+			int eh_offset)
 {
   eh_region ret, n;
 
-  ret = n = ggc_alloc (sizeof (struct eh_region));
+  ret = n = GGC_NEW (struct eh_region_def);
 
   *n = *old;
   n->outer = outer;
@@ -1024,17 +1033,17 @@ duplicate_eh_regions (struct function *i
       switch (cur->type)
 	{
 	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);
+	  if (cur->u.try_list.current_catch)
+	    REMAP (cur->u.try_list.current_catch);
+	  if (cur->u.try_list.last_catch)
+	    REMAP (cur->u.try_list.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);
+	  if (cur->u.catch_list.next_catch)
+	    REMAP (cur->u.catch_list.next_catch);
+	  if (cur->u.catch_list.prev_catch)
+	    REMAP (cur->u.catch_list.prev_catch);
 	  break;
 
 	case ERT_CLEANUP:
@@ -1059,7 +1068,7 @@ duplicate_eh_regions (struct function *i
 bool
 eh_region_outer_p (struct function *ifun, int region_a, int region_b)
 {
-  struct eh_region *rp_a, *rp_b;
+  eh_region rp_a, rp_b;
 
   gcc_assert (ifun->eh->last_region_number > 0);
   gcc_assert (ifun->eh->region_tree);
@@ -1086,7 +1095,7 @@ eh_region_outer_p (struct function *ifun
 int
 eh_region_outermost (struct function *ifun, int region_a, int region_b)
 {
-  struct eh_region *rp_a, *rp_b;
+  eh_region rp_a, rp_b;
   sbitmap b_outer;
 
   gcc_assert (ifun->eh->last_region_number > 0);
@@ -1312,7 +1321,7 @@ assign_filter_values (void)
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
-      struct eh_region *r;
+      eh_region r;
 
       r = VEC_index (eh_region, cfun->eh->region_array, i);
 
@@ -1325,21 +1334,21 @@ assign_filter_values (void)
 	case ERT_CATCH:
 	  /* Whatever type_list is (NULL or true list), we build a list
 	     of filters for the region.  */
-	  r->u.catch.filter_list = NULL_TREE;
+	  r->u.catch_list.filter_list = NULL_TREE;
 
-	  if (r->u.catch.type_list != NULL)
+	  if (r->u.catch_list.type_list != NULL)
 	    {
 	      /* Get a filter value for each of the types caught and store
 		 them in the region's dedicated list.  */
-	      tree tp_node = r->u.catch.type_list;
+	      tree tp_node = r->u.catch_list.type_list;
 
 	      for (;tp_node; tp_node = TREE_CHAIN (tp_node))
 		{
 		  int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
 		  tree flt_node = build_int_cst (NULL_TREE, flt);
 
-		  r->u.catch.filter_list
-		    = tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
+		  r->u.catch_list.filter_list
+		    = tree_cons (NULL_TREE, flt_node, r->u.catch_list.filter_list);
 		}
 	    }
 	  else
@@ -1349,8 +1358,8 @@ assign_filter_values (void)
 	      int flt = add_ttypes_entry (ttypes, NULL);
 	      tree flt_node = build_int_cst (NULL_TREE, flt);
 
-	      r->u.catch.filter_list
-		= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
+	      r->u.catch_list.filter_list
+		= tree_cons (NULL_TREE, flt_node, r->u.catch_list.filter_list);
 	    }
 
 	  break;
@@ -1407,7 +1416,7 @@ build_post_landing_pads (void)
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
-      struct eh_region *region;
+      eh_region region;
       rtx seq;
 
       region = VEC_index (eh_region, cfun->eh->region_array, i);
@@ -1434,18 +1443,19 @@ build_post_landing_pads (void)
 	     switch statement generation code in expand_end_case.
 	     Rapid prototyping sez a sequence of ifs.  */
 	  {
-	    struct eh_region *c;
-	    for (c = region->u.try.catch; c ; c = c->u.catch.next_catch)
+	    eh_region c;
+	    for (c = region->u.try_list.current_catch; c ;
+		 c = c->u.catch_list.next_catch)
 	      {
-		if (c->u.catch.type_list == NULL)
+		if (c->u.catch_list.type_list == NULL)
 		  emit_jump (c->label);
 		else
 		  {
 		    /* Need for one cmp/jump per type caught. Each type
 		       list entry has a matching entry in the filter list
 		       (see assign_filter_values).  */
-		    tree tp_node = c->u.catch.type_list;
-		    tree flt_node = c->u.catch.filter_list;
+		    tree tp_node = c->u.catch_list.type_list;
+		    tree flt_node = c->u.catch_list.filter_list;
 
 		    for (; tp_node; )
 		      {
@@ -1472,7 +1482,7 @@ build_post_landing_pads (void)
 	  seq = get_insns ();
 	  end_sequence ();
 
-	  emit_to_new_bb_before (seq, region->u.try.catch->label);
+	  emit_to_new_bb_before (seq, region->u.try_list.current_catch->label);
 
 	  break;
 
@@ -1527,8 +1537,8 @@ connect_post_landing_pads (void)
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
-      struct eh_region *region;
-      struct eh_region *outer;
+      eh_region region;
+      eh_region outer;
       rtx seq;
       rtx barrier;
 
@@ -1604,7 +1614,7 @@ dw2_build_landing_pads (void)
 
   for (i = cfun->eh->last_region_number; i > 0; --i)
     {
-      struct eh_region *region;
+      eh_region region;
       rtx seq;
       basic_block bb;
       edge e;
@@ -1669,7 +1679,7 @@ sjlj_find_directly_reachable_regions (st
 
   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
     {
-      struct eh_region *region;
+      eh_region region;
       enum reachable_code rc;
       tree type_thrown;
       rtx note;
@@ -1686,7 +1696,7 @@ sjlj_find_directly_reachable_regions (st
       type_thrown = NULL_TREE;
       if (region->type == ERT_THROW)
 	{
-	  type_thrown = region->u.throw.type;
+	  type_thrown = region->u.throw_type.type;
 	  region = region->outer;
 	}
 
@@ -1723,7 +1733,7 @@ sjlj_assign_call_site_values (rtx dispat
   for (i = cfun->eh->last_region_number; i > 0; --i)
     if (lp_info[i].directly_reachable)
       {
-	struct eh_region *r = VEC_index (eh_region, cfun->eh->region_array, i);
+	eh_region r = VEC_index (eh_region, cfun->eh->region_array, i);
 
 	r->landing_pad = dispatch_label;
 	lp_info[i].action_index = collect_one_action_chain (ar_hash, r);
@@ -1780,7 +1790,7 @@ sjlj_mark_call_sites (struct sjlj_lp_inf
 
   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
     {
-      struct eh_region *region;
+      eh_region region;
       int this_call_site;
       rtx note, before, p;
 
@@ -2021,14 +2031,14 @@ sjlj_emit_dispatch_table (rtx dispatch_l
 
       emit_cmp_and_jump_insns (dispatch, GEN_INT (lp_info[i].dispatch_index),
 			       EQ, NULL_RTX, TYPE_MODE (integer_type_node), 0,
-	                       ((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, i))
+	                       ((eh_region)VEC_index (eh_region, cfun->eh->region_array, i))
 				->post_landing_pad);
     }
 
   seq = get_insns ();
   end_sequence ();
 
-  before = (((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, first_reachable))
+  before = (((eh_region)VEC_index (eh_region, cfun->eh->region_array, first_reachable))
 	    ->post_landing_pad);
 
   bb = emit_to_new_bb_before (seq, before);
@@ -2168,9 +2178,9 @@ remove_exception_handler_label (rtx labe
 /* Splice REGION from the region tree etc.  */
 
 static void
-remove_eh_handler (struct eh_region *region)
+remove_eh_handler (eh_region region)
 {
-  struct eh_region **pp, **pp_start, *p, *outer, *inner;
+  eh_region *pp, *pp_start, p, outer, inner;
   rtx lab;
 
   /* For the benefit of efficiently handling REG_EH_REGION notes,
@@ -2229,28 +2239,28 @@ remove_eh_handler (struct eh_region *reg
 
   if (region->type == ERT_CATCH)
     {
-      struct eh_region *try, *next, *prev;
+      eh_region try_region, next, prev;
 
-      for (try = region->next_peer;
-	   try->type == ERT_CATCH;
-	   try = try->next_peer)
+      for (try_region = region->next_peer;
+	   try_region->type == ERT_CATCH;
+	   try_region = try_region->next_peer)
 	continue;
-      gcc_assert (try->type == ERT_TRY);
+      gcc_assert (try_region->type == ERT_TRY);
 
-      next = region->u.catch.next_catch;
-      prev = region->u.catch.prev_catch;
+      next = region->u.catch_list.next_catch;
+      prev = region->u.catch_list.prev_catch;
 
       if (next)
-	next->u.catch.prev_catch = prev;
+	next->u.catch_list.prev_catch = prev;
       else
-	try->u.try.last_catch = prev;
+	try_region->u.try_list.last_catch = prev;
       if (prev)
-	prev->u.catch.next_catch = next;
+	prev->u.catch_list.next_catch = next;
       else
 	{
-	  try->u.try.catch = next;
+	  try_region->u.try_list.current_catch = next;
 	  if (! next)
-	    remove_eh_handler (try);
+	    remove_eh_handler (try_region);
 	}
     }
 }
@@ -2263,7 +2273,7 @@ void
 maybe_remove_eh_handler (rtx label)
 {
   struct ehl_map_entry **slot, tmp;
-  struct eh_region *region;
+  eh_region region;
 
   /* ??? After generating landing pads, it's not so simple to determine
      if the region data is completely unused.  One must examine the
@@ -2317,12 +2327,12 @@ for_each_eh_label_1 (void **pentry, void
 /* Invoke CALLBACK for every exception region in the current function.  */
 
 void
-for_each_eh_region (void (*callback) (struct eh_region *))
+for_each_eh_region (void (*callback) (eh_region))
 {
   int i, n = cfun->eh->last_region_number;
   for (i = 1; i <= n; ++i)
     {
-      struct eh_region *region;
+      eh_region region;
 
       region = VEC_index (eh_region, cfun->eh->region_array, i);
       if (region)
@@ -2337,7 +2347,7 @@ struct reachable_info
 {
   tree types_caught;
   tree types_allowed;
-  void (*callback) (struct eh_region *, void *);
+  void (*callback) (eh_region, void *);
   void *callback_data;
   bool saw_any_handlers;
 };
@@ -2377,7 +2387,7 @@ check_handled (tree handled, tree type)
 
 static void
 add_reachable_handler (struct reachable_info *info,
-		       struct eh_region *lp_region, struct eh_region *region)
+		       eh_region lp_region, eh_region region)
 {
   if (! info)
     return;
@@ -2396,7 +2406,7 @@ add_reachable_handler (struct reachable_
    and caught/allowed type information between invocations.  */
 
 static enum reachable_code
-reachable_next_level (struct eh_region *region, tree type_thrown,
+reachable_next_level (eh_region region, tree type_thrown,
 		      struct reachable_info *info)
 {
   switch (region->type)
@@ -2410,13 +2420,14 @@ reachable_next_level (struct eh_region *
 
     case ERT_TRY:
       {
-	struct eh_region *c;
+	eh_region c;
 	enum reachable_code ret = RNL_NOT_CAUGHT;
 
-	for (c = region->u.try.catch; c ; c = c->u.catch.next_catch)
+	for (c = region->u.try_list.current_catch; c ;
+	     c = c->u.catch_list.next_catch)
 	  {
 	    /* A catch-all handler ends the search.  */
-	    if (c->u.catch.type_list == NULL)
+	    if (c->u.catch_list.type_list == NULL)
 	      {
 		add_reachable_handler (info, region, c);
 		return RNL_CAUGHT;
@@ -2425,7 +2436,7 @@ reachable_next_level (struct eh_region *
 	    if (type_thrown)
 	      {
 		/* If we have at least one type match, end the search.  */
-		tree tp_node = c->u.catch.type_list;
+		tree tp_node = c->u.catch_list.type_list;
 
 		for (; tp_node; tp_node = TREE_CHAIN (tp_node))
 		  {
@@ -2463,7 +2474,7 @@ reachable_next_level (struct eh_region *
 	      ret = RNL_MAYBE_CAUGHT;
 	    else
 	      {
-		tree tp_node = c->u.catch.type_list;
+		tree tp_node = c->u.catch_list.type_list;
 		bool maybe_reachable = false;
 
 		/* Compute the potential reachability of this handler and
@@ -2563,11 +2574,11 @@ reachable_next_level (struct eh_region *
 
 void
 foreach_reachable_handler (int region_number, bool is_resx,
-			   void (*callback) (struct eh_region *, void *),
+			   void (*callback) (eh_region , void *),
 			   void *callback_data)
 {
   struct reachable_info info;
-  struct eh_region *region;
+  eh_region region;
   tree type_thrown;
 
   memset (&info, 0, sizeof (info));
@@ -2587,7 +2598,7 @@ foreach_reachable_handler (int region_nu
     }
   else if (region->type == ERT_THROW)
     {
-      type_thrown = region->u.throw.type;
+      type_thrown = region->u.throw_type.type;
       region = region->outer;
     }
 
@@ -2610,17 +2621,17 @@ foreach_reachable_handler (int region_nu
    reached by a given insn.  */
 
 static void
-arh_to_landing_pad (struct eh_region *region, void *data)
+arh_to_landing_pad (eh_region region, void *data)
 {
-  rtx *p_handlers = data;
+  rtx *p_handlers = (rtx *) data;
   if (! *p_handlers)
     *p_handlers = alloc_INSN_LIST (region->landing_pad, NULL_RTX);
 }
 
 static void
-arh_to_label (struct eh_region *region, void *data)
+arh_to_label (eh_region region, void *data)
 {
-  rtx *p_handlers = data;
+  rtx *p_handlers = (rtx *) data;
   *p_handlers = alloc_INSN_LIST (region->label, *p_handlers);
 }
 
@@ -2660,7 +2671,7 @@ reachable_handlers (rtx insn)
 bool
 can_throw_internal_1 (int region_number, bool is_resx)
 {
-  struct eh_region *region;
+  eh_region region;
   tree type_thrown;
 
   region = VEC_index (eh_region, cfun->eh->region_array, region_number);
@@ -2670,7 +2681,7 @@ can_throw_internal_1 (int region_number,
     region = region->outer;
   else if (region->type == ERT_THROW)
     {
-      type_thrown = region->u.throw.type;
+      type_thrown = region->u.throw_type.type;
       region = region->outer;
     }
 
@@ -2720,7 +2731,7 @@ can_throw_internal (rtx insn)
 bool
 can_throw_external_1 (int region_number, bool is_resx)
 {
-  struct eh_region *region;
+  eh_region region;
   tree type_thrown;
 
   region = VEC_index (eh_region, cfun->eh->region_array, region_number);
@@ -2730,7 +2741,7 @@ can_throw_external_1 (int region_number,
     region = region->outer;
   else if (region->type == ERT_THROW)
     {
-      type_thrown = region->u.throw.type;
+      type_thrown = region->u.throw_type.type;
       region = region->outer;
     }
 
@@ -3070,19 +3081,19 @@ action_record_hash (const void *pentry)
 static int
 add_action_record (htab_t ar_hash, int filter, int next)
 {
-  struct action_record **slot, *new, tmp;
+  struct action_record **slot, *new_record, tmp;
 
   tmp.filter = filter;
   tmp.next = next;
   slot = (struct action_record **) htab_find_slot (ar_hash, &tmp, INSERT);
 
-  if ((new = *slot) == NULL)
+  if ((new_record = *slot) == NULL)
     {
-      new = xmalloc (sizeof (*new));
-      new->offset = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
-      new->filter = filter;
-      new->next = next;
-      *slot = new;
+      new_record = XNEW (struct action_record);
+      new_record->offset = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
+      new_record->filter = filter;
+      new_record->next = next;
+      *slot = new_record;
 
       /* The filter value goes in untouched.  The link to the next
 	 record is a "self-relative" byte offset, or zero to indicate
@@ -3095,13 +3106,13 @@ add_action_record (htab_t ar_hash, int f
       push_sleb128 (&cfun->eh->action_record_data, next);
     }
 
-  return new->offset;
+  return new_record->offset;
 }
 
 static int
-collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
+collect_one_action_chain (htab_t ar_hash, eh_region region)
 {
-  struct eh_region *c;
+  eh_region c;
   int next;
 
   /* If we've reached the top of the region chain, then we have
@@ -3132,14 +3143,15 @@ collect_one_action_chain (htab_t ar_hash
 	 search outer regions.  Use a magic -3 value to record
 	 that we haven't done the outer search.  */
       next = -3;
-      for (c = region->u.try.last_catch; c ; c = c->u.catch.prev_catch)
+      for (c = region->u.try_list.last_catch; c ;
+	   c = c->u.catch_list.prev_catch)
 	{
-	  if (c->u.catch.type_list == NULL)
+	  if (c->u.catch_list.type_list == NULL)
 	    {
 	      /* Retrieve the filter from the head of the filter list
 		 where we have stored it (see assign_filter_values).  */
 	      int filter
-		= TREE_INT_CST_LOW (TREE_VALUE (c->u.catch.filter_list));
+		= TREE_INT_CST_LOW (TREE_VALUE (c->u.catch_list.filter_list));
 
 	      next = add_action_record (ar_hash, filter, 0);
 	    }
@@ -3164,7 +3176,7 @@ collect_one_action_chain (htab_t ar_hash
 		    next = add_action_record (ar_hash, 0, 0);
 		}
 
-	      flt_node = c->u.catch.filter_list;
+	      flt_node = c->u.catch_list.filter_list;
 	      for (; flt_node; flt_node = TREE_CHAIN (flt_node))
 		{
 		  int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node));
@@ -3219,7 +3231,7 @@ add_call_site (rtx landing_pad, int acti
   if (used >= size)
     {
       size = (size ? size * 2 : 64);
-      data = ggc_realloc (data, sizeof (*data) * size);
+      data = GGC_RESIZEVEC (struct call_site_record, data, size);
       cfun->eh->call_site_data = data;
       cfun->eh->call_site_data_size = size;
     }
@@ -3257,7 +3269,7 @@ convert_to_eh_region_ranges (void)
   for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
     if (INSN_P (iter))
       {
-	struct eh_region *region;
+	eh_region region;
 	int this_action;
 	rtx this_landing_pad;
 
@@ -3301,7 +3313,7 @@ convert_to_eh_region_ranges (void)
 	   landing pads.  Collect the landing pad for this region.  */
 	if (this_action >= 0)
 	  {
-	    struct eh_region *o;
+	    eh_region o;
 	    for (o = region; ! o->landing_pad ; o = o->outer)
 	      continue;
 	    this_landing_pad = o->landing_pad;
@@ -3552,7 +3564,7 @@ switch_to_exception_section (const char 
 #ifdef HAVE_LD_EH_GC_SECTIONS
 	  if (flag_function_sections)
 	    {
-	      char *section_name = xmalloc (strlen (fnname) + 32);
+	      char *section_name = XNEWVEC (char, strlen (fnname) + 32);
 	      sprintf (section_name, ".gcc_except_table.%s", fnname);
 	      s = get_section (section_name, flags, NULL);
 	      free (section_name);
@@ -3580,7 +3592,7 @@ static void
 output_ttype (tree type, int tt_format, int tt_format_size)
 {
   rtx value;
-  bool public = true;
+  bool public_symbol = true;
 
   if (type == NULL_TREE)
     value = const0_rtx;
@@ -3603,7 +3615,7 @@ output_ttype (tree type, int tt_format, 
 	      node = varpool_node (type);
 	      if (node)
 		varpool_mark_needed_node (node);
-	      public = TREE_PUBLIC (type);
+	      public_symbol = TREE_PUBLIC (type);
 	    }
 	}
       else
@@ -3618,7 +3630,7 @@ output_ttype (tree type, int tt_format, 
     assemble_integer (value, tt_format_size,
 		      tt_format_size * BITS_PER_UNIT, 1);
   else
-    dw2_asm_output_encoded_addr_rtx (tt_format, value, public, NULL);
+    dw2_asm_output_encoded_addr_rtx (tt_format, value, public_symbol, NULL);
 }
 
 void
@@ -3826,7 +3838,7 @@ get_eh_throw_stmt_table (struct function
 void
 dump_eh_tree (FILE *out, struct function *fun)
 {
-  struct eh_region *i;
+  eh_region i;
   int depth = 0;
   static const char * const type_name[] = {"unknown", "cleanup", "try", "catch",
 					   "allowed_exceptions", "must_not_throw",
@@ -3872,7 +3884,7 @@ dump_eh_tree (FILE *out, struct function
 void
 verify_eh_tree (struct function *fun)
 {
-  struct eh_region *i, *outer = NULL;
+  eh_region i, outer = NULL;
   bool err = false;
   int nvisited = 0;
   int count = 0;
Index: gcc/except.h
===================================================================
--- gcc/except.h	(revision 124739)
+++ gcc/except.h	(working copy)
@@ -28,14 +28,17 @@ struct function;
 struct eh_status;
 
 /* Internal structure describing a region.  */
-struct eh_region;
+struct eh_region_def;
+
+/** Pointer to a region */
+typedef struct eh_region_def* eh_region;
 
 /* Test: is exception handling turned on?  */
 extern int doing_eh (int);
 
 /* Note that the current EH region (if any) may contain a throw, or a
    call to a function which itself may contain a throw.  */
-extern void note_eh_region_may_contain_throw (struct eh_region *);
+extern void note_eh_region_may_contain_throw (eh_region);
 extern void note_current_region_may_contain_throw (void);
 
 /* Invokes CALLBACK for every exception handler label.  Only used by old
@@ -43,7 +46,7 @@ extern void note_current_region_may_cont
 extern void for_each_eh_label (void (*) (rtx));
 
 /* Invokes CALLBACK for every exception region in the current function.  */
-extern void for_each_eh_region (void (*) (struct eh_region *));
+extern void for_each_eh_region (void (*) (eh_region));
 
 /* Determine if the given INSN can throw an exception.  */
 extern bool can_throw_internal_1 (int, bool);
@@ -88,19 +91,19 @@ extern int duplicate_eh_regions (struct 
 extern void sjlj_emit_function_exit_after (rtx);
 extern void default_init_unwind_resume_libfunc (void);
 
-extern struct eh_region *gen_eh_region_cleanup (struct eh_region *,
-						struct eh_region *);
-extern struct eh_region *gen_eh_region_try (struct eh_region *);
-extern struct eh_region *gen_eh_region_catch (struct eh_region *, tree);
-extern struct eh_region *gen_eh_region_allowed (struct eh_region *, tree);
-extern struct eh_region *gen_eh_region_must_not_throw (struct eh_region *);
-extern int get_eh_region_number (struct eh_region *);
-extern bool get_eh_region_may_contain_throw (struct eh_region *);
-extern tree get_eh_region_tree_label (struct eh_region *);
-extern void set_eh_region_tree_label (struct eh_region *, tree);
+extern eh_region gen_eh_region_cleanup (eh_region,
+					eh_region);
+extern eh_region gen_eh_region_try (eh_region);
+extern eh_region gen_eh_region_catch (eh_region, tree);
+extern eh_region gen_eh_region_allowed (eh_region, tree);
+extern eh_region gen_eh_region_must_not_throw (eh_region);
+extern int get_eh_region_number (eh_region);
+extern bool get_eh_region_may_contain_throw (eh_region);
+extern tree get_eh_region_tree_label (eh_region);
+extern void set_eh_region_tree_label (eh_region, tree);
 
 extern void foreach_reachable_handler (int, bool,
-				       void (*) (struct eh_region *, void *),
+				       void (*) (eh_region, void *),
 				       void *);
 
 extern void collect_eh_region_array (void);
Index: gcc/tree-cfg.c
===================================================================
--- gcc/tree-cfg.c	(revision 124739)
+++ gcc/tree-cfg.c	(working copy)
@@ -847,7 +847,7 @@ static struct label_record
 
 /* Callback for for_each_eh_region.  Helper for cleanup_dead_labels.  */
 static void
-update_eh_label (struct eh_region *region)
+update_eh_label (eh_region region)
 {
   tree old_label = get_eh_region_tree_label (region);
   if (old_label)
@@ -2726,7 +2726,7 @@ bsi_insert_before (block_stmt_iterator *
 {
   set_bb_for_stmt (t, i->bb);
   update_modified_stmts (t);
-  tsi_link_before (&i->tsi, t, m);
+  tsi_link_before (&i->tsi, t, (enum tsi_iterator_update) m);
 }
 
 
@@ -2739,7 +2739,7 @@ bsi_insert_after (block_stmt_iterator *i
 {
   set_bb_for_stmt (t, i->bb);
   update_modified_stmts (t);
-  tsi_link_after (&i->tsi, t, m);
+  tsi_link_after (&i->tsi, t, (enum tsi_iterator_update) m);
 }
 
 
@@ -4538,7 +4538,9 @@ move_stmt_r (tree *tp, int *walk_subtree
 	    {
 	      struct tree_map in, *out;
 	      in.base.from = t;
-	      out = htab_find_with_hash (p->new_label_map, &in, DECL_UID (t));
+	      out = (struct tree_map *) htab_find_with_hash (p->new_label_map,
+							     &in,
+							     DECL_UID (t));
 	      if (out)
 		*tp = t = out->to;
 	    }
@@ -4727,7 +4729,7 @@ new_label_mapper (tree decl, void *data)
 
   gcc_assert (TREE_CODE (decl) == LABEL_DECL);
 
-  m = xmalloc (sizeof (struct tree_map));
+  m = XNEW (struct tree_map);
   m->hash = DECL_UID (decl);
   m->base.from = decl;
   m->to = create_artificial_label ();