CbC/CbC_gcc: gcc/except.c comparison

comparison gcc/except.c @ 111:04ced10e8804

gcc 7

author	kono
date	Fri, 27 Oct 2017 22:46:09 +0900
parents	f6334be47118
children	84e7813d76e9

comparison

equal deleted inserted replaced

-:561a7518be6b
+:04ced10e8804
 /* Implements exception handling.
-Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+Copyright (C) 1989-2017 Free Software Foundation, Inc.
-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-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
 During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
 that create an rtl to eh_region mapping that corresponds to the
 gimple to eh_region mapping that had been recorded in the
 THROW_STMT_TABLE.
-During pass_rtl_eh (except.c), we generate the real landing pads
+Then, via finish_eh_generation, we generate the real landing pads
 to which the runtime will actually transfer control.  These new
 landing pads perform whatever bookkeeping is needed by the target
 backend in order to resume execution within the current function.
 Each of these new landing pads falls through into the post_landing_pad
 label which had been used within the CFG up to this point.  All
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
+#include "target.h"
 #include "rtl.h"
 #include "tree.h"
-#include "flags.h"
+#include "cfghooks.h"
-#include "function.h"
+#include "tree-pass.h"
+#include "memmodel.h"
+#include "tm_p.h"
+#include "stringpool.h"
+#include "expmed.h"
+#include "optabs.h"
+#include "emit-rtl.h"
+#include "cgraph.h"
+#include "diagnostic.h"
+#include "fold-const.h"
+#include "stor-layout.h"
+#include "explow.h"
+#include "stmt.h"
 #include "expr.h"
+#include "calls.h"
 #include "libfuncs.h"
-#include "insn-config.h"
 #include "except.h"
-#include "integrate.h"
-#include "hard-reg-set.h"
-#include "basic-block.h"
 #include "output.h"
 #include "dwarf2asm.h"
 #include "dwarf2out.h"
-#include "dwarf2.h"
+#include "common/common-target.h"
-#include "toplev.h"
-#include "hashtab.h"
-#include "intl.h"
-#include "ggc.h"
-#include "tm_p.h"
-#include "target.h"
 #include "langhooks.h"
-#include "cgraph.h"
+#include "cfgrtl.h"
-#include "diagnostic.h"
 #include "tree-pretty-print.h"
-#include "tree-pass.h"
+#include "cfgloop.h"
-#include "timevar.h"
+#include "builtins.h"
-#include "tree-flow.h"
+#include "tree-hash-traits.h"
-/* Provide defaults for stuff that may not be defined when using
-sjlj exceptions.  */
-#ifndef EH_RETURN_DATA_REGNO
-#define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
-#endif
 static GTY(()) int call_site_base;
-static GTY ((param_is (union tree_node)))
-htab_t type_to_runtime_map;
+static GTY(()) hash_map<tree_hash, tree> *type_to_runtime_map;
+static GTY(()) tree setjmp_fn;
 /* Describe the SjLj_Function_Context structure.  */
 static GTY(()) tree sjlj_fc_type_node;
 static int sjlj_fc_call_site_ofs;
 static int sjlj_fc_data_ofs;
 struct GTY(()) call_site_record_d
 {
 rtx landing_pad;
 int action;
 };
+/* In the following structure and associated functions,
+we represent entries in the action table as 1-based indices.
+Special cases are:
+	 0:	null action record, non-null landing pad; implies cleanups
+	-1:	null action record, null landing pad; implies no action
+	-2:	no call-site entry; implies must_not_throw
+	-3:	we have yet to process outer regions
+Further, no special cases apply to the "next" field of the record.
+For next, 0 means end of list.  */
+struct action_record
+{
+int offset;
+int filter;
+int next;
+};
+/* Hashtable helpers.  */
+struct action_record_hasher : free_ptr_hash <action_record>
+{
+static inline hashval_t hash (const action_record *);
+static inline bool equal (const action_record *, const action_record *);
+};
+inline hashval_t
+action_record_hasher::hash (const action_record *entry)
+{
+return entry->next * 1009 + entry->filter;
+}
+inline bool
+action_record_hasher::equal (const action_record *entry,
+			     const action_record *data)
+{
+return entry->filter == data->filter && entry->next == data->next;
+}
+typedef hash_table<action_record_hasher> action_hash_type;
 static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *,
 					   eh_landing_pad *);
-static int t2r_eq (const void *, const void *);
-static hashval_t t2r_hash (const void *);
-static int ttypes_filter_eq (const void *, const void *);
-static hashval_t ttypes_filter_hash (const void *);
-static int ehspec_filter_eq (const void *, const void *);
-static hashval_t ehspec_filter_hash (const void *);
-static int add_ttypes_entry (htab_t, tree);
-static int add_ehspec_entry (htab_t, htab_t, tree);
 static void dw2_build_landing_pads (void);
-static int action_record_eq (const void *, const void *);
+static int collect_one_action_chain (action_hash_type *, eh_region);
-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, eh_region);
 static int add_call_site (rtx, int, int);
-static void push_uleb128 (VEC (uchar, gc) **, unsigned int);
+static void push_uleb128 (vec<uchar, va_gc> **, unsigned int);
-static void push_sleb128 (VEC (uchar, gc) **, int);
+static void push_sleb128 (vec<uchar, va_gc> **, int);
-#ifndef HAVE_AS_LEB128
 static int dw2_size_of_call_site_table (int);
 static int sjlj_size_of_call_site_table (void);
-#endif
 static void dw2_output_call_site_table (int, int);
 static void sjlj_output_call_site_table (void);
 void
 init_eh (void)
 {
 if (! flag_exceptions)
 return;
-type_to_runtime_map = htab_create_ggc (31, t2r_hash, t2r_eq, NULL);
+type_to_runtime_map = hash_map<tree_hash, tree>::create_ggc (31);
 /* Create the SjLj_Function_Context structure.  This should match
 the definition in unwind-sjlj.c.  */
-if (targetm.except_unwind_info (&global_options) == UI_SJLJ)
+if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
 {
 tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp;
 sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE);
 f_cs = build_decl (BUILTINS_LOCATION,
 			 FIELD_DECL, get_identifier ("__call_site"),
 			 integer_type_node);
 DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;
-tmp = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
+tmp = build_index_type (size_int (4 - 1));
 tmp = build_array_type (lang_hooks.types.type_for_mode
 				(targetm.unwind_word_mode (), 1),
 			      tmp);
 f_data = build_decl (BUILTINS_LOCATION,
 			   FIELD_DECL, get_identifier ("__data"), tmp);
 			   ptr_type_node);
 DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node;
 #ifdef DONT_USE_BUILTIN_SETJMP
 #ifdef JMP_BUF_SIZE
-tmp = build_int_cst (NULL_TREE, JMP_BUF_SIZE - 1);
+tmp = size_int (JMP_BUF_SIZE - 1);
 #else
 /* Should be large enough for most systems, if it is not,
 	 JMP_BUF_SIZE should be defined with the proper value.  It will
 	 also tend to be larger than necessary for most systems, a more
 	 optimal port will define JMP_BUF_SIZE.  */
-tmp = build_int_cst (NULL_TREE, FIRST_PSEUDO_REGISTER + 2 - 1);
+tmp = size_int (FIRST_PSEUDO_REGISTER + 2 - 1);
 #endif
 #else
-/* builtin_setjmp takes a pointer to 5 words.  */
+/* Compute a minimally sized jump buffer.  We need room to store at
-tmp = build_int_cst (NULL_TREE, 5 * BITS_PER_WORD / POINTER_SIZE - 1);
+	 least 3 pointers - stack pointer, frame pointer and return address.
+	 Plus for some targets we need room for an extra pointer - in the
+	 case of MIPS this is the global pointer.  This makes a total of four
+	 pointers, but to be safe we actually allocate room for 5.
+	 If pointers are smaller than words then we allocate enough room for
+	 5 words, just in case the backend needs this much room.  For more
+	 discussion on this issue see:
+	 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html.  */
+if (POINTER_SIZE > BITS_PER_WORD)
+	tmp = size_int (5 - 1);
+else
+	tmp = size_int ((5 * BITS_PER_WORD / POINTER_SIZE) - 1);
 #endif
 tmp = build_index_type (tmp);
 tmp = build_array_type (ptr_type_node, tmp);
 f_jbuf = build_decl (BUILTINS_LOCATION,
 			   FIELD_DECL, get_identifier ("__jbuf"), tmp);
 #ifdef DONT_USE_BUILTIN_SETJMP
 /* We don't know what the alignment requirements of the
 	 runtime's jmp_buf has.  Overestimate.  */
-DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT;
+SET_DECL_ALIGN (f_jbuf, BIGGEST_ALIGNMENT);
 DECL_USER_ALIGN (f_jbuf) = 1;
 #endif
 DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node;
 TYPE_FIELDS (sjlj_fc_type_node) = f_prev;
 layout_type (sjlj_fc_type_node);
 /* Cache the interesting field offsets so that we have
 	 easy access from rtl.  */
 sjlj_fc_call_site_ofs
-	= (tree_low_cst (DECL_FIELD_OFFSET (f_cs), 1)
+	= (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs))
-	   + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs), 1) / BITS_PER_UNIT);
+	   + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs)) / BITS_PER_UNIT);
 sjlj_fc_data_ofs
-	= (tree_low_cst (DECL_FIELD_OFFSET (f_data), 1)
+	= (tree_to_uhwi (DECL_FIELD_OFFSET (f_data))
-	   + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data), 1) / BITS_PER_UNIT);
+	   + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data)) / BITS_PER_UNIT);
 sjlj_fc_personality_ofs
-	= (tree_low_cst (DECL_FIELD_OFFSET (f_per), 1)
+	= (tree_to_uhwi (DECL_FIELD_OFFSET (f_per))
-	   + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per), 1) / BITS_PER_UNIT);
+	   + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per)) / BITS_PER_UNIT);
 sjlj_fc_lsda_ofs
-	= (tree_low_cst (DECL_FIELD_OFFSET (f_lsda), 1)
+	= (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda))
-	   + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda), 1) / BITS_PER_UNIT);
+	   + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda)) / BITS_PER_UNIT);
 sjlj_fc_jbuf_ofs
-	= (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf), 1)
+	= (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf))
-	   + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf), 1) / BITS_PER_UNIT);
+	   + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf)) / BITS_PER_UNIT);
+#ifdef DONT_USE_BUILTIN_SETJMP
+tmp = build_function_type_list (integer_type_node, TREE_TYPE (f_jbuf),
+				      NULL);
+setjmp_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
+			      get_identifier ("setjmp"), tmp);
+TREE_PUBLIC (setjmp_fn) = 1;
+DECL_EXTERNAL (setjmp_fn) = 1;
+DECL_ASSEMBLER_NAME (setjmp_fn);
+#endif
 }
 }
 void
 init_eh_for_function (void)
 {
-cfun->eh = ggc_alloc_cleared_eh_status ();
+cfun->eh = ggc_cleared_alloc<eh_status> ();
 /* Make sure zero'th entries are used.  */
-VEC_safe_push (eh_region, gc, cfun->eh->region_array, NULL);
+vec_safe_push (cfun->eh->region_array, (eh_region)0);
-VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, NULL);
+vec_safe_push (cfun->eh->lp_array, (eh_landing_pad)0);
 }
 /* Routines to generate the exception tree somewhat directly.
 These are used from tree-eh.c when processing exception related
 nodes during tree optimization.  */
 gen_eh_region (enum eh_region_type type, eh_region outer)
 {
 eh_region new_eh;
 /* Insert a new blank region as a leaf in the tree.  */
-new_eh = ggc_alloc_cleared_eh_region_d ();
+new_eh = ggc_cleared_alloc<eh_region_d> ();
 new_eh->type = type;
 new_eh->outer = outer;
 if (outer)
 {
 new_eh->next_peer = outer->inner;
 {
 new_eh->next_peer = cfun->eh->region_tree;
 cfun->eh->region_tree = new_eh;
 }
-new_eh->index = VEC_length (eh_region, cfun->eh->region_array);
+new_eh->index = vec_safe_length (cfun->eh->region_array);
-VEC_safe_push (eh_region, gc, cfun->eh->region_array, new_eh);
+vec_safe_push (cfun->eh->region_array, new_eh);
 /* Copy the language's notion of whether to use __cxa_end_cleanup.  */
 if (targetm.arm_eabi_unwinder && lang_hooks.eh_use_cxa_end_cleanup)
 new_eh->use_cxa_end_cleanup = true;
 type_node = type_list;
 for (; type_node; type_node = TREE_CHAIN (type_node))
 	add_type_for_runtime (TREE_VALUE (type_node));
 }
-c = ggc_alloc_cleared_eh_catch_d ();
+c = ggc_cleared_alloc<eh_catch_d> ();
 c->type_list = type_list;
 l = t->u.eh_try.last_catch;
 c->prev_catch = l;
 if (l)
 l->next_catch = c;
 }
 eh_landing_pad
 gen_eh_landing_pad (eh_region region)
 {
-eh_landing_pad lp = ggc_alloc_cleared_eh_landing_pad_d ();
+eh_landing_pad lp = ggc_cleared_alloc<eh_landing_pad_d> ();
 lp->next_lp = region->landing_pads;
 lp->region = region;
-lp->index = VEC_length (eh_landing_pad, cfun->eh->lp_array);
+lp->index = vec_safe_length (cfun->eh->lp_array);
 region->landing_pads = lp;
-VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, lp);
+vec_safe_push (cfun->eh->lp_array, lp);
 return lp;
 }
 eh_region
 get_eh_region_from_number_fn (struct function *ifun, int i)
 {
-return VEC_index (eh_region, ifun->eh->region_array, i);
+return (*ifun->eh->region_array)[i];
 }
 eh_region
 get_eh_region_from_number (int i)
 {
 }
 eh_landing_pad
 get_eh_landing_pad_from_number_fn (struct function *ifun, int i)
 {
-return VEC_index (eh_landing_pad, ifun->eh->lp_array, i);
+return (*ifun->eh->lp_array)[i];
 }
 eh_landing_pad
 get_eh_landing_pad_from_number (int i)
 {
 eh_region
 get_eh_region_from_lp_number_fn (struct function *ifun, int i)
 {
 if (i < 0)
-return VEC_index (eh_region, ifun->eh->region_array, -i);
+return (*ifun->eh->region_array)[-i];
 else if (i == 0)
 return NULL;
 else
 {
 eh_landing_pad lp;
-lp = VEC_index (eh_landing_pad, ifun->eh->lp_array, i);
+lp = (*ifun->eh->lp_array)[i];
 return lp->region;
 }
 }
 eh_region
 struct duplicate_eh_regions_data
 {
 duplicate_eh_regions_map label_map;
 void *label_map_data;
-struct pointer_map_t *eh_map;
+hash_map<void *, void *> *eh_map;
 };
 static void
 duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,
 			eh_region old_r, eh_region outer)
 {
 eh_landing_pad old_lp, new_lp;
 eh_region new_r;
-void **slot;
 new_r = gen_eh_region (old_r->type, outer);
-slot = pointer_map_insert (data->eh_map, (void *)old_r);
+gcc_assert (!data->eh_map->put (old_r, new_r));
-gcc_assert (*slot == NULL);
-*slot = (void *)new_r;
 switch (old_r->type)
 {
 case ERT_CLEANUP:
 break;
 else
 	new_r->u.allowed.label = NULL_TREE;
 break;
 case ERT_MUST_NOT_THROW:
-new_r->u.must_not_throw = old_r->u.must_not_throw;
+new_r->u.must_not_throw.failure_loc =
+	LOCATION_LOCUS (old_r->u.must_not_throw.failure_loc);
+new_r->u.must_not_throw.failure_decl =
+	old_r->u.must_not_throw.failure_decl;
 break;
 }
 for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp)
 {
 /* Don't bother copying unused landing pads.  */
 if (old_lp->post_landing_pad == NULL)
 	continue;
 new_lp = gen_eh_landing_pad (new_r);
-slot = pointer_map_insert (data->eh_map, (void *)old_lp);
+gcc_assert (!data->eh_map->put (old_lp, new_lp));
-gcc_assert (*slot == NULL);
-*slot = (void *)new_lp;
 new_lp->post_landing_pad
 	= data->label_map (old_lp->post_landing_pad, data->label_map_data);
 EH_LANDING_PAD_NR (new_lp->post_landing_pad) = new_lp->index;
 }
 The special case of COPY_REGION of NULL means all regions.
 Remap labels using MAP/MAP_DATA callback.  Return a pointer map
 that allows the caller to remap uses of both EH regions and
 EH landing pads.  */
-struct pointer_map_t *
+hash_map<void *, void *> *
 duplicate_eh_regions (struct function *ifun,
 		      eh_region copy_region, int outer_lp,
 		      duplicate_eh_regions_map map, void *map_data)
 {
 struct duplicate_eh_regions_data data;
 eh_region outer_region;
-#ifdef ENABLE_CHECKING
+if (flag_checking)
 verify_eh_tree (ifun);
-#endif
 data.label_map = map;
 data.label_map_data = map_data;
-data.eh_map = pointer_map_create ();
+data.eh_map = new hash_map<void *, void *>;
-outer_region = get_eh_region_from_lp_number (outer_lp);
+outer_region = get_eh_region_from_lp_number_fn (cfun, outer_lp);
 /* Copy all the regions in the subtree.  */
 if (copy_region)
 duplicate_eh_regions_1 (&data, copy_region, outer_region);
 else
 eh_region r;
 for (r = ifun->eh->region_tree; r ; r = r->next_peer)
 	duplicate_eh_regions_1 (&data, r, outer_region);
 }
-#ifdef ENABLE_CHECKING
+if (flag_checking)
 verify_eh_tree (cfun);
-#endif
 return data.eh_map;
 }
 /* Return the region that is outer to both REGION_A and REGION_B in IFUN.  */
 eh_region
 eh_region_outermost (struct function *ifun, eh_region region_a,
 		     eh_region region_b)
 {
-sbitmap b_outer;
 gcc_assert (ifun->eh->region_array);
 gcc_assert (ifun->eh->region_tree);
-b_outer = sbitmap_alloc (VEC_length (eh_region, ifun->eh->region_array));
+auto_sbitmap b_outer (ifun->eh->region_array->length ());
-sbitmap_zero (b_outer);
+bitmap_clear (b_outer);
 do
 {
-SET_BIT (b_outer, region_b->index);
+bitmap_set_bit (b_outer, region_b->index);
 region_b = region_b->outer;
 }
 while (region_b);
 do
 {
-if (TEST_BIT (b_outer, region_a->index))
+if (bitmap_bit_p (b_outer, region_a->index))
 	break;
 region_a = region_a->outer;
 }
 while (region_a);
-sbitmap_free (b_outer);
 return region_a;
 }
-static int
-t2r_eq (const void *pentry, const void *pdata)
-{
-const_tree const entry = (const_tree) pentry;
-const_tree const data = (const_tree) pdata;
-return TREE_PURPOSE (entry) == data;
-}
-static hashval_t
-t2r_hash (const void *pentry)
-{
-const_tree const entry = (const_tree) pentry;
-return TREE_HASH (TREE_PURPOSE (entry));
-}
 void
 add_type_for_runtime (tree type)
 {
-tree *slot;
 /* If TYPE is NOP_EXPR, it means that it already is a runtime type.  */
 if (TREE_CODE (type) == NOP_EXPR)
 return;
-slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
+bool existed = false;
-					    TREE_HASH (type), INSERT);
+tree *slot = &type_to_runtime_map->get_or_insert (type, &existed);
-if (*slot == NULL)
+if (!existed)
-{
+*slot = lang_hooks.eh_runtime_type (type);
-tree runtime = lang_hooks.eh_runtime_type (type);
-*slot = tree_cons (type, runtime, NULL_TREE);
-}
 }
 tree
 lookup_type_for_runtime (tree type)
 {
-tree *slot;
 /* If TYPE is NOP_EXPR, it means that it already is a runtime type.  */
 if (TREE_CODE (type) == NOP_EXPR)
 return type;
-slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
-					    TREE_HASH (type), NO_INSERT);
 /* We should have always inserted the data earlier.  */
-return TREE_VALUE (*slot);
+return *type_to_runtime_map->get (type);
 }
 /* Represent an entry in @TTypes for either catch actions
 or exception filter actions.  */
 struct ttypes_filter {
 tree t;
 int filter;
 };
+/* Helper for ttypes_filter hashing.  */
+struct ttypes_filter_hasher : free_ptr_hash <ttypes_filter>
+{
+typedef tree_node *compare_type;
+static inline hashval_t hash (const ttypes_filter *);
+static inline bool equal (const ttypes_filter *, const tree_node *);
+};
 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
 (a tree) for a @TTypes type node we are thinking about adding.  */
-static int
+inline bool
-ttypes_filter_eq (const void *pentry, const void *pdata)
+ttypes_filter_hasher::equal (const ttypes_filter *entry, const tree_node *data)
 {
-const struct ttypes_filter *const entry
-= (const struct ttypes_filter *) pentry;
-const_tree const data = (const_tree) pdata;
 return entry->t == data;
 }
-static hashval_t
+inline hashval_t
-ttypes_filter_hash (const void *pentry)
+ttypes_filter_hasher::hash (const ttypes_filter *entry)
 {
-const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
 return TREE_HASH (entry->t);
 }
+typedef hash_table<ttypes_filter_hasher> ttypes_hash_type;
+/* Helper for ehspec hashing.  */
+struct ehspec_hasher : free_ptr_hash <ttypes_filter>
+{
+static inline hashval_t hash (const ttypes_filter *);
+static inline bool equal (const ttypes_filter *, const ttypes_filter *);
+};
 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
 exception specification list we are thinking about adding.  */
 /* ??? Currently we use the type lists in the order given.  Someone
 should put these in some canonical order.  */
-static int
+inline bool
-ehspec_filter_eq (const void *pentry, const void *pdata)
+ehspec_hasher::equal (const ttypes_filter *entry, const ttypes_filter *data)
 {
-const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
-const struct ttypes_filter *data = (const struct ttypes_filter *) pdata;
 return type_list_equal (entry->t, data->t);
 }
 /* Hash function for exception specification lists.  */
-static hashval_t
+inline hashval_t
-ehspec_filter_hash (const void *pentry)
+ehspec_hasher::hash (const ttypes_filter *entry)
 {
-const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
 hashval_t h = 0;
 tree list;
 for (list = entry->t; list ; list = TREE_CHAIN (list))
 h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list));
 return h;
 }
+typedef hash_table<ehspec_hasher> ehspec_hash_type;
 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
 to speed up the search.  Return the filter value to be used.  */
 static int
-add_ttypes_entry (htab_t ttypes_hash, tree type)
+add_ttypes_entry (ttypes_hash_type *ttypes_hash, tree type)
 {
 struct ttypes_filter **slot, *n;
-slot = (struct ttypes_filter **)
+slot = ttypes_hash->find_slot_with_hash (type, (hashval_t) TREE_HASH (type),
-htab_find_slot_with_hash (ttypes_hash, type, TREE_HASH (type), INSERT);
+					  INSERT);
 if ((n = *slot) == NULL)
 {
 /* Filter value is a 1 based table index.  */
 n = XNEW (struct ttypes_filter);
 n->t = type;
-n->filter = VEC_length (tree, cfun->eh->ttype_data) + 1;
+n->filter = vec_safe_length (cfun->eh->ttype_data) + 1;
 *slot = n;
-VEC_safe_push (tree, gc, cfun->eh->ttype_data, type);
+vec_safe_push (cfun->eh->ttype_data, type);
 }
 return n->filter;
 }
 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
 to speed up the search.  Return the filter value to be used.  */
 static int
-add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list)
+add_ehspec_entry (ehspec_hash_type *ehspec_hash, ttypes_hash_type *ttypes_hash,
+		  tree list)
 {
 struct ttypes_filter **slot, *n;
 struct ttypes_filter dummy;
 dummy.t = list;
-slot = (struct ttypes_filter **)
+slot = ehspec_hash->find_slot (&dummy, INSERT);
-htab_find_slot (ehspec_hash, &dummy, INSERT);
 if ((n = *slot) == NULL)
 {
 int len;
 if (targetm.arm_eabi_unwinder)
-	len = VEC_length (tree, cfun->eh->ehspec_data.arm_eabi);
+	len = vec_safe_length (cfun->eh->ehspec_data.arm_eabi);
 else
-	len = VEC_length (uchar, cfun->eh->ehspec_data.other);
+	len = vec_safe_length (cfun->eh->ehspec_data.other);
 /* Filter value is a -1 based byte index into a uleb128 buffer.  */
 n = XNEW (struct ttypes_filter);
 n->t = list;
 /* Generate a 0 terminated list of filter values.  */
 for (; list ; list = TREE_CHAIN (list))
 	{
 	  if (targetm.arm_eabi_unwinder)
-	    VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi,
+	    vec_safe_push (cfun->eh->ehspec_data.arm_eabi, TREE_VALUE (list));
-			   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.other,
 			    add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
 	    }
 	}
 if (targetm.arm_eabi_unwinder)
-	VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, NULL_TREE);
+	vec_safe_push (cfun->eh->ehspec_data.arm_eabi, NULL_TREE);
 else
-	VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, 0);
+	vec_safe_push (cfun->eh->ehspec_data.other, (uchar)0);
 }
 return n->filter;
 }
 void
 assign_filter_values (void)
 {
 int i;
-htab_t ttypes, ehspec;
 eh_region r;
 eh_catch c;
-cfun->eh->ttype_data = VEC_alloc (tree, gc, 16);
+vec_alloc (cfun->eh->ttype_data, 16);
 if (targetm.arm_eabi_unwinder)
-cfun->eh->ehspec_data.arm_eabi = VEC_alloc (tree, gc, 64);
+vec_alloc (cfun->eh->ehspec_data.arm_eabi, 64);
 else
-cfun->eh->ehspec_data.other = VEC_alloc (uchar, gc, 64);
+vec_alloc (cfun->eh->ehspec_data.other, 64);
-ttypes = htab_create (31, ttypes_filter_hash, ttypes_filter_eq, free);
+ehspec_hash_type ehspec (31);
-ehspec = htab_create (31, ehspec_filter_hash, ehspec_filter_eq, free);
+ttypes_hash_type ttypes (31);
-for (i = 1; VEC_iterate (eh_region, cfun->eh->region_array, i, r); ++i)
+for (i = 1; vec_safe_iterate (cfun->eh->region_array, i, &r); ++i)
 {
 if (r == NULL)
 	continue;
 switch (r->type)
 		     them in the region's dedicated list.  */
 		  tree tp_node = c->type_list;
 		  for ( ; tp_node; tp_node = TREE_CHAIN (tp_node))
 		    {
-		      int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
+		      int flt
-		      tree flt_node = build_int_cst (NULL_TREE, flt);
+		       	= add_ttypes_entry (&ttypes, TREE_VALUE (tp_node));
+		      tree flt_node = build_int_cst (integer_type_node, flt);
 		      c->filter_list
 			= tree_cons (NULL_TREE, flt_node, c->filter_list);
 		    }
 		}
 	      else
 		{
 		  /* Get a filter value for the NULL list also since it
 		     will need an action record anyway.  */
-		  int flt = add_ttypes_entry (ttypes, NULL);
+		  int flt = add_ttypes_entry (&ttypes, NULL);
-		  tree flt_node = build_int_cst (NULL_TREE, flt);
+		  tree flt_node = build_int_cst (integer_type_node, flt);
 		  c->filter_list
 		    = tree_cons (NULL_TREE, flt_node, NULL);
 		}
 	    }
 	  break;
 	case ERT_ALLOWED_EXCEPTIONS:
 	  r->u.allowed.filter
-	    = add_ehspec_entry (ehspec, ttypes, r->u.allowed.type_list);
+	    = add_ehspec_entry (&ehspec, &ttypes, r->u.allowed.type_list);
 	  break;
 	default:
 	  break;
 	}
 }
-htab_delete (ttypes);
-htab_delete (ehspec);
 }
 /* Emit SEQ into basic block just before INSN (that is assumed to be
 first instruction of some existing BB and return the newly
 produced block.  */
 static basic_block
-emit_to_new_bb_before (rtx seq, rtx insn)
+emit_to_new_bb_before (rtx_insn *seq, rtx_insn *insn)
 {
-rtx last;
+rtx_insn *last;
 basic_block bb;
 edge e;
 edge_iterator ei;
 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
 update_bb_for_insn (bb);
 bb->flags |= BB_SUPERBLOCK;
 return bb;
 }
+/* A subroutine of dw2_build_landing_pads, also used for edge splitting
+at the rtl level.  Emit the code required by the target at a landing
+pad for the given region.  */
+void
+expand_dw2_landing_pad_for_region (eh_region region)
+{
+if (targetm.have_exception_receiver ())
+emit_insn (targetm.gen_exception_receiver ());
+else if (targetm.have_nonlocal_goto_receiver ())
+emit_insn (targetm.gen_nonlocal_goto_receiver ());
+else
+{ /* Nothing */ }
+if (region->exc_ptr_reg)
+emit_move_insn (region->exc_ptr_reg,
+		    gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
+if (region->filter_reg)
+emit_move_insn (region->filter_reg,
+		    gen_rtx_REG (targetm.eh_return_filter_mode (),
+				 EH_RETURN_DATA_REGNO (1)));
+}
 /* Expand the extra code needed at landing pads for dwarf2 unwinding.  */
 static void
 dw2_build_landing_pads (void)
 {
 int i;
 eh_landing_pad lp;
+int e_flags = EDGE_FALLTHRU;
-for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
-{
+/* If we're going to partition blocks, we need to be able to add
-eh_region region;
+new landing pads later, which means that we need to hold on to
+the post-landing-pad block.  Prevent it from being merged away.
+We'll remove this bit after partitioning.  */
+if (flag_reorder_blocks_and_partition)
+e_flags |= EDGE_PRESERVE;
+for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
+{
 basic_block bb;
-rtx seq;
+rtx_insn *seq;
-edge e;
 if (lp == NULL || lp->post_landing_pad == NULL)
 	continue;
 start_sequence ();
 lp->landing_pad = gen_label_rtx ();
 emit_label (lp->landing_pad);
 LABEL_PRESERVE_P (lp->landing_pad) = 1;
-#ifdef HAVE_exception_receiver
+expand_dw2_landing_pad_for_region (lp->region);
-if (HAVE_exception_receiver)
-	emit_insn (gen_exception_receiver ());
-else
-#endif
-#ifdef HAVE_nonlocal_goto_receiver
-	if (HAVE_nonlocal_goto_receiver)
-	  emit_insn (gen_nonlocal_goto_receiver ());
-	else
-#endif
-	  { /* Nothing */ }
-region = lp->region;
-if (region->exc_ptr_reg)
-	emit_move_insn (region->exc_ptr_reg,
-			gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
-if (region->filter_reg)
-	emit_move_insn (region->filter_reg,
-			gen_rtx_REG (targetm.eh_return_filter_mode (),
-				     EH_RETURN_DATA_REGNO (1)));
 seq = get_insns ();
 end_sequence ();
 bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad));
-e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
+bb->count = bb->next_bb->count;
-e->count = bb->count;
+bb->frequency = bb->next_bb->frequency;
-e->probability = REG_BR_PROB_BASE;
+make_single_succ_edge (bb, bb->next_bb, e_flags);
+if (current_loops)
+	{
+	  struct loop *loop = bb->next_bb->loop_father;
+	  /* If we created a pre-header block, add the new block to the
+	     outer loop, otherwise to the loop itself.  */
+	  if (bb->next_bb == loop->header)
+	    add_bb_to_loop (bb, loop_outer (loop));
+	  else
+	    add_bb_to_loop (bb, loop);
+	}
 }
 }
-static VEC (int, heap) *sjlj_lp_call_site_index;
+static vec<int> sjlj_lp_call_site_index;
 /* Process all active landing pads.  Assign each one a compact dispatch
 index, and a call-site index.  */
 static int
 sjlj_assign_call_site_values (void)
 {
-htab_t ar_hash;
+action_hash_type ar_hash (31);
 int i, disp_index;
 eh_landing_pad lp;
-crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64);
+vec_alloc (crtl->eh.action_record_data, 64);
-ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
 disp_index = 0;
 call_site_base = 1;
-for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
+for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
 if (lp && lp->post_landing_pad)
 {
 	int action, call_site;
 	/* First: build the action table.  */
-	action = collect_one_action_chain (ar_hash, lp->region);
+	action = collect_one_action_chain (&ar_hash, lp->region);
 	/* Next: assign call-site values.  If dwarf2 terms, this would be
 	   the region number assigned by convert_to_eh_region_ranges, but
 	   handles no-action and must-not-throw differently.  */
 	/* Map must-not-throw to otherwise unused call-site index 0.  */
 	else if (action == -1)
 	  call_site = -1;
 	/* Otherwise, look it up in the table.  */
 	else
 	  call_site = add_call_site (GEN_INT (disp_index), action, 0);
-	VEC_replace (int, sjlj_lp_call_site_index, i, call_site);
+	sjlj_lp_call_site_index[i] = call_site;
 	disp_index++;
 }
-htab_delete (ar_hash);
 return disp_index;
 }
 /* Emit code to record the current call-site index before every
 insn that can throw.  */
 static void
 sjlj_mark_call_sites (void)
 {
 int last_call_site = -2;
-rtx insn, mem;
+rtx_insn *insn;
+rtx mem;
 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
 {
 eh_landing_pad lp;
 eh_region r;
 bool nothrow;
 int this_call_site;
-rtx before, p;
+rtx_insn *before, *p;
 /* Reset value tracking at extended basic block boundaries.  */
 if (LABEL_P (insn))
 	last_call_site = -2;
+/* If the function allocates dynamic stack space, the context must
+	 be updated after every allocation/deallocation accordingly.  */
+if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_UPDATE_SJLJ_CONTEXT)
+	{
+	  rtx buf_addr;
+	  start_sequence ();
+	  buf_addr = plus_constant (Pmode, XEXP (crtl->eh.sjlj_fc, 0),
+				    sjlj_fc_jbuf_ofs);
+	  expand_builtin_update_setjmp_buf (buf_addr);
+	  p = get_insns ();
+	  end_sequence ();
+	  emit_insn_before (p, insn);
+	}
 if (! INSN_P (insn))
 	continue;
 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
 if (nothrow)
 	continue;
 if (lp)
-	this_call_site = VEC_index (int, sjlj_lp_call_site_index, lp->index);
+	this_call_site = sjlj_lp_call_site_index[lp->index];
 else if (r == NULL)
 	{
 	  /* Calls (and trapping insns) without notes are outside any
 	     exception handling region in this function.  Mark them as
 	     no action.  */
 	continue;
 /* Don't separate a call from it's argument loads.  */
 before = insn;
 if (CALL_P (insn))
-	before = find_first_parameter_load (insn, NULL_RTX);
+	before = find_first_parameter_load (insn, NULL);
 start_sequence ();
 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));
+emit_move_insn (mem, gen_int_mode (this_call_site, GET_MODE (mem)));
 p = get_insns ();
 end_sequence ();
 emit_insn_before (p, before);
 last_call_site = this_call_site;
 }
 /* Construct the SjLj_Function_Context.  */
 static void
-sjlj_emit_function_enter (rtx dispatch_label)
+sjlj_emit_function_enter (rtx_code_label *dispatch_label)
 {
-rtx fn_begin, fc, mem, seq;
+rtx_insn *fn_begin, *seq;
+rtx fc, mem;
 bool fn_begin_outside_block;
 rtx personality = get_personality_function (current_function_decl);
 fc = crtl->eh.sjlj_fc;
 else
 emit_move_insn (mem, const0_rtx);
 if (dispatch_label)
 {
+rtx addr = plus_constant (Pmode, XEXP (fc, 0), sjlj_fc_jbuf_ofs);
 #ifdef DONT_USE_BUILTIN_SETJMP
-rtx x, last;
+addr = copy_addr_to_reg (addr);
-x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE,
+addr = convert_memory_address (ptr_mode, addr);
-				   TYPE_MODE (integer_type_node), 1,
+tree addr_tree = make_tree (ptr_type_node, addr);
-				   plus_constant (XEXP (fc, 0),
-						  sjlj_fc_jbuf_ofs), Pmode);
+tree call_expr = build_call_expr (setjmp_fn, 1, addr_tree);
+rtx x = expand_call (call_expr, NULL_RTX, false);
 emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
 			       TYPE_MODE (integer_type_node), 0,
-			       dispatch_label);
+			       dispatch_label,
-last = get_last_insn ();
+			       profile_probability::unlikely ());
-if (JUMP_P (last) && any_condjump_p (last))
-	{
-	  gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
-	  add_reg_note (last, REG_BR_PROB, GEN_INT (REG_BR_PROB_BASE / 100));
-	}
 #else
-expand_builtin_setjmp_setup (plus_constant (XEXP (fc, 0),
+expand_builtin_setjmp_setup (addr, dispatch_label);
-						  sjlj_fc_jbuf_ofs),
-				   dispatch_label);
 #endif
 }
 emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
-		     1, XEXP (fc, 0), Pmode);
+		     XEXP (fc, 0), Pmode);
 seq = get_insns ();
 end_sequence ();
 /* ??? Instead of doing this at the beginning of the function,
 	  break;
 	else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin))
 	  fn_begin_outside_block = false;
 }
+#ifdef DONT_USE_BUILTIN_SETJMP
+if (dispatch_label)
+{
+/* The sequence contains a branch in the middle so we need to force
+	 the creation of a new basic block by means of BB_SUPERBLOCK.  */
+if (fn_begin_outside_block)
+	{
+	  basic_block bb
+	    = split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
+	  if (JUMP_P (BB_END (bb)))
+	    emit_insn_before (seq, BB_END (bb));
+	  else
+	    emit_insn_after (seq, BB_END (bb));
+	}
+else
+	emit_insn_after (seq, fn_begin);
+single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun))->flags |= BB_SUPERBLOCK;
+return;
+}
+#endif
 if (fn_begin_outside_block)
-insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR));
+insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
 else
 emit_insn_after (seq, fn_begin);
 }
 /* Call back from expand_function_end to know where we should put
 the call to unwind_sjlj_unregister_libfunc if needed.  */
 void
-sjlj_emit_function_exit_after (rtx after)
+sjlj_emit_function_exit_after (rtx_insn *after)
 {
 crtl->eh.sjlj_exit_after = after;
 }
 static void
 sjlj_emit_function_exit (void)
 {
-rtx seq, insn;
+rtx_insn *seq, *insn;
 start_sequence ();
 emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
-		     1, XEXP (crtl->eh.sjlj_fc, 0), Pmode);
+		     XEXP (crtl->eh.sjlj_fc, 0), Pmode);
 seq = get_insns ();
 end_sequence ();
 /* ??? Really this can be done in any block at loop level 0 that
 emit_insn_after (seq, insn);
 }
 static void
-sjlj_emit_dispatch_table (rtx dispatch_label, int num_dispatch)
+sjlj_emit_dispatch_table (rtx_code_label *dispatch_label, int num_dispatch)
 {
-enum machine_mode unwind_word_mode = targetm.unwind_word_mode ();
+scalar_int_mode unwind_word_mode = targetm.unwind_word_mode ();
-enum machine_mode filter_mode = targetm.eh_return_filter_mode ();
+scalar_int_mode filter_mode = targetm.eh_return_filter_mode ();
 eh_landing_pad lp;
-rtx mem, seq, fc, before, exc_ptr_reg, filter_reg;
+rtx mem, fc, exc_ptr_reg, filter_reg;
-rtx first_reachable_label;
+rtx_insn *seq;
 basic_block bb;
 eh_region r;
-edge e;
 int i, disp_index;
-gimple switch_stmt;
+vec<tree> dispatch_labels = vNULL;
 fc = crtl->eh.sjlj_fc;
 start_sequence ();
 making sure that the label doesn't vanish.  The only other caller
 is the expander for __builtin_setjmp_receiver, which places this
 label on the nonlocal_goto_label list.  Since we're modeling these
 CFG edges more exactly, we can use the forced_labels list instead.  */
 LABEL_PRESERVE_P (dispatch_label) = 1;
-forced_labels
+vec_safe_push<rtx_insn *> (forced_labels, dispatch_label);
-= gen_rtx_EXPR_LIST (VOIDmode, dispatch_label, forced_labels);
 #endif
 /* Load up exc_ptr and filter values from the function context.  */
 mem = adjust_address (fc, unwind_word_mode, sjlj_fc_data_ofs);
 if (unwind_word_mode != ptr_mode)
 filter_reg = force_reg (filter_mode, mem);
 /* Jump to one of the directly reachable regions.  */
 disp_index = 0;
-first_reachable_label = NULL;
+rtx_code_label *first_reachable_label = NULL;
 /* If there's exactly one call site in the function, don't bother
 generating a switch statement.  */
-switch_stmt = NULL;
 if (num_dispatch > 1)
-{
+dispatch_labels.create (num_dispatch);
-tree disp;
+for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
-mem = adjust_address (fc, TYPE_MODE (integer_type_node),
-			    sjlj_fc_call_site_ofs);
-disp = make_tree (integer_type_node, mem);
-switch_stmt = gimple_build_switch_nlabels (num_dispatch, disp, NULL);
-}
-for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
 if (lp && lp->post_landing_pad)
 {
-	rtx seq2, label;
+	rtx_insn *seq2;
+	rtx_code_label *label;
 	start_sequence ();
 	lp->landing_pad = dispatch_label;
 	if (num_dispatch > 1)
 	  {
-	    tree t_label, case_elt;
+	    tree t_label, case_elt, t;
 	    t_label = create_artificial_label (UNKNOWN_LOCATION);
-	    case_elt = build3 (CASE_LABEL_EXPR, void_type_node,
+	    t = build_int_cst (integer_type_node, disp_index);
-			       build_int_cst (NULL, disp_index),
+	    case_elt = build_case_label (t, NULL, t_label);
-			       NULL, t_label);
+	    dispatch_labels.quick_push (case_elt);
-	    gimple_switch_set_label (switch_stmt, disp_index, case_elt);
+	    label = jump_target_rtx (t_label);
-	    label = label_rtx (t_label);
 	  }
 	else
 	  label = gen_label_rtx ();
 	if (disp_index == 0)
 	  emit_move_insn (r->filter_reg, filter_reg);
 	seq2 = get_insns ();
 	end_sequence ();
-	before = label_rtx (lp->post_landing_pad);
+	rtx_insn *before = label_rtx (lp->post_landing_pad);
 	bb = emit_to_new_bb_before (seq2, before);
-	e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
+	make_single_succ_edge (bb, bb->next_bb, EDGE_FALLTHRU);
-	e->count = bb->count;
+	if (current_loops)
-	e->probability = REG_BR_PROB_BASE;
+	  {
+	    struct loop *loop = bb->next_bb->loop_father;
+	    /* If we created a pre-header block, add the new block to the
+	       outer loop, otherwise to the loop itself.  */
+	    if (bb->next_bb == loop->header)
+	      add_bb_to_loop (bb, loop_outer (loop));
+	    else
+	      add_bb_to_loop (bb, loop);
+	    /* ???  For multiple dispatches we will end up with edges
+	       from the loop tree root into this loop, making it a
+	       multiple-entry loop.  Discard all affected loops.  */
+	    if (num_dispatch > 1)
+	      {
+		for (loop = bb->loop_father;
+		     loop_outer (loop); loop = loop_outer (loop))
+		  mark_loop_for_removal (loop);
+	      }
+	  }
 	disp_index++;
 }
 gcc_assert (disp_index == num_dispatch);
 if (num_dispatch > 1)
 {
-expand_case (switch_stmt);
+rtx disp = adjust_address (fc, TYPE_MODE (integer_type_node),
-expand_builtin_trap ();
+				 sjlj_fc_call_site_ofs);
+expand_sjlj_dispatch_table (disp, dispatch_labels);
 }
 seq = get_insns ();
 end_sequence ();
 bb = emit_to_new_bb_before (seq, first_reachable_label);
 if (num_dispatch == 1)
 {
-e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
+make_single_succ_edge (bb, bb->next_bb, EDGE_FALLTHRU);
-e->count = bb->count;
+if (current_loops)
-e->probability = REG_BR_PROB_BASE;
+	{
+	  struct loop *loop = bb->next_bb->loop_father;
+	  /* If we created a pre-header block, add the new block to the
+	     outer loop, otherwise to the loop itself.  */
+	  if (bb->next_bb == loop->header)
+	    add_bb_to_loop (bb, loop_outer (loop));
+	  else
+	    add_bb_to_loop (bb, loop);
+	}
+}
+else
+{
+/* We are not wiring up edges here, but as the dispatcher call
+is at function begin simply associate the block with the
+	 outermost (non-)loop.  */
+if (current_loops)
+	add_bb_to_loop (bb, current_loops->tree_root);
 }
 }
 static void
 sjlj_build_landing_pads (void)
 {
 int num_dispatch;
-num_dispatch = VEC_length (eh_landing_pad, cfun->eh->lp_array);
+num_dispatch = vec_safe_length (cfun->eh->lp_array);
 if (num_dispatch == 0)
 return;
-VEC_safe_grow (int, heap, sjlj_lp_call_site_index, num_dispatch);
+sjlj_lp_call_site_index.safe_grow_cleared (num_dispatch);
 num_dispatch = sjlj_assign_call_site_values ();
 if (num_dispatch > 0)
 {
-rtx dispatch_label = gen_label_rtx ();
+rtx_code_label *dispatch_label = gen_label_rtx ();
 int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node,
 					TYPE_MODE (sjlj_fc_type_node),
 					TYPE_ALIGN (sjlj_fc_type_node));
 crtl->eh.sjlj_fc
 	= assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
 	= assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
 			      int_size_in_bytes (sjlj_fc_type_node),
 			      align);
 sjlj_mark_call_sites ();
-sjlj_emit_function_enter (NULL_RTX);
+sjlj_emit_function_enter (NULL);
 sjlj_emit_function_exit ();
 }
-VEC_free (int, heap, sjlj_lp_call_site_index);
+sjlj_lp_call_site_index.release ();
+}
+/* Update the sjlj function context.  This function should be called
+whenever we allocate or deallocate dynamic stack space.  */
+void
+update_sjlj_context (void)
+{
+if (!flag_exceptions)
+return;
+emit_note (NOTE_INSN_UPDATE_SJLJ_CONTEXT);
 }
 /* After initial rtl generation, call back to finish generating
 exception support code.  */
-static void
+void
 finish_eh_generation (void)
 {
 basic_block bb;
 /* Construct the landing pads.  */
-if (targetm.except_unwind_info (&global_options) == UI_SJLJ)
+if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
 sjlj_build_landing_pads ();
 else
 dw2_build_landing_pads ();
 break_superblocks ();
-if (targetm.except_unwind_info (&global_options) == UI_SJLJ
+if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ
-/* Kludge for Alpha/Tru64 (see alpha_gp_save_rtx).  */
+/* Kludge for Alpha (see alpha_gp_save_rtx).  */
-|| single_succ_edge (ENTRY_BLOCK_PTR)->insns.r)
+|| single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun))->insns.r)
 commit_edge_insertions ();
 /* Redirect all EH edges from the post_landing_pad to the landing pad.  */
-FOR_EACH_BB (bb)
+FOR_EACH_BB_FN (bb, cfun)
 {
 eh_landing_pad lp;
 edge_iterator ei;
 edge e;
 		       ? EDGE_ABNORMAL | EDGE_ABNORMAL_CALL
 		       : EDGE_ABNORMAL);
 	}
 }
 }
-static bool
-gate_handle_eh (void)
-{
-/* Nothing to do if no regions created.  */
-return cfun->eh->region_tree != NULL;
-}
-/* Complete generation of exception handling code.  */
-static unsigned int
-rest_of_handle_eh (void)
-{
-finish_eh_generation ();
-cleanup_cfg (CLEANUP_NO_INSN_DEL);
-return 0;
-}
-struct rtl_opt_pass pass_rtl_eh =
-{
-{
-RTL_PASS,
-"rtl eh",                             /* name */
-gate_handle_eh,                       /* gate */
-rest_of_handle_eh,			/* execute */
-NULL,                                 /* sub */
-NULL,                                 /* next */
-0,                                    /* static_pass_number */
-TV_JUMP,                              /* tv_id */
-0,                                    /* properties_required */
-0,                                    /* properties_provided */
-0,                                    /* properties_destroyed */
-0,                                    /* todo_flags_start */
-TODO_dump_func                        /* todo_flags_finish */
-}
-};
 /* This section handles removing dead code for flow.  */
 void
 remove_eh_landing_pad (eh_landing_pad lp)
 continue;
 *pp = lp->next_lp;
 if (lp->post_landing_pad)
 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
-VEC_replace (eh_landing_pad, cfun->eh->lp_array, lp->index, NULL);
+(*cfun->eh->lp_array)[lp->index] = NULL;
 }
-/* Splice REGION from the region tree.  */
+/* Splice the EH region at PP from the region tree.  */
-void
+static void
-remove_eh_handler (eh_region region)
+remove_eh_handler_splicer (eh_region *pp)
 {
-eh_region *pp, *pp_start, p, outer;
+eh_region region = *pp;
 eh_landing_pad lp;
 for (lp = region->landing_pads; lp ; lp = lp->next_lp)
 {
 if (lp->post_landing_pad)
 	EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
-VEC_replace (eh_landing_pad, cfun->eh->lp_array, lp->index, NULL);
+(*cfun->eh->lp_array)[lp->index] = NULL;
 }
-outer = region->outer;
-if (outer)
-pp_start = &outer->inner;
-else
-pp_start = &cfun->eh->region_tree;
-for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp)
-continue;
 if (region->inner)
 {
+eh_region p, outer;
+outer = region->outer;
 *pp = p = region->inner;
 do
 	{
 	  p->outer = outer;
 	  pp = &p->next_peer;
 	}
 while (p);
 }
 *pp = region->next_peer;
-VEC_replace (eh_region, cfun->eh->region_array, region->index, NULL);
+(*cfun->eh->region_array)[region->index] = NULL;
+}
+/* Splice a single EH region REGION from the region tree.
+To unlink REGION, we need to find the pointer to it with a relatively
+expensive search in REGION's outer region.  If you are going to
+remove a number of handlers, using remove_unreachable_eh_regions may
+be a better option.  */
+void
+remove_eh_handler (eh_region region)
+{
+eh_region *pp, *pp_start, p, outer;
+outer = region->outer;
+if (outer)
+pp_start = &outer->inner;
+else
+pp_start = &cfun->eh->region_tree;
+for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp)
+continue;
+remove_eh_handler_splicer (pp);
+}
+/* Worker for remove_unreachable_eh_regions.
+PP is a pointer to the region to start a region tree depth-first
+search from.  R_REACHABLE is the set of regions that have to be
+preserved.  */
+static void
+remove_unreachable_eh_regions_worker (eh_region *pp, sbitmap r_reachable)
+{
+while (*pp)
+{
+eh_region region = *pp;
+remove_unreachable_eh_regions_worker (&region->inner, r_reachable);
+if (!bitmap_bit_p (r_reachable, region->index))
+	remove_eh_handler_splicer (pp);
+else
+	pp = &region->next_peer;
+}
+}
+/* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
+Do this by traversing the EH tree top-down and splice out regions that
+are not marked.  By removing regions from the leaves, we avoid costly
+searches in the region tree.  */
+void
+remove_unreachable_eh_regions (sbitmap r_reachable)
+{
+remove_unreachable_eh_regions_worker (&cfun->eh->region_tree, r_reachable);
 }
 /* Invokes CALLBACK for every exception handler landing pad label.
 Only used by reload hackery; should not be used by new code.  */
 for_each_eh_label (void (*callback) (rtx))
 {
 eh_landing_pad lp;
 int i;
-for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
+for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
 {
 if (lp)
 	{
-	  rtx lab = lp->landing_pad;
+	  rtx_code_label *lab = lp->landing_pad;
 	  if (lab && LABEL_P (lab))
 	    (*callback) (lab);
 	}
 }
 }
 on the call_insn directly.  Perhaps we should make more use of
 attaching the trees to call_insns (reachable via symbol_ref in
 direct call cases) and just pull the data out of the trees.  */
 void
-make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr)
+make_reg_eh_region_note (rtx_insn *insn, int ecf_flags, int lp_nr)
 {
 rtx value;
 if (ecf_flags & ECF_NOTHROW)
 value = const0_rtx;
 else if (lp_nr != 0)
 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
 nor perform a non-local goto.  Replace the region note if it
 already exists.  */
 void
-make_reg_eh_region_note_nothrow_nononlocal (rtx insn)
+make_reg_eh_region_note_nothrow_nononlocal (rtx_insn *insn)
 {
 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
 rtx intmin = GEN_INT (INT_MIN);
 if (note != 0)
 /* Copy an REG_EH_REGION note to each insn that might throw beginning
 at FIRST and ending at LAST.  NOTE_OR_INSN is either the source insn
 to look for a note, or the note itself.  */
 void
-copy_reg_eh_region_note_forward (rtx note_or_insn, rtx first, rtx last)
+copy_reg_eh_region_note_forward (rtx note_or_insn, rtx_insn *first, rtx last)
 {
-rtx insn, note = note_or_insn;
+rtx_insn *insn;
+rtx note = note_or_insn;
 if (INSN_P (note_or_insn))
 {
 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
 if (note == NULL)
 }
 /* Likewise, but iterate backward.  */
 void
-copy_reg_eh_region_note_backward (rtx note_or_insn, rtx last, rtx first)
+copy_reg_eh_region_note_backward (rtx note_or_insn, rtx_insn *last, rtx first)
 {
-rtx insn, note = note_or_insn;
+rtx_insn *insn;
+rtx note = note_or_insn;
 if (INSN_P (note_or_insn))
 {
 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
 if (note == NULL)
 ret = true;
 goto egress;
 }
 if (lp_nr < 0)
-r = VEC_index (eh_region, cfun->eh->region_array, -lp_nr);
+r = (*cfun->eh->region_array)[-lp_nr];
 else
 {
-lp = VEC_index (eh_landing_pad, cfun->eh->lp_array, lp_nr);
+lp = (*cfun->eh->lp_array)[lp_nr];
 r = lp->region;
 }
 egress:
 *plp = lp;
 return false;
 if (NONJUMP_INSN_P (insn)
 && GET_CODE (PATTERN (insn)) == SEQUENCE)
 {
-rtx seq = PATTERN (insn);
+rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (insn));
-int i, n = XVECLEN (seq, 0);
+int i, n = seq->len ();
 for (i = 0; i < n; i++)
-	if (can_throw_external (XVECEXP (seq, 0, i)))
+	if (can_throw_external (seq->element (i)))
 	  return true;
 return false;
 }
 return true;
 if (NONJUMP_INSN_P (insn)
 && GET_CODE (PATTERN (insn)) == SEQUENCE)
 {
-rtx seq = PATTERN (insn);
+rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (insn));
-int i, n = XVECLEN (seq, 0);
+int i, n = seq->len ();
 for (i = 0; i < n; i++)
-	if (!insn_nothrow_p (XVECEXP (seq, 0, i)))
+	if (!insn_nothrow_p (seq->element (i)))
 	  return false;
 return true;
 }
 /* Return true if INSN can perform a non-local goto.  */
 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION.  */
 bool
-can_nonlocal_goto (const_rtx insn)
+can_nonlocal_goto (const rtx_insn *insn)
 {
 if (nonlocal_goto_handler_labels && CALL_P (insn))
 {
 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
 if (!note || INTVAL (XEXP (note, 0)) != INT_MIN)
 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls.  */
 static unsigned int
 set_nothrow_function_flags (void)
 {
-rtx insn;
+rtx_insn *insn;
 crtl->nothrow = 1;
 /* Assume crtl->all_throwers_are_sibcalls until we encounter
 something that can throw an exception.  We specifically exempt
 	    crtl->all_throwers_are_sibcalls = 0;
 	    return 0;
 	  }
 }
-for (insn = crtl->epilogue_delay_list; insn;
-insn = XEXP (insn, 1))
-if (can_throw_external (insn))
-{
-crtl->nothrow = 0;
-	if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
-	  {
-	    crtl->all_throwers_are_sibcalls = 0;
-	    return 0;
-	  }
-}
 if (crtl->nothrow
-&& (cgraph_function_body_availability (cgraph_node
+&& (cgraph_node::get (current_function_decl)->get_availability ()
-					     (current_function_decl))
 >= AVAIL_AVAILABLE))
 {
-struct cgraph_node *node = cgraph_node (current_function_decl);
+struct cgraph_node *node = cgraph_node::get (current_function_decl);
 struct cgraph_edge *e;
 for (e = node->callers; e; e = e->next_caller)
 e->can_throw_external = false;
-cgraph_set_nothrow_flag (node, true);
+node->set_nothrow_flag (true);
 if (dump_file)
 	fprintf (dump_file, "Marking function nothrow: %s\n\n",
 		 current_function_name ());
 }
 return 0;
 }
-struct rtl_opt_pass pass_set_nothrow_function_flags =
+namespace {
-{
-{
+const pass_data pass_data_set_nothrow_function_flags =
-RTL_PASS,
+{
-"nothrow",                            /* name */
+RTL_PASS, /* type */
-NULL,                                 /* gate */
+"nothrow", /* name */
-set_nothrow_function_flags,           /* execute */
+OPTGROUP_NONE, /* optinfo_flags */
-NULL,                                 /* sub */
+TV_NONE, /* tv_id */
-NULL,                                 /* next */
+0, /* properties_required */
-0,                                    /* static_pass_number */
+0, /* properties_provided */
-TV_NONE,                              /* tv_id */
+0, /* properties_destroyed */
-0,                                    /* properties_required */
+0, /* todo_flags_start */
-0,                                    /* properties_provided */
+0, /* todo_flags_finish */
-0,                                    /* properties_destroyed */
-0,                                    /* todo_flags_start */
-TODO_dump_func,                       /* todo_flags_finish */
-}
 };
+class pass_set_nothrow_function_flags : public rtl_opt_pass
+{
+public:
+pass_set_nothrow_function_flags (gcc::context *ctxt)
+: rtl_opt_pass (pass_data_set_nothrow_function_flags, ctxt)
+{}
+/* opt_pass methods: */
+virtual unsigned int execute (function *)
+{
+return set_nothrow_function_flags ();
+}
+}; // class pass_set_nothrow_function_flags
+} // anon namespace
+rtl_opt_pass *
+make_pass_set_nothrow_function_flags (gcc::context *ctxt)
+{
+return new pass_set_nothrow_function_flags (ctxt);
+}
 /* Various hooks for unwind library.  */
 /* Expand the EH support builtin functions:
 expand_builtin_eh_common (tree region_nr_t)
 {
 HOST_WIDE_INT region_nr;
 eh_region region;
-gcc_assert (host_integerp (region_nr_t, 0));
+gcc_assert (tree_fits_shwi_p (region_nr_t));
-region_nr = tree_low_cst (region_nr_t, 0);
+region_nr = tree_to_shwi (region_nr_t);
-region = VEC_index (eh_region, cfun->eh->region_array, region_nr);
+region = (*cfun->eh->region_array)[region_nr];
 /* ??? We shouldn't have been able to delete a eh region without
 deleting all the code that depended on it.  */
 gcc_assert (region != NULL);
 {
 eh_region dst
 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
 eh_region src
 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1));
-enum machine_mode fmode = targetm.eh_return_filter_mode ();
+scalar_int_mode fmode = targetm.eh_return_filter_mode ();
 if (dst->exc_ptr_reg == NULL)
 dst->exc_ptr_reg = gen_reg_rtx (ptr_mode);
 if (src->exc_ptr_reg == NULL)
 src->exc_ptr_reg = gen_reg_rtx (ptr_mode);
 {
 /* 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.  */
 crtl->saves_all_registers = 1;
-#ifdef SETUP_FRAME_ADDRESSES
 SETUP_FRAME_ADDRESSES ();
-#endif
 }
 /* Map a non-negative number to an eh return data register number; expands
 to -1 if no return data register is associated with the input number.
 At least the inputs 0 and 1 must be mapped; the target may provide more.  */
 {
 error ("argument of %<__builtin_eh_return_regno%> must be constant");
 return constm1_rtx;
 }
-iwhich = tree_low_cst (which, 1);
+iwhich = tree_to_uhwi (which);
 iwhich = EH_RETURN_DATA_REGNO (iwhich);
 if (iwhich == INVALID_REGNUM)
 return constm1_rtx;
 #ifdef DWARF_FRAME_REGNUM
 addr = convert_to_mode (Pmode, addr, 0);
 #endif
 }
 /* First mask out any unwanted bits.  */
-#ifdef MASK_RETURN_ADDR
+rtx mask = MASK_RETURN_ADDR;
-expand_and (Pmode, addr, MASK_RETURN_ADDR, addr);
+if (mask)
-#endif
+expand_and (Pmode, addr, mask, addr);
 /* Then adjust to find the real return address.  */
-#if defined (RETURN_ADDR_OFFSET)
+if (RETURN_ADDR_OFFSET)
-addr = plus_constant (addr, RETURN_ADDR_OFFSET);
+addr = plus_constant (Pmode, addr, RETURN_ADDR_OFFSET);
-#endif
 return addr;
 }
 /* Given an actual address in addr_tree, do any necessary encoding
 {
 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
 addr = convert_memory_address (Pmode, addr);
-#ifdef RETURN_ADDR_OFFSET
+if (RETURN_ADDR_OFFSET)
-addr = force_reg (Pmode, addr);
+{
-addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
+addr = force_reg (Pmode, addr);
-#endif
+addr = plus_constant (Pmode, addr, -RETURN_ADDR_OFFSET);
+}
 return addr;
 }
 /* Set up the epilogue with the magic bits we'll need to return to the
 #ifdef EH_RETURN_STACKADJ_RTX
 tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj,
 		     VOIDmode, EXPAND_NORMAL);
 tmp = convert_memory_address (Pmode, tmp);
 if (!crtl->eh.ehr_stackadj)
-crtl->eh.ehr_stackadj = copy_to_reg (tmp);
+crtl->eh.ehr_stackadj = copy_addr_to_reg (tmp);
 else if (tmp != crtl->eh.ehr_stackadj)
 emit_move_insn (crtl->eh.ehr_stackadj, tmp);
 #endif
 tmp = expand_expr (handler_tree, crtl->eh.ehr_handler,
 		     VOIDmode, EXPAND_NORMAL);
 tmp = convert_memory_address (Pmode, tmp);
 if (!crtl->eh.ehr_handler)
-crtl->eh.ehr_handler = copy_to_reg (tmp);
+crtl->eh.ehr_handler = copy_addr_to_reg (tmp);
 else if (tmp != crtl->eh.ehr_handler)
 emit_move_insn (crtl->eh.ehr_handler, tmp);
 if (!crtl->eh.ehr_label)
 crtl->eh.ehr_label = gen_label_rtx ();
 given PC other than the normal return address.  */
 void
 expand_eh_return (void)
 {
-rtx around_label;
+rtx_code_label *around_label;
 if (! crtl->eh.ehr_label)
 return;
 crtl->calls_eh_return = 1;
 #ifdef EH_RETURN_STACKADJ_RTX
 emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj);
 #endif
-#ifdef HAVE_eh_return
+if (targetm.have_eh_return ())
-if (HAVE_eh_return)
+emit_insn (targetm.gen_eh_return (crtl->eh.ehr_handler));
-emit_insn (gen_eh_return (crtl->eh.ehr_handler));
 else
-#endif
+{
-{
+if (rtx handler = EH_RETURN_HANDLER_RTX)
-#ifdef EH_RETURN_HANDLER_RTX
+	emit_move_insn (handler, crtl->eh.ehr_handler);
-emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler);
+else
-#else
+	error ("__builtin_eh_return not supported on this target");
-error ("__builtin_eh_return not supported on this target");
-#endif
 }
 emit_label (around_label);
 }
 #endif
 return convert_modes (targetm.unwind_word_mode (), ptr_mode, addr, extend);
 }
-/* In the following functions, we represent entries in the action table
-as 1-based indices.  Special cases are:
-	 0:	null action record, non-null landing pad; implies cleanups
-	-1:	null action record, null landing pad; implies no action
-	-2:	no call-site entry; implies must_not_throw
-	-3:	we have yet to process outer regions
-Further, no special cases apply to the "next" field of the record.
-For next, 0 means end of list.  */
-struct action_record
-{
-int offset;
-int filter;
-int next;
-};
 static int
-action_record_eq (const void *pentry, const void *pdata)
+add_action_record (action_hash_type *ar_hash, int filter, int next)
-{
-const struct action_record *entry = (const struct action_record *) pentry;
-const struct action_record *data = (const struct action_record *) pdata;
-return entry->filter == data->filter && entry->next == data->next;
-}
-static hashval_t
-action_record_hash (const void *pentry)
-{
-const struct action_record *entry = (const struct action_record *) pentry;
-return entry->next * 1009 + entry->filter;
-}
-static int
-add_action_record (htab_t ar_hash, int filter, int next)
 {
 struct action_record **slot, *new_ar, tmp;
 tmp.filter = filter;
 tmp.next = next;
-slot = (struct action_record **) htab_find_slot (ar_hash, &tmp, INSERT);
+slot = ar_hash->find_slot (&tmp, INSERT);
 if ((new_ar = *slot) == NULL)
 {
 new_ar = XNEW (struct action_record);
-new_ar->offset = VEC_length (uchar, crtl->eh.action_record_data) + 1;
+new_ar->offset = crtl->eh.action_record_data->length () + 1;
 new_ar->filter = filter;
 new_ar->next = next;
 *slot = new_ar;
 /* The filter value goes in untouched.  The link to the next
 	 that there is no next record.  So convert the absolute 1 based
 	 indices we've been carrying around into a displacement.  */
 push_sleb128 (&crtl->eh.action_record_data, filter);
 if (next)
-	next -= VEC_length (uchar, crtl->eh.action_record_data) + 1;
+	next -= crtl->eh.action_record_data->length () + 1;
 push_sleb128 (&crtl->eh.action_record_data, next);
 }
 return new_ar->offset;
 }
 static int
-collect_one_action_chain (htab_t ar_hash, eh_region region)
+collect_one_action_chain (action_hash_type *ar_hash, eh_region region)
 {
 int next;
 /* If we've reached the top of the region chain, then we have
 no actions, and require no landing pad.  */
 static int
 add_call_site (rtx landing_pad, int action, int section)
 {
 call_site_record record;
-record = ggc_alloc_call_site_record_d ();
+record = ggc_alloc<call_site_record_d> ();
 record->landing_pad = landing_pad;
 record->action = action;
-VEC_safe_push (call_site_record, gc,
+vec_safe_push (crtl->eh.call_site_record_v[section], record);
-		 crtl->eh.call_site_record[section], record);
+return call_site_base + crtl->eh.call_site_record_v[section]->length () - 1;
-return call_site_base + VEC_length (call_site_record,
+}
-				      crtl->eh.call_site_record[section]) - 1;
+static rtx_note *
+emit_note_eh_region_end (rtx_insn *insn)
+{
+rtx_insn *next = NEXT_INSN (insn);
+/* Make sure we do not split a call and its corresponding
+CALL_ARG_LOCATION note.  */
+if (next && NOTE_P (next)
+&& NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
+insn = next;
+return emit_note_after (NOTE_INSN_EH_REGION_END, insn);
+}
+/* Add NOP after NOTE_INSN_SWITCH_TEXT_SECTIONS when the cold section starts
+with landing pad.
+With landing pad being at offset 0 from the start label of the section
+we would miss EH delivery because 0 is special and means no landing pad.  */
+static bool
+maybe_add_nop_after_section_switch (void)
+{
+if (!crtl->uses_eh_lsda
+|| !crtl->eh.call_site_record_v[1])
+return false;
+int n = vec_safe_length (crtl->eh.call_site_record_v[1]);
+hash_set<rtx_insn *> visited;
+for (int i = 0; i < n; ++i)
+{
+struct call_site_record_d *cs
+	 = (*crtl->eh.call_site_record_v[1])[i];
+if (cs->landing_pad)
+	{
+	  rtx_insn *insn = as_a <rtx_insn *> (cs->landing_pad);
+	  while (true)
+	    {
+	      /* Landing pads have LABEL_PRESERVE_P flag set.  This check make
+		 sure that we do not walk past landing pad visited earlier
+		 which would result in possible quadratic behaviour.  */
+	      if (LABEL_P (insn) && LABEL_PRESERVE_P (insn)
+		  && visited.add (insn))
+		break;
+	      /* Conservatively assume that ASM insn may be empty.  We have
+		 now way to tell what they contain.  */
+	      if (active_insn_p (insn)
+		  && GET_CODE (PATTERN (insn)) != ASM_INPUT
+		  && GET_CODE (PATTERN (insn)) != ASM_OPERANDS)
+		break;
+	      /* If we reached the start of hot section, then NOP will be
+		 needed.  */
+	      if (GET_CODE (insn) == NOTE
+		  && NOTE_KIND (insn) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
+		{
+		  emit_insn_after (gen_nop (), insn);
+		  break;
+		}
+	      /* We visit only labels from cold section.  We should never hit
+		 begining of the insn stream here.  */
+	      insn = PREV_INSN (insn);
+	    }
+	}
+}
+return false;
 }
 /* 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.  */
 static unsigned int
 convert_to_eh_region_ranges (void)
 {
-rtx insn, iter, note;
+rtx insn;
-htab_t ar_hash;
+rtx_insn *iter;
+rtx_note *note;
+action_hash_type ar_hash (31);
 int last_action = -3;
-rtx last_action_insn = NULL_RTX;
+rtx_insn *last_action_insn = NULL;
 rtx last_landing_pad = NULL_RTX;
-rtx first_no_action_insn = NULL_RTX;
+rtx_insn *first_no_action_insn = NULL;
 int call_site = 0;
 int cur_sec = 0;
-rtx section_switch_note = NULL_RTX;
+rtx_insn *section_switch_note = NULL;
-rtx first_no_action_insn_before_switch = NULL_RTX;
+rtx_insn *first_no_action_insn_before_switch = NULL;
-rtx last_no_action_insn_before_switch = NULL_RTX;
+rtx_insn *last_no_action_insn_before_switch = NULL;
-rtx *pad_map = NULL;
-sbitmap pad_loc = NULL;
-int min_labelno = 0, max_labelno = 0;
 int saved_call_site_base = call_site_base;
-crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64);
+vec_alloc (crtl->eh.action_record_data, 64);
-ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
 for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
 if (INSN_P (iter))
 {
 	eh_landing_pad lp;
 	eh_region region;
 	bool nothrow;
 	int this_action;
-	rtx this_landing_pad;
+	rtx_code_label *this_landing_pad;
 	insn = iter;
 	if (NONJUMP_INSN_P (insn)
 	    && GET_CODE (PATTERN (insn)) == SEQUENCE)
 	  insn = XVECEXP (PATTERN (insn), 0, 0);
 	nothrow = get_eh_region_and_lp_from_rtx (insn, &region, &lp);
 	if (nothrow)
 	  continue;
 	if (region)
-	  this_action = collect_one_action_chain (ar_hash, region);
+	  this_action = collect_one_action_chain (&ar_hash, region);
 	else
 	  this_action = -1;
 	/* Existence of catch handlers, or must-not-throw regions
 	   implies that an lsda is needed (even if empty).  */
 	  }
 	if (this_action >= 0)
 	  this_landing_pad = lp->landing_pad;
 	else
-	  this_landing_pad = NULL_RTX;
+	  this_landing_pad = NULL;
 	/* Differing actions or landing pads implies a change in call-site
 	   info, which implies some EH_REGION note should be emitted.  */
 	if (last_action != this_action
 	    || last_landing_pad != this_landing_pad)
 					       ? -1 : -3));
 		call_site = add_call_site (NULL_RTX, 0, 0);
 		note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
 					 first_no_action_insn_before_switch);
 		NOTE_EH_HANDLER (note) = call_site;
-		note = emit_note_after (NOTE_INSN_EH_REGION_END,
+		note
-					last_no_action_insn_before_switch);
+		  = emit_note_eh_region_end (last_no_action_insn_before_switch);
 		NOTE_EH_HANDLER (note) = call_site;
 		gcc_assert (last_action != -3
 			    || (last_action_insn
 				== last_no_action_insn_before_switch));
-		first_no_action_insn_before_switch = NULL_RTX;
+		first_no_action_insn_before_switch = NULL;
-		last_no_action_insn_before_switch = NULL_RTX;
+		last_no_action_insn_before_switch = NULL;
 		call_site_base++;
 	      }
 	    /* If we'd not seen a previous action (-3) or the previous
 	       action was must-not-throw (-2), then we do not need an
 	       end note.  */
 		  {
 		    call_site = add_call_site (NULL_RTX, 0, cur_sec);
 		    note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
 					     first_no_action_insn);
 		    NOTE_EH_HANDLER (note) = call_site;
-		    first_no_action_insn = NULL_RTX;
+		    first_no_action_insn = NULL;
 		  }
-		note = emit_note_after (NOTE_INSN_EH_REGION_END,
+		note = emit_note_eh_region_end (last_action_insn);
-					last_action_insn);
 		NOTE_EH_HANDLER (note) = call_site;
 	      }
 	    /* If the new action is must-not-throw, then no region notes
 	       are created.  */
 	section_switch_note = iter;
 	if (first_no_action_insn)
 	  {
 	    first_no_action_insn_before_switch = first_no_action_insn;
 	    last_no_action_insn_before_switch = last_action_insn;
-	    first_no_action_insn = NULL_RTX;
+	    first_no_action_insn = NULL;
 	    gcc_assert (last_action == -1);
 	    last_action = -3;
 	  }
 	/* Force closing of current EH region before section switch and
 	   opening a new one afterwards.  */
 	else if (last_action != -3)
 	  last_landing_pad = pc_rtx;
-	call_site_base += VEC_length (call_site_record,
+	if (crtl->eh.call_site_record_v[cur_sec])
-				      crtl->eh.call_site_record[cur_sec]);
+	  call_site_base += crtl->eh.call_site_record_v[cur_sec]->length ();
 	cur_sec++;
-	gcc_assert (crtl->eh.call_site_record[cur_sec] == NULL);
+	gcc_assert (crtl->eh.call_site_record_v[cur_sec] == NULL);
-	crtl->eh.call_site_record[cur_sec]
+	vec_alloc (crtl->eh.call_site_record_v[cur_sec], 10);
-	  = VEC_alloc (call_site_record, gc, 10);
-	max_labelno = max_label_num ();
-	min_labelno = get_first_label_num ();
-	pad_map = XCNEWVEC (rtx, max_labelno - min_labelno + 1);
-	pad_loc = sbitmap_alloc (max_labelno - min_labelno + 1);
 }
-else if (LABEL_P (iter) && pad_map)
-SET_BIT (pad_loc, CODE_LABEL_NUMBER (iter) - min_labelno);
 if (last_action >= -1 && ! first_no_action_insn)
 {
-note = emit_note_after (NOTE_INSN_EH_REGION_END, last_action_insn);
+note = emit_note_eh_region_end (last_action_insn);
 NOTE_EH_HANDLER (note) = call_site;
 }
 call_site_base = saved_call_site_base;
-if (pad_map)
-{
-/* When doing hot/cold partitioning, ensure landing pads are
-	 always in the same section as the EH region, .gcc_except_table
-	 can't express it otherwise.  */
-for (cur_sec = 0; cur_sec < 2; cur_sec++)
-	{
-	  int i, idx;
-	  int n = VEC_length (call_site_record,
-			      crtl->eh.call_site_record[cur_sec]);
-	  basic_block prev_bb = NULL, padbb;
-	  for (i = 0; i < n; ++i)
-	    {
-	      struct call_site_record_d *cs =
-		VEC_index (call_site_record,
-			   crtl->eh.call_site_record[cur_sec], i);
-	      rtx jump, note;
-	      if (cs->landing_pad == NULL_RTX)
-		continue;
-	      idx = CODE_LABEL_NUMBER (cs->landing_pad) - min_labelno;
-	      /* If the landing pad is in the correct section, nothing
-		 is needed.  */
-	      if (TEST_BIT (pad_loc, idx) ^ (cur_sec == 0))
-		continue;
-	      /* Otherwise, if we haven't seen this pad yet, we need to
-		 add a new label and jump to the correct section.  */
-	      if (pad_map[idx] == NULL_RTX)
-		{
-		  pad_map[idx] = gen_label_rtx ();
-		  if (prev_bb == NULL)
-		    for (iter = section_switch_note;
-			 iter; iter = PREV_INSN (iter))
-		      if (NOTE_INSN_BASIC_BLOCK_P (iter))
-			{
-			  prev_bb = NOTE_BASIC_BLOCK (iter);
-			  break;
-			}
-		  if (cur_sec == 0)
-		    {
-		      note = emit_label_before (pad_map[idx],
-						section_switch_note);
-		      jump = emit_jump_insn_before (gen_jump (cs->landing_pad),
-						    section_switch_note);
-		    }
-		  else
-		    {
-		      jump = emit_jump_insn_after (gen_jump (cs->landing_pad),
-						   section_switch_note);
-		      note = emit_label_after (pad_map[idx],
-					       section_switch_note);
-		    }
-		  JUMP_LABEL (jump) = cs->landing_pad;
-		  add_reg_note (jump, REG_CROSSING_JUMP, NULL_RTX);
-		  iter = NEXT_INSN (cs->landing_pad);
-		  if (iter && NOTE_INSN_BASIC_BLOCK_P (iter))
-		    padbb = NOTE_BASIC_BLOCK (iter);
-		  else
-		    padbb = NULL;
-		  if (padbb && prev_bb
-		      && BB_PARTITION (padbb) != BB_UNPARTITIONED)
-		    {
-		      basic_block bb;
-		      int part
-			= BB_PARTITION (padbb) == BB_COLD_PARTITION
-			  ? BB_HOT_PARTITION : BB_COLD_PARTITION;
-		      edge_iterator ei;
-		      edge e;
-		      bb = create_basic_block (note, jump, prev_bb);
-		      make_single_succ_edge (bb, padbb, EDGE_CROSSING);
-		      BB_SET_PARTITION (bb, part);
-		      for (ei = ei_start (padbb->preds);
-			   (e = ei_safe_edge (ei)); )
-			{
-			  if ((e->flags & (EDGE_EH|EDGE_CROSSING))
-			      == (EDGE_EH|EDGE_CROSSING))
-			    {
-			      redirect_edge_succ (e, bb);
-			      e->flags &= ~EDGE_CROSSING;
-			    }
-			  else
-			    ei_next (&ei);
-			}
-		      if (cur_sec == 0)
-			prev_bb = bb;
-		    }
-		}
-	      cs->landing_pad = pad_map[idx];
-	    }
-	}
-sbitmap_free (pad_loc);
-XDELETEVEC (pad_map);
-}
-htab_delete (ar_hash);
 return 0;
 }
-static bool
+namespace {
-gate_convert_to_eh_region_ranges (void)
+const pass_data pass_data_convert_to_eh_region_ranges =
+{
+RTL_PASS, /* type */
+"eh_ranges", /* name */
+OPTGROUP_NONE, /* optinfo_flags */
+TV_NONE, /* tv_id */
+0, /* properties_required */
+0, /* properties_provided */
+0, /* properties_destroyed */
+0, /* todo_flags_start */
+0, /* todo_flags_finish */
+};
+class pass_convert_to_eh_region_ranges : public rtl_opt_pass
+{
+public:
+pass_convert_to_eh_region_ranges (gcc::context *ctxt)
+: rtl_opt_pass (pass_data_convert_to_eh_region_ranges, ctxt)
+{}
+/* opt_pass methods: */
+virtual bool gate (function *);
+virtual unsigned int execute (function *)
+{
+int ret = convert_to_eh_region_ranges ();
+maybe_add_nop_after_section_switch ();
+return ret;
+}
+}; // class pass_convert_to_eh_region_ranges
+bool
+pass_convert_to_eh_region_ranges::gate (function *)
 {
 /* Nothing to do for SJLJ exceptions or if no regions created.  */
 if (cfun->eh->region_tree == NULL)
 return false;
-if (targetm.except_unwind_info (&global_options) == UI_SJLJ)
+if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
 return false;
 return true;
 }
-struct rtl_opt_pass pass_convert_to_eh_region_ranges =
+} // anon namespace
-{
-{
+rtl_opt_pass *
-RTL_PASS,
+make_pass_convert_to_eh_region_ranges (gcc::context *ctxt)
-"eh_ranges",                          /* name */
+{
-gate_convert_to_eh_region_ranges,	/* gate */
+return new pass_convert_to_eh_region_ranges (ctxt);
-convert_to_eh_region_ranges,          /* execute */
+}
-NULL,                                 /* sub */
-NULL,                                 /* next */
-0,                                    /* static_pass_number */
-TV_NONE,                              /* tv_id */
-0,                                    /* properties_required */
-0,                                    /* properties_provided */
-0,                                    /* properties_destroyed */
-0,                                    /* todo_flags_start */
-TODO_dump_func,			/* todo_flags_finish */
-}
-};
 static void
-push_uleb128 (VEC (uchar, gc) **data_area, unsigned int value)
+push_uleb128 (vec<uchar, va_gc> **data_area, unsigned int value)
 {
 do
 {
 unsigned char byte = value & 0x7f;
 value >>= 7;
 if (value)
 	byte |= 0x80;
-VEC_safe_push (uchar, gc, *data_area, byte);
+vec_safe_push (*data_area, byte);
 }
 while (value);
 }
 static void
-push_sleb128 (VEC (uchar, gc) **data_area, int value)
+push_sleb128 (vec<uchar, va_gc> **data_area, int value)
 {
 unsigned char byte;
 int more;
 do
 value >>= 7;
 more = ! ((value == 0 && (byte & 0x40) == 0)
 		|| (value == -1 && (byte & 0x40) != 0));
 if (more)
 	byte |= 0x80;
-VEC_safe_push (uchar, gc, *data_area, byte);
+vec_safe_push (*data_area, byte);
 }
 while (more);
 }
-#ifndef HAVE_AS_LEB128
 static int
 dw2_size_of_call_site_table (int section)
 {
-int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]);
+int n = vec_safe_length (crtl->eh.call_site_record_v[section]);
 int size = n * (4 + 4 + 4);
 int i;
 for (i = 0; i < n; ++i)
 {
 struct call_site_record_d *cs =
-	VEC_index (call_site_record, crtl->eh.call_site_record[section], i);
+	(*crtl->eh.call_site_record_v[section])[i];
 size += size_of_uleb128 (cs->action);
 }
 return size;
 }
 static int
 sjlj_size_of_call_site_table (void)
 {
-int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]);
+int n = vec_safe_length (crtl->eh.call_site_record_v[0]);
 int size = 0;
 int i;
 for (i = 0; i < n; ++i)
 {
 struct call_site_record_d *cs =
-	VEC_index (call_site_record, crtl->eh.call_site_record[0], i);
+	(*crtl->eh.call_site_record_v[0])[i];
 size += size_of_uleb128 (INTVAL (cs->landing_pad));
 size += size_of_uleb128 (cs->action);
 }
 return size;
 }
-#endif
 static void
 dw2_output_call_site_table (int cs_format, int section)
 {
-int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]);
+int n = vec_safe_length (crtl->eh.call_site_record_v[section]);
 int i;
 const char *begin;
 if (section == 0)
 begin = current_function_func_begin_label;
 else
 begin = crtl->subsections.cold_section_label;
 for (i = 0; i < n; ++i)
 {
-struct call_site_record_d *cs =
+struct call_site_record_d *cs = (*crtl->eh.call_site_record_v[section])[i];
-	VEC_index (call_site_record, crtl->eh.call_site_record[section], i);
 char reg_start_lab[32];
 char reg_end_lab[32];
 char landing_pad_lab[32];
 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab, "LEHB", call_site_base + i);
 }
 static void
 sjlj_output_call_site_table (void)
 {
-int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]);
+int n = vec_safe_length (crtl->eh.call_site_record_v[0]);
 int i;
 for (i = 0; i < n; ++i)
 {
-struct call_site_record_d *cs =
+struct call_site_record_d *cs = (*crtl->eh.call_site_record_v[0])[i];
-	VEC_index (call_site_record, crtl->eh.call_site_record[0], i);
 dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
 				   "region %d landing pad", i);
 dw2_asm_output_data_uleb128 (cs->action, "action");
 }
 if (exception_section)
 s = exception_section;
 else
 {
+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;
 /* Compute the section and cache it into exception_section,
 	 unless it depends on the function name.  */
-if (targetm.have_named_sections)
+if (targetm_common.have_named_sections)
 	{
-	  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)
+	  if (flag_function_sections
+	      || (DECL_COMDAT_GROUP (current_function_decl) && HAVE_COMDAT_GROUP))
 	    {
 	      char *section_name = XNEWVEC (char, strlen (fnname) + 32);
+	      /* The EH table must match the code section, so only mark
+		 it linkonce if we have COMDAT groups to tie them together.  */
+	      if (DECL_COMDAT_GROUP (current_function_decl) && HAVE_COMDAT_GROUP)
+		flags |= SECTION_LINKONCE;
 	      sprintf (section_name, ".gcc_except_table.%s", fnname);
-	      s = get_section (section_name, flags, NULL);
+	      s = get_section (section_name, flags, current_function_decl);
 	      free (section_name);
 	    }
 	  else
 #endif
 	    exception_section
 	      = s = get_section (".gcc_except_table", flags, NULL);
 	}
 else
 	exception_section
-	  = s = flag_pic ? data_section : readonly_data_section;
+	  = s = flags == SECTION_WRITE ? data_section : readonly_data_section;
 }
 switch_to_section (s);
 }
 if (type == NULL_TREE)
 value = const0_rtx;
 else
 {
-struct varpool_node *node;
 /* FIXME lto.  pass_ipa_free_lang_data changes all types to
 	 runtime types so TYPE should already be a runtime type
 	 reference.  When pass_ipa_free_lang data is made a default
 	 pass, we can then remove the call to lookup_type_for_runtime
 	 below.  */
 	 care of this for us.  */
 STRIP_NOPS (type);
 if (TREE_CODE (type) == ADDR_EXPR)
 	{
 	  type = TREE_OPERAND (type, 0);
-	  if (TREE_CODE (type) == VAR_DECL)
+	  if (VAR_P (type))
-	    {
+	    is_public = TREE_PUBLIC (type);
-	      node = varpool_node (type);
-	      if (node)
-		varpool_mark_needed_node (node);
-	      is_public = TREE_PUBLIC (type);
-	    }
 	}
 else
 	gcc_assert (TREE_CODE (type) == INTEGER_CST);
 }
 static void
 output_one_function_exception_table (int section)
 {
 int tt_format, cs_format, lp_format, i;
-#ifdef HAVE_AS_LEB128
 char ttype_label[32];
 char cs_after_size_label[32];
 char cs_end_label[32];
-#else
 int call_site_len;
-#endif
 int have_tt_data;
 int tt_format_size = 0;
-have_tt_data = (VEC_length (tree, cfun->eh->ttype_data)
+have_tt_data = (vec_safe_length (cfun->eh->ttype_data)
 		  || (targetm.arm_eabi_unwinder
-		      ? VEC_length (tree, cfun->eh->ehspec_data.arm_eabi)
+		      ? vec_safe_length (cfun->eh->ehspec_data.arm_eabi)
-		      : VEC_length (uchar, cfun->eh->ehspec_data.other)));
+		      : vec_safe_length (cfun->eh->ehspec_data.other)));
 /* Indicate the format of the @TType entries.  */
 if (! have_tt_data)
 tt_format = DW_EH_PE_omit;
 else
 {
 tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
-#ifdef HAVE_AS_LEB128
+if (HAVE_AS_LEB128)
-ASM_GENERATE_INTERNAL_LABEL (ttype_label,
+	ASM_GENERATE_INTERNAL_LABEL (ttype_label,
-				   section ? "LLSDATTC" : "LLSDATT",
+				     section ? "LLSDATTC" : "LLSDATT",
-				   current_function_funcdef_no);
+				     current_function_funcdef_no);
-#endif
 tt_format_size = size_of_encoded_value (tt_format);
 assemble_align (tt_format_size * BITS_PER_UNIT);
 }
 /* @LPStart pointer would go here.  */
 dw2_asm_output_data (1, tt_format, "@TType format (%s)",
 		       eh_data_format_name (tt_format));
-#ifndef HAVE_AS_LEB128
+if (!HAVE_AS_LEB128)
-if (targetm.except_unwind_info (&global_options) == UI_SJLJ)
+{
-call_site_len = sjlj_size_of_call_site_table ();
+if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
-else
+	call_site_len = sjlj_size_of_call_site_table ();
-call_site_len = dw2_size_of_call_site_table (section);
+else
-#endif
+	call_site_len = dw2_size_of_call_site_table (section);
+}
 /* A pc-relative 4-byte displacement to the @TType data.  */
 if (have_tt_data)
 {
-#ifdef HAVE_AS_LEB128
+if (HAVE_AS_LEB128)
-char ttype_after_disp_label[32];
-ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label,
-				   section ? "LLSDATTDC" : "LLSDATTD",
-				   current_function_funcdef_no);
-dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
-				    "@TType base offset");
-ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label);
-#else
-/* Ug.  Alignment queers things.  */
-unsigned int before_disp, after_disp, last_disp, disp;
-before_disp = 1 + 1;
-after_disp = (1 + size_of_uleb128 (call_site_len)
-		    + call_site_len
-		    + VEC_length (uchar, crtl->eh.action_record_data)
-		    + (VEC_length (tree, cfun->eh->ttype_data)
-		       * tt_format_size));
-disp = after_disp;
-do
 	{
-	  unsigned int disp_size, pad;
+	  char ttype_after_disp_label[32];
+	  ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label,
-	  last_disp = disp;
+				       section ? "LLSDATTDC" : "LLSDATTD",
-	  disp_size = size_of_uleb128 (disp);
+				       current_function_funcdef_no);
-	  pad = before_disp + disp_size + after_disp;
+	  dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
-	  if (pad % tt_format_size)
+					"@TType base offset");
-	    pad = tt_format_size - (pad % tt_format_size);
+	  ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label);
-	  else
-	    pad = 0;
-	  disp = after_disp + pad;
 	}
-while (disp != last_disp);
+else
+	{
-dw2_asm_output_data_uleb128 (disp, "@TType base offset");
+	  /* Ug.  Alignment queers things.  */
-#endif
+	  unsigned int before_disp, after_disp, last_disp, disp;
-}
+	  before_disp = 1 + 1;
+	  after_disp = (1 + size_of_uleb128 (call_site_len)
+			+ call_site_len
+			+ vec_safe_length (crtl->eh.action_record_data)
+			+ (vec_safe_length (cfun->eh->ttype_data)
+			   * tt_format_size));
+	  disp = after_disp;
+	  do
+	    {
+	      unsigned int disp_size, pad;
+	      last_disp = disp;
+	      disp_size = size_of_uleb128 (disp);
+	      pad = before_disp + disp_size + after_disp;
+	      if (pad % tt_format_size)
+		pad = tt_format_size - (pad % tt_format_size);
+	      else
+		pad = 0;
+	      disp = after_disp + pad;
+	    }
+	  while (disp != last_disp);
+	  dw2_asm_output_data_uleb128 (disp, "@TType base offset");
+	}
+	}
 /* Indicate the format of the call-site offsets.  */
-#ifdef HAVE_AS_LEB128
+if (HAVE_AS_LEB128)
 cs_format = DW_EH_PE_uleb128;
-#else
+else
 cs_format = DW_EH_PE_udata4;
-#endif
 dw2_asm_output_data (1, cs_format, "call-site format (%s)",
 		       eh_data_format_name (cs_format));
-#ifdef HAVE_AS_LEB128
+if (HAVE_AS_LEB128)
-ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label,
+{
-			       section ? "LLSDACSBC" : "LLSDACSB",
+ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label,
-			       current_function_funcdef_no);
+				   section ? "LLSDACSBC" : "LLSDACSB",
-ASM_GENERATE_INTERNAL_LABEL (cs_end_label,
+				   current_function_funcdef_no);
-			       section ? "LLSDACSEC" : "LLSDACSE",
+ASM_GENERATE_INTERNAL_LABEL (cs_end_label,
-			       current_function_funcdef_no);
+				   section ? "LLSDACSEC" : "LLSDACSE",
-dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label,
+				   current_function_funcdef_no);
-				"Call-site table length");
+dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label,
-ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label);
+				    "Call-site table length");
-if (targetm.except_unwind_info (&global_options) == UI_SJLJ)
+ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label);
-sjlj_output_call_site_table ();
+if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
+	sjlj_output_call_site_table ();
+else
+	dw2_output_call_site_table (cs_format, section);
+ASM_OUTPUT_LABEL (asm_out_file, cs_end_label);
+}
 else
-dw2_output_call_site_table (cs_format, section);
+{
-ASM_OUTPUT_LABEL (asm_out_file, cs_end_label);
+dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length");
-#else
+if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
-dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length");
+	sjlj_output_call_site_table ();
-if (targetm.except_unwind_info (&global_options) == UI_SJLJ)
+else
-sjlj_output_call_site_table ();
+	dw2_output_call_site_table (cs_format, section);
-else
+}
-dw2_output_call_site_table (cs_format, section);
-#endif
 /* ??? Decode and interpret the data for flag_debug_asm.  */
 {
 uchar uc;
-FOR_EACH_VEC_ELT (uchar, crtl->eh.action_record_data, i, uc)
+FOR_EACH_VEC_ELT (*crtl->eh.action_record_data, i, uc)
 dw2_asm_output_data (1, uc, 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_safe_length (cfun->eh->ttype_data);
 while (i-- > 0)
 {
-tree type = VEC_index (tree, cfun->eh->ttype_data, i);
+tree type = (*cfun->eh->ttype_data)[i];
 output_ttype (type, tt_format, tt_format_size);
 }
-#ifdef HAVE_AS_LEB128
+if (HAVE_AS_LEB128 && have_tt_data)
-if (have_tt_data)
+ASM_OUTPUT_LABEL (asm_out_file, ttype_label);
-ASM_OUTPUT_LABEL (asm_out_file, ttype_label);
-#endif
 /* ??? Decode and interpret the data for flag_debug_asm.  */
 if (targetm.arm_eabi_unwinder)
 {
 tree type;
 for (i = 0;
-	   VEC_iterate (tree, cfun->eh->ehspec_data.arm_eabi, i, type); ++i)
+	   vec_safe_iterate (cfun->eh->ehspec_data.arm_eabi, i, &type); ++i)
 	output_ttype (type, tt_format, tt_format_size);
 }
 else
 {
 uchar uc;
 for (i = 0;
-	   VEC_iterate (uchar, cfun->eh->ehspec_data.other, i, uc); ++i)
+	   vec_safe_iterate (cfun->eh->ehspec_data.other, i, &uc); ++i)
 	dw2_asm_output_data (1, uc,
 			     i ? NULL : "Exception specification table");
 }
 }
 /* If the target wants a label to begin the table, emit it here.  */
 targetm.asm_out.emit_except_table_label (asm_out_file);
 output_one_function_exception_table (0);
-if (crtl->eh.call_site_record[1] != NULL)
+if (crtl->eh.call_site_record_v[1])
 output_one_function_exception_table (1);
 switch_to_section (current_function_section ());
 }
 void
-set_eh_throw_stmt_table (struct function *fun, struct htab *table)
+set_eh_throw_stmt_table (function *fun, hash_map<gimple *, int> *table)
 {
 fun->eh->throw_stmt_table = table;
 }
-htab_t
+hash_map<gimple *, int> *
 get_eh_throw_stmt_table (struct function *fun)
 {
 return fun->eh->throw_stmt_table;
 }
 	  if (current_ir_type () == IR_GIMPLE)
 	    {
 	      for (lp = i->landing_pads; lp ; lp = lp->next_lp)
 		{
 		  fprintf (out, "{%i,", lp->index);
-		  print_generic_expr (out, lp->post_landing_pad, 0);
+		  print_generic_expr (out, lp->post_landing_pad);
 		  fputc ('}', out);
 		  if (lp->next_lp)
 		    fputc (',', out);
 		}
 	    }
 			     NOTE_P (lp->landing_pad) ? "(del)" : "");
 		  else
 		    fprintf (out, "(nil),");
 		  if (lp->post_landing_pad)
 		    {
-		      rtx lab = label_rtx (lp->post_landing_pad);
+		      rtx_insn *lab = label_rtx (lp->post_landing_pad);
 		      fprintf (out, "%i%s}", INSN_UID (lab),
 			       NOTE_P (lab) ? "(del)" : "");
 		    }
 		  else
 		    fprintf (out, "(nil)}");
 	      {
 		fputc ('{', out);
 		if (c->label)
 		  {
 		    fprintf (out, "lab:");
-		    print_generic_expr (out, c->label, 0);
+		    print_generic_expr (out, c->label);
 		    fputc (';', out);
 		  }
-		print_generic_expr (out, c->type_list, 0);
+		print_generic_expr (out, c->type_list);
 		fputc ('}', out);
 		if (c->next_catch)
 		  fputc (',', out);
 	      }
 	  }
 	  break;
 	case ERT_ALLOWED_EXCEPTIONS:
 	  fprintf (out, " filter :%i types:", i->u.allowed.filter);
-	  print_generic_expr (out, i->u.allowed.type_list, 0);
+	  print_generic_expr (out, i->u.allowed.type_list);
 	  break;
 	}
 fputc ('\n', out);
 /* If there are sub-regions, process them.  */
 if (!fun->eh->region_tree)
 return;
 count_r = 0;
-for (i = 1; VEC_iterate (eh_region, fun->eh->region_array, i, r); ++i)
+for (i = 1; vec_safe_iterate (fun->eh->region_array, i, &r); ++i)
 if (r)
 {
 	if (r->index == i)
 	  count_r++;
 	else
 	    err = true;
 	  }
 }
 count_lp = 0;
-for (i = 1; VEC_iterate (eh_landing_pad, fun->eh->lp_array, i, lp); ++i)
+for (i = 1; vec_safe_iterate (fun->eh->lp_array, i, &lp); ++i)
 if (lp)
 {
 	if (lp->index == i)
 	  count_lp++;
 	else
 depth = nvisited_lp = nvisited_r = 0;
 outer = NULL;
 r = fun->eh->region_tree;
 while (1)
 {
-if (VEC_index (eh_region, fun->eh->region_array, r->index) != r)
+if ((*fun->eh->region_array)[r->index] != r)
 	{
 	  error ("region_array is corrupted for region %i", r->index);
 	  err = true;
 	}
 if (r->outer != outer)
 	}
 nvisited_r++;
 for (lp = r->landing_pads; lp ; lp = lp->next_lp)
 	{
-	  if (VEC_index (eh_landing_pad, fun->eh->lp_array, lp->index) != lp)
+	  if ((*fun->eh->lp_array)[lp->index] != lp)
 	    {
 	      error ("lp_array is corrupted for lp %i", lp->index);
 	      err = true;
 	    }
 	  if (lp->region != r)

Mercurial > hg > CbC > CbC_gcc

comparison gcc/except.c @ 111:04ced10e8804