X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fexcept.c;h=fccfb735d6a5c2a7850bd15f1319c44ddc3e7dd1;hp=8bfdfe45d9dd435a84c1b28fb8b1cec787da14da;hb=493106f66ff610b15fb855a85ba53fea69d322a8;hpb=8c4c00c181e6df4f0a9afc76e4c9edbbc1c2fd41 diff --git a/gcc/except.c b/gcc/except.c index 8bfdfe45d9d..fccfb735d6a 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -1,6 +1,6 @@ /* Implements exception handling. Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. Contributed by Mike Stump . @@ -21,30 +21,94 @@ along with GCC; see the file COPYING3. If not see . */ -/* An exception is an event that can be signaled from within a - function. This event can then be "caught" or "trapped" by the - callers of this function. This potentially allows program flow to - be transferred to any arbitrary code associated with a function call - several levels up the stack. - - The intended use for this mechanism is for signaling "exceptional - events" in an out-of-band fashion, hence its name. The C++ language - (and many other OO-styled or functional languages) practically - requires such a mechanism, as otherwise it becomes very difficult - or even impossible to signal failure conditions in complex - situations. The traditional C++ example is when an error occurs in - the process of constructing an object; without such a mechanism, it - is impossible to signal that the error occurs without adding global - state variables and error checks around every object construction. - - The act of causing this event to occur is referred to as "throwing - an exception". (Alternate terms include "raising an exception" or - "signaling an exception".) The term "throw" is used because control - is returned to the callers of the function that is signaling the - exception, and thus there is the concept of "throwing" the - exception up the call stack. - - [ Add updated documentation on how to use this. ] */ +/* An exception is an event that can be "thrown" from within a + function. This event can then be "caught" by the callers of + the function. + + The representation of exceptions changes several times during + the compilation process: + + In the beginning, in the front end, we have the GENERIC trees + TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR, + CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR. + + During initial gimplification (gimplify.c) these are lowered + to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes. + The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted + into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1 + conversion. + + During pass_lower_eh (tree-eh.c) we record the nested structure + of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE. + We expand the lang_protect_cleanup_actions hook into MUST_NOT_THROW + regions at this time. We can then flatten the statements within + the TRY nodes to straight-line code. Statements that had been within + TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE, + so that we may remember what action is supposed to be taken if + a given statement does throw. During this lowering process, + we create an EH_LANDING_PAD node for each EH_REGION that has + some code within the function that needs to be executed if a + throw does happen. We also create RESX statements that are + used to transfer control from an inner EH_REGION to an outer + EH_REGION. We also create EH_DISPATCH statements as placeholders + for a runtime type comparison that should be made in order to + select the action to perform among different CATCH and EH_FILTER + regions. + + During pass_lower_eh_dispatch (tree-eh.c), which is run after + all inlining is complete, we are able to run assign_filter_values, + which allows us to map the set of types manipulated by all of the + CATCH and EH_FILTER regions to a set of integers. This set of integers + will be how the exception runtime communicates with the code generated + within the function. We then expand the GIMPLE_EH_DISPATCH statements + to a switch or conditional branches that use the argument provided by + the runtime (__builtin_eh_filter) and the set of integers we computed + in assign_filter_values. + + During pass_lower_resx (tree-eh.c), which is run near the end + of optimization, we expand RESX statements. If the eh region + that is outer to the RESX statement is a MUST_NOT_THROW, then + the RESX expands to some form of abort statement. If the eh + region that is outer to the RESX statement is within the current + function, then the RESX expands to a bookkeeping call + (__builtin_eh_copy_values) and a goto. Otherwise, the next + handler for the exception must be within a function somewhere + up the call chain, so we call back into the exception runtime + (__builtin_unwind_resume). + + 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 + 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 + exception edges within the CFG are redirected to the new landing pads. + If the target uses setjmp to implement exceptions, the various extra + calls into the runtime to register and unregister the current stack + frame are emitted at this time. + + During pass_convert_to_eh_region_ranges (except.c), we transform + the REG_EH_REGION notes attached to individual insns into + non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG + and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the + same associated action within the exception region tree, meaning + that (1) the exception is caught by the same landing pad within the + current function, (2) the exception is blocked by the runtime with + a MUST_NOT_THROW region, or (3) the exception is not handled at all + within the current function. + + Finally, during assembly generation, we call + output_function_exception_table (except.c) to emit the tables with + which the exception runtime can determine if a given stack frame + handles a given exception, and if so what filter value to provide + to the function when the non-local control transfer is effected. + If the target uses dwarf2 unwinding to implement exceptions, then + output_call_frame_info (dwarf2out.c) emits the required unwind data. */ #include "config.h" @@ -77,6 +141,7 @@ along with GCC; see the file COPYING3. If not see #include "diagnostic.h" #include "tree-pass.h" #include "timevar.h" +#include "tree-flow.h" /* Provide defaults for stuff that may not be defined when using sjlj exceptions. */ @@ -84,25 +149,10 @@ along with GCC; see the file COPYING3. If not see #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM #endif - /* Protect cleanup actions with must-not-throw regions, with a call to the given failure handler. */ tree (*lang_protect_cleanup_actions) (void); -/* Return true if type A catches type B. */ -int (*lang_eh_type_covers) (tree a, tree b); - -/* Map a type to a runtime object to match type. */ -tree (*lang_eh_runtime_type) (tree); - -/* A hash table of label to region number. */ - -struct ehl_map_entry GTY(()) -{ - rtx label; - struct eh_region *region; -}; - static GTY(()) int call_site_base; static GTY ((param_is (union tree_node))) htab_t type_to_runtime_map; @@ -115,149 +165,18 @@ static int sjlj_fc_personality_ofs; static int sjlj_fc_lsda_ofs; static int sjlj_fc_jbuf_ofs; -/* Describes one exception region. */ -struct eh_region GTY(()) -{ - /* The immediately surrounding region. */ - struct eh_region *outer; - - /* The list of immediately contained regions. */ - struct eh_region *inner; - struct eh_region *next_peer; - - /* An identifier for this region. */ - int region_number; - - /* When a region is deleted, its parents inherit the REG_EH_REGION - numbers already assigned. */ - 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; - - /* 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; - - /* 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; - tree type_list; - tree filter_list; - } GTY ((tag ("ERT_CATCH"))) catch; - - /* A tree_list of allowed types. */ - struct eh_region_u_allowed { - tree type_list; - int filter; - } GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed; - - /* The type given by a call to "throw foo();", or discovered - for a throw. */ - struct eh_region_u_throw { - tree type; - } GTY ((tag ("ERT_THROW"))) throw; - - /* 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; - } GTY ((tag ("ERT_CLEANUP"))) cleanup; - } GTY ((desc ("%0.type"))) u; - - /* Entry point for this region's handler before landing pads are built. */ - rtx label; - tree tree_label; - - /* Entry point for this region's handler from the runtime eh library. */ - rtx landing_pad; - - /* Entry point for this region's handler from an inner region. */ - rtx post_landing_pad; - - /* The RESX insn for handing off control to the next outermost handler, - if appropriate. */ - rtx resume; - - /* True if something in this region may throw. */ - unsigned may_contain_throw : 1; -}; - -typedef struct eh_region *eh_region; -struct call_site_record GTY(()) +struct GTY(()) call_site_record_d { rtx landing_pad; int action; }; - -DEF_VEC_P(eh_region); -DEF_VEC_ALLOC_P(eh_region, gc); - -/* Used to save exception status for each function. */ -struct eh_status GTY(()) -{ - /* The tree of all regions for this function. */ - struct 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; - - /* This is the region for which we are processing catch blocks. */ - struct eh_region *try_region; - - rtx filter; - rtx exc_ptr; - - int built_landing_pads; - int last_region_number; - - VEC(tree,gc) *ttype_data; - varray_type ehspec_data; - varray_type action_record_data; - - htab_t GTY ((param_is (struct ehl_map_entry))) exception_handler_label_map; - - struct call_site_record * GTY ((length ("%h.call_site_data_used"))) - call_site_data; - int call_site_data_used; - int call_site_data_size; - - rtx ehr_stackadj; - rtx ehr_handler; - rtx ehr_label; - - rtx sjlj_fc; - rtx sjlj_exit_after; - - htab_t GTY((param_is (struct throw_stmt_node))) throw_stmt_table; -}; +static 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 void add_type_for_runtime (tree); -static tree lookup_type_for_runtime (tree); - -static void remove_unreachable_regions (rtx); static int ttypes_filter_eq (const void *, const void *); static hashval_t ttypes_filter_hash (const void *); @@ -265,57 +184,21 @@ 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 assign_filter_values (void); -static void build_post_landing_pads (void); -static void connect_post_landing_pads (void); static void dw2_build_landing_pads (void); -struct sjlj_lp_info; -static bool sjlj_find_directly_reachable_regions (struct sjlj_lp_info *); -static void sjlj_assign_call_site_values (rtx, struct sjlj_lp_info *); -static void sjlj_mark_call_sites (struct sjlj_lp_info *); -static void sjlj_emit_function_enter (rtx); -static void sjlj_emit_function_exit (void); -static void sjlj_emit_dispatch_table (rtx, struct sjlj_lp_info *); -static void sjlj_build_landing_pads (void); - -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 remove_exception_handler_label (rtx); -static void remove_eh_handler (struct eh_region *); -static int for_each_eh_label_1 (void **, void *); - -/* The return value of reachable_next_level. */ -enum reachable_code -{ - /* The given exception is not processed by the given region. */ - RNL_NOT_CAUGHT, - /* The given exception may need processing by the given region. */ - RNL_MAYBE_CAUGHT, - /* The given exception is completely processed by the given region. */ - RNL_CAUGHT, - /* The given exception is completely processed by the runtime. */ - RNL_BLOCKED -}; - -struct reachable_info; -static enum reachable_code reachable_next_level (struct 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 add_call_site (rtx, int); +static int collect_one_action_chain (htab_t, eh_region); +static int add_call_site (rtx, int, int); -static void push_uleb128 (varray_type *, unsigned int); -static void push_sleb128 (varray_type *, int); +static void push_uleb128 (VEC (uchar, gc) **, unsigned int); +static void push_sleb128 (VEC (uchar, gc) **, int); #ifndef HAVE_AS_LEB128 -static int dw2_size_of_call_site_table (void); +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 (void); +static void dw2_output_call_site_table (int, int); static void sjlj_output_call_site_table (void); @@ -359,25 +242,31 @@ init_eh (void) sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE); - f_prev = build_decl (FIELD_DECL, get_identifier ("__prev"), + f_prev = build_decl (BUILTINS_LOCATION, + FIELD_DECL, get_identifier ("__prev"), build_pointer_type (sjlj_fc_type_node)); DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node; - f_cs = build_decl (FIELD_DECL, get_identifier ("__call_site"), + 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_array_type (lang_hooks.types.type_for_mode (word_mode, 1), + tmp = build_array_type (lang_hooks.types.type_for_mode + (targetm.unwind_word_mode (), 1), tmp); - f_data = build_decl (FIELD_DECL, get_identifier ("__data"), tmp); + f_data = build_decl (BUILTINS_LOCATION, + FIELD_DECL, get_identifier ("__data"), tmp); DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node; - f_per = build_decl (FIELD_DECL, get_identifier ("__personality"), + f_per = build_decl (BUILTINS_LOCATION, + FIELD_DECL, get_identifier ("__personality"), ptr_type_node); DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node; - f_lsda = build_decl (FIELD_DECL, get_identifier ("__lsda"), + f_lsda = build_decl (BUILTINS_LOCATION, + FIELD_DECL, get_identifier ("__lsda"), ptr_type_node); DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node; @@ -397,7 +286,8 @@ init_eh (void) #endif tmp = build_index_type (tmp); tmp = build_array_type (ptr_type_node, tmp); - f_jbuf = build_decl (FIELD_DECL, get_identifier ("__jbuf"), 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. */ @@ -438,62 +328,71 @@ 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); + + /* Make sure zero'th entries are used. */ + VEC_safe_push (eh_region, gc, cfun->eh->region_array, NULL); + VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, NULL); } /* 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_eh; #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_eh = GGC_CNEW (struct eh_region_d); + new_eh->type = type; + new_eh->outer = outer; if (outer) { - new->next_peer = outer->inner; - outer->inner = new; + new_eh->next_peer = outer->inner; + outer->inner = new_eh; } else { - new->next_peer = cfun->eh->region_tree; - cfun->eh->region_tree = new; + new_eh->next_peer = cfun->eh->region_tree; + cfun->eh->region_tree = new_eh; } - new->region_number = ++cfun->eh->last_region_number; + new_eh->index = VEC_length (eh_region, cfun->eh->region_array); + VEC_safe_push (eh_region, gc, cfun->eh->region_array, new_eh); - return new; + /* 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; + + return new_eh; } -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) { - struct eh_region *cleanup = gen_eh_region (ERT_CLEANUP, outer); - cleanup->u.cleanup.prev_try = prev_try; - return cleanup; + return gen_eh_region (ERT_CLEANUP, outer); } -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_catch +gen_eh_region_catch (eh_region t, tree type_or_list) { - struct eh_region *c, *l; + eh_catch c, l; tree type_list, type_node; + gcc_assert (t->type == ERT_TRY); + /* Ensure to always end up with a type list to normalize further processing, then register each type against the runtime types map. */ type_list = type_or_list; @@ -507,23 +406,23 @@ gen_eh_region_catch (struct eh_region *t, tree type_or_list) add_type_for_runtime (TREE_VALUE (type_node)); } - 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 = GGC_CNEW (struct eh_catch_d); + c->type_list = type_list; + l = t->u.eh_try.last_catch; + c->prev_catch = l; if (l) - l->u.catch.next_catch = c; + l->next_catch = c; else - t->u.try.catch = c; - t->u.try.last_catch = c; + t->u.eh_try.first_catch = c; + t->u.eh_try.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,693 +431,334 @@ gen_eh_region_allowed (struct eh_region *outer, tree allowed) 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) +eh_landing_pad +gen_eh_landing_pad (eh_region region) { - return region->region_number; + eh_landing_pad lp = GGC_CNEW (struct eh_landing_pad_d); + + lp->next_lp = region->landing_pads; + lp->region = region; + lp->index = VEC_length (eh_landing_pad, cfun->eh->lp_array); + region->landing_pads = lp; + + VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, lp); + + return lp; } -bool -get_eh_region_may_contain_throw (struct eh_region *region) +eh_region +get_eh_region_from_number_fn (struct function *ifun, int i) { - return region->may_contain_throw; + return VEC_index (eh_region, ifun->eh->region_array, i); } -tree -get_eh_region_tree_label (struct eh_region *region) +eh_region +get_eh_region_from_number (int i) { - return region->tree_label; + return get_eh_region_from_number_fn (cfun, i); } -void -set_eh_region_tree_label (struct eh_region *region, tree lab) +eh_landing_pad +get_eh_landing_pad_from_number_fn (struct function *ifun, int i) { - region->tree_label = lab; + return VEC_index (eh_landing_pad, ifun->eh->lp_array, i); } - -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); - gcc_assert (!reg->resume); - reg->resume = emit_jump_insn (gen_rtx_RESX (VOIDmode, region_nr)); - emit_barrier (); +eh_landing_pad +get_eh_landing_pad_from_number (int i) +{ + return get_eh_landing_pad_from_number_fn (cfun, i); } -/* Note that the current EH region (if any) may contain a throw, or a - call to a function which itself may contain a throw. */ - -void -note_eh_region_may_contain_throw (struct eh_region *region) +eh_region +get_eh_region_from_lp_number_fn (struct function *ifun, int i) { - while (region && !region->may_contain_throw) + if (i < 0) + return VEC_index (eh_region, ifun->eh->region_array, -i); + else if (i == 0) + return NULL; + else { - region->may_contain_throw = 1; - region = region->outer; + eh_landing_pad lp; + lp = VEC_index (eh_landing_pad, ifun->eh->lp_array, i); + return lp->region; } } -void -note_current_region_may_contain_throw (void) +eh_region +get_eh_region_from_lp_number (int i) { - note_eh_region_may_contain_throw (cfun->eh->cur_region); + return get_eh_region_from_lp_number_fn (cfun, i); } + +/* Returns true if the current function has exception handling regions. */ - -/* Return an rtl expression for a pointer to the exception object - within a handler. */ - -rtx -get_exception_pointer (struct function *fun) +bool +current_function_has_exception_handlers (void) { - rtx exc_ptr = fun->eh->exc_ptr; - if (fun == cfun && ! exc_ptr) - { - exc_ptr = gen_reg_rtx (ptr_mode); - fun->eh->exc_ptr = exc_ptr; - } - return exc_ptr; + return cfun->eh->region_tree != NULL; } + +/* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD. + Root it at OUTER, and apply LP_OFFSET to the lp numbers. */ -/* Return an rtl expression for the exception dispatch filter - within a handler. */ +struct duplicate_eh_regions_data +{ + duplicate_eh_regions_map label_map; + void *label_map_data; + struct pointer_map_t *eh_map; +}; -rtx -get_exception_filter (struct function *fun) +static void +duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data, + eh_region old_r, eh_region outer) { - rtx filter = fun->eh->filter; - if (fun == cfun && ! filter) - { - filter = gen_reg_rtx (targetm.eh_return_filter_mode ()); - fun->eh->filter = filter; - } - return filter; -} - -/* This section is for the exception handling specific optimization pass. */ + eh_landing_pad old_lp, new_lp; + eh_region new_r; + void **slot; -/* Random access the exception region tree. */ + new_r = gen_eh_region (old_r->type, outer); + slot = pointer_map_insert (data->eh_map, (void *)old_r); + gcc_assert (*slot == NULL); + *slot = (void *)new_r; -void -collect_eh_region_array (void) -{ - struct eh_region *i; + switch (old_r->type) + { + case ERT_CLEANUP: + break; - i = cfun->eh->region_tree; - if (! i) - return; + case ERT_TRY: + { + eh_catch oc, nc; + for (oc = old_r->u.eh_try.first_catch; oc ; oc = oc->next_catch) + { + /* We should be doing all our region duplication before and + during inlining, which is before filter lists are created. */ + gcc_assert (oc->filter_list == NULL); + nc = gen_eh_region_catch (new_r, oc->type_list); + nc->label = data->label_map (oc->label, data->label_map_data); + } + } + break; + + case ERT_ALLOWED_EXCEPTIONS: + new_r->u.allowed.type_list = old_r->u.allowed.type_list; + if (old_r->u.allowed.label) + new_r->u.allowed.label + = data->label_map (old_r->u.allowed.label, data->label_map_data); + else + new_r->u.allowed.label = NULL_TREE; + break; - VEC_safe_grow (eh_region, gc, cfun->eh->region_array, - cfun->eh->last_region_number + 1); - VEC_replace (eh_region, cfun->eh->region_array, 0, 0); + case ERT_MUST_NOT_THROW: + new_r->u.must_not_throw = old_r->u.must_not_throw; + break; + } - while (1) + for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp) { - VEC_replace (eh_region, cfun->eh->region_array, i->region_number, i); + /* Don't bother copying unused landing pads. */ + if (old_lp->post_landing_pad == NULL) + continue; - /* If there are sub-regions, process them. */ - if (i->inner) - i = i->inner; - /* If there are peers, process them. */ - else if (i->next_peer) - i = i->next_peer; - /* Otherwise, step back up the tree to the next peer. */ - else - { - do { - i = i->outer; - if (i == NULL) - return; - } while (i->next_peer == NULL); - i = i->next_peer; - } + new_lp = gen_eh_landing_pad (new_r); + slot = pointer_map_insert (data->eh_map, (void *)old_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; } + + /* Make sure to preserve the original use of __cxa_end_cleanup. */ + new_r->use_cxa_end_cleanup = old_r->use_cxa_end_cleanup; + + for (old_r = old_r->inner; old_r ; old_r = old_r->next_peer) + duplicate_eh_regions_1 (data, old_r, new_r); } -/* Remove all regions whose labels are not reachable from insns. */ +/* Duplicate the EH regions from IFUN rooted at COPY_REGION into + the current function and root the tree below OUTER_REGION. + 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. */ -static void -remove_unreachable_regions (rtx insns) +struct pointer_map_t * +duplicate_eh_regions (struct function *ifun, + eh_region copy_region, int outer_lp, + duplicate_eh_regions_map map, void *map_data) { - int i, *uid_region_num; - bool *reachable; - struct eh_region *r; - rtx insn; - - uid_region_num = xcalloc (get_max_uid (), sizeof(int)); - reachable = xcalloc (cfun->eh->last_region_number + 1, sizeof(bool)); + struct duplicate_eh_regions_data data; + eh_region outer_region; - for (i = cfun->eh->last_region_number; i > 0; --i) - { - r = VEC_index (eh_region, cfun->eh->region_array, i); - if (!r || r->region_number != i) - continue; +#ifdef ENABLE_CHECKING + verify_eh_tree (ifun); +#endif - if (r->resume) - { - gcc_assert (!uid_region_num[INSN_UID (r->resume)]); - uid_region_num[INSN_UID (r->resume)] = i; - } - if (r->label) - { - gcc_assert (!uid_region_num[INSN_UID (r->label)]); - uid_region_num[INSN_UID (r->label)] = i; - } - } + data.label_map = map; + data.label_map_data = map_data; + data.eh_map = pointer_map_create (); - for (insn = insns; insn; insn = NEXT_INSN (insn)) - reachable[uid_region_num[INSN_UID (insn)]] = true; + outer_region = get_eh_region_from_lp_number (outer_lp); - for (i = cfun->eh->last_region_number; i > 0; --i) + /* Copy all the regions in the subtree. */ + if (copy_region) + duplicate_eh_regions_1 (&data, copy_region, outer_region); + else { - r = VEC_index (eh_region, cfun->eh->region_array, i); - if (r && r->region_number == i && !reachable[i]) - { - bool kill_it = true; - switch (r->type) - { - case ERT_THROW: - /* Don't remove ERT_THROW regions if their outer region - is reachable. */ - if (r->outer && reachable[r->outer->region_number]) - kill_it = false; - break; - - case ERT_MUST_NOT_THROW: - /* MUST_NOT_THROW regions are implementable solely in the - runtime, but their existence continues to affect calls - within that region. Never delete them here. */ - kill_it = false; - break; - - case ERT_TRY: - { - /* 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) - if (reachable[c->region_number]) - { - kill_it = false; - break; - } - break; - } - - default: - break; - } - - if (kill_it) - remove_eh_handler (r); - } + eh_region r; + for (r = ifun->eh->region_tree; r ; r = r->next_peer) + duplicate_eh_regions_1 (&data, r, outer_region); } - free (reachable); - free (uid_region_num); +#ifdef ENABLE_CHECKING + verify_eh_tree (cfun); +#endif + + return data.eh_map; } -/* Set up EH labels for RTL. */ +/* Return the region that is outer to both REGION_A and REGION_B in IFUN. */ -void -convert_from_eh_region_ranges (void) +eh_region +eh_region_outermost (struct function *ifun, eh_region region_a, + eh_region region_b) { - rtx insns = get_insns (); - int i, n = cfun->eh->last_region_number; + sbitmap b_outer; + + gcc_assert (ifun->eh->region_array); + gcc_assert (ifun->eh->region_tree); - /* Most of the work is already done at the tree level. All we need to - do is collect the rtl labels that correspond to the tree labels that - collect the rtl labels that correspond to the tree labels - we allocated earlier. */ - for (i = 1; i <= n; ++i) + b_outer = sbitmap_alloc (VEC_length (eh_region, ifun->eh->region_array)); + sbitmap_zero (b_outer); + + do { - struct eh_region *region; + SET_BIT (b_outer, region_b->index); + region_b = region_b->outer; + } + while (region_b); - region = VEC_index (eh_region, cfun->eh->region_array, i); - if (region && region->tree_label) - region->label = DECL_RTL_IF_SET (region->tree_label); + do + { + if (TEST_BIT (b_outer, region_a->index)) + break; + region_a = region_a->outer; } + while (region_a); - remove_unreachable_regions (insns); + sbitmap_free (b_outer); + return region_a; } - -static void -add_ehl_entry (rtx label, struct eh_region *region) + +static int +t2r_eq (const void *pentry, const void *pdata) { - struct ehl_map_entry **slot, *entry; - - LABEL_PRESERVE_P (label) = 1; - - entry = ggc_alloc (sizeof (*entry)); - entry->label = label; - entry->region = region; - - slot = (struct ehl_map_entry **) - htab_find_slot (cfun->eh->exception_handler_label_map, entry, INSERT); + const_tree const entry = (const_tree) pentry; + const_tree const data = (const_tree) pdata; - /* Before landing pad creation, each exception handler has its own - label. After landing pad creation, the exception handlers may - share landing pads. This is ok, since maybe_remove_eh_handler - only requires the 1-1 mapping before landing pad creation. */ - gcc_assert (!*slot || cfun->eh->built_landing_pads); + return TREE_PURPOSE (entry) == data; +} - *slot = entry; +static hashval_t +t2r_hash (const void *pentry) +{ + const_tree const entry = (const_tree) pentry; + return TREE_HASH (TREE_PURPOSE (entry)); } void -find_exception_handler_labels (void) +add_type_for_runtime (tree type) { - int i; - - if (cfun->eh->exception_handler_label_map) - htab_empty (cfun->eh->exception_handler_label_map); - else - { - /* ??? The expansion factor here (3/2) must be greater than the htab - occupancy factor (4/3) to avoid unnecessary resizing. */ - cfun->eh->exception_handler_label_map - = htab_create_ggc (cfun->eh->last_region_number * 3 / 2, - ehl_hash, ehl_eq, NULL); - } + tree *slot; - if (cfun->eh->region_tree == NULL) + /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */ + if (TREE_CODE (type) == NOP_EXPR) return; - for (i = cfun->eh->last_region_number; i > 0; --i) + slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type, + TREE_HASH (type), INSERT); + if (*slot == NULL) { - struct eh_region *region; - rtx lab; - - region = VEC_index (eh_region, cfun->eh->region_array, i); - if (! region || region->region_number != i) - continue; - if (cfun->eh->built_landing_pads) - lab = region->landing_pad; - else - lab = region->label; - - if (lab) - add_ehl_entry (lab, region); + tree runtime = lang_hooks.eh_runtime_type (type); + *slot = tree_cons (type, runtime, NULL_TREE); } - - /* For sjlj exceptions, need the return label to remain live until - after landing pad generation. */ - if (USING_SJLJ_EXCEPTIONS && ! cfun->eh->built_landing_pads) - add_ehl_entry (return_label, NULL); } -/* Returns true if the current function has exception handling regions. */ - -bool -current_function_has_exception_handlers (void) +tree +lookup_type_for_runtime (tree type) { - int i; + tree *slot; - for (i = cfun->eh->last_region_number; i > 0; --i) - { - struct eh_region *region; + /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */ + if (TREE_CODE (type) == NOP_EXPR) + return type; - region = VEC_index (eh_region, cfun->eh->region_array, i); - if (region - && region->region_number == i - && region->type != ERT_THROW) - return true; - } + slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type, + TREE_HASH (type), NO_INSERT); - return false; + /* We should have always inserted the data earlier. */ + return TREE_VALUE (*slot); } + -/* A subroutine of duplicate_eh_regions. Search the region tree under O - for the minimum and maximum region numbers. Update *MIN and *MAX. */ +/* Represent an entry in @TTypes for either catch actions + or exception filter actions. */ +struct GTY(()) ttypes_filter { + tree t; + int filter; +}; -static void -duplicate_eh_regions_0 (eh_region o, int *min, int *max) +/* 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 +ttypes_filter_eq (const void *pentry, const void *pdata) { - if (o->region_number < *min) - *min = o->region_number; - if (o->region_number > *max) - *max = o->region_number; + const struct ttypes_filter *const entry + = (const struct ttypes_filter *) pentry; + const_tree const data = (const_tree) pdata; - if (o->inner) - { - o = o->inner; - duplicate_eh_regions_0 (o, min, max); - while (o->next_peer) - { - o = o->next_peer; - duplicate_eh_regions_0 (o, min, max); - } - } + return entry->t == data; } -/* A subroutine of duplicate_eh_regions. Copy the region tree under OLD. - Root it at OUTER, and apply EH_OFFSET to the region number. Don't worry - about the other internal pointers just yet, just the tree-like pointers. */ - -static eh_region -duplicate_eh_regions_1 (eh_region old, eh_region outer, int eh_offset) +static hashval_t +ttypes_filter_hash (const void *pentry) { - eh_region ret, n; - - ret = n = ggc_alloc (sizeof (struct eh_region)); - - *n = *old; - n->outer = outer; - n->next_peer = NULL; - gcc_assert (!old->aka); + const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry; + return TREE_HASH (entry->t); +} - n->region_number += eh_offset; - VEC_replace (eh_region, cfun->eh->region_array, n->region_number, n); +/* 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. */ - if (old->inner) - { - old = old->inner; - n = n->inner = duplicate_eh_regions_1 (old, ret, eh_offset); - while (old->next_peer) - { - old = old->next_peer; - n = n->next_peer = duplicate_eh_regions_1 (old, ret, eh_offset); - } - } +static int +ehspec_filter_eq (const void *pentry, const void *pdata) +{ + const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry; + const struct ttypes_filter *data = (const struct ttypes_filter *) pdata; - return ret; + return type_list_equal (entry->t, data->t); } -/* Duplicate the EH regions of IFUN, rooted at COPY_REGION, into current - function and root the tree below OUTER_REGION. Remap labels using MAP - callback. The special case of COPY_REGION of 0 means all regions. */ +/* Hash function for exception specification lists. */ -int -duplicate_eh_regions (struct function *ifun, duplicate_eh_regions_map map, - void *data, int copy_region, int outer_region) +static hashval_t +ehspec_filter_hash (const void *pentry) { - eh_region cur, prev_try, outer, *splice; - int i, min_region, max_region, eh_offset, cfun_last_region_number; - int num_regions; - - if (!ifun->eh->region_tree) - return 0; - - /* Find the range of region numbers to be copied. The interface we - provide here mandates a single offset to find new number from old, - which means we must look at the numbers present, instead of the - count or something else. */ - if (copy_region > 0) - { - min_region = INT_MAX; - max_region = 0; - - cur = VEC_index (eh_region, ifun->eh->region_array, copy_region); - duplicate_eh_regions_0 (cur, &min_region, &max_region); - } - else - min_region = 1, max_region = ifun->eh->last_region_number; - num_regions = max_region - min_region + 1; - cfun_last_region_number = cfun->eh->last_region_number; - eh_offset = cfun_last_region_number + 1 - min_region; - - /* If we've not yet created a region array, do so now. */ - VEC_safe_grow (eh_region, gc, cfun->eh->region_array, - cfun_last_region_number + 1 + num_regions); - cfun->eh->last_region_number = max_region + eh_offset; - - /* We may have just allocated the array for the first time. - Make sure that element zero is null. */ - VEC_replace (eh_region, cfun->eh->region_array, 0, 0); - - /* Zero all entries in the range allocated. */ - memset (VEC_address (eh_region, cfun->eh->region_array) - + cfun_last_region_number + 1, 0, num_regions * sizeof (eh_region)); - - /* Locate the spot at which to insert the new tree. */ - if (outer_region > 0) - { - outer = VEC_index (eh_region, cfun->eh->region_array, outer_region); - splice = &outer->inner; - } - else - { - outer = NULL; - splice = &cfun->eh->region_tree; - } - while (*splice) - splice = &(*splice)->next_peer; - - /* Copy all the regions in the subtree. */ - if (copy_region > 0) - { - cur = VEC_index (eh_region, ifun->eh->region_array, copy_region); - *splice = duplicate_eh_regions_1 (cur, outer, eh_offset); - } - else - { - eh_region n; - - cur = ifun->eh->region_tree; - *splice = n = duplicate_eh_regions_1 (cur, outer, eh_offset); - while (cur->next_peer) - { - cur = cur->next_peer; - n = n->next_peer = duplicate_eh_regions_1 (cur, outer, eh_offset); - } - } - - /* Remap all the labels in the new regions. */ - for (i = cfun_last_region_number + 1; - VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i) - if (cur && cur->tree_label) - cur->tree_label = map (cur->tree_label, data); - - /* Search for the containing ERT_TRY region to fix up - the prev_try short-cuts for ERT_CLEANUP regions. */ - prev_try = NULL; - if (outer_region > 0) - for (prev_try = VEC_index (eh_region, cfun->eh->region_array, outer_region); - prev_try && prev_try->type != ERT_TRY; - prev_try = prev_try->outer) - if (prev_try->type == ERT_MUST_NOT_THROW) - { - prev_try = NULL; - break; - } - - /* Remap all of the internal catch and cleanup linkages. Since we - duplicate entire subtrees, all of the referenced regions will have - been copied too. And since we renumbered them as a block, a simple - bit of arithmetic finds us the index for the replacement region. */ - for (i = cfun_last_region_number + 1; - VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i) - { - if (cur == NULL) - continue; - -#define REMAP(REG) \ - (REG) = VEC_index (eh_region, cfun->eh->region_array, \ - (REG)->region_number + eh_offset) - - 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); - break; - - case ERT_CATCH: - if (cur->u.catch.next_catch) - REMAP (cur->u.catch.next_catch); - if (cur->u.catch.prev_catch) - REMAP (cur->u.catch.prev_catch); - break; - - case ERT_CLEANUP: - if (cur->u.cleanup.prev_try) - REMAP (cur->u.cleanup.prev_try); - else - cur->u.cleanup.prev_try = prev_try; - break; - - default: - break; - } - -#undef REMAP - } - - return eh_offset; -} - -/* Return true if REGION_A is outer to REGION_B in IFUN. */ - -bool -eh_region_outer_p (struct function *ifun, int region_a, int region_b) -{ - struct eh_region *rp_a, *rp_b; - - gcc_assert (ifun->eh->last_region_number > 0); - gcc_assert (ifun->eh->region_tree); - - rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a); - rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b); - gcc_assert (rp_a != NULL); - gcc_assert (rp_b != NULL); - - do - { - if (rp_a == rp_b) - return true; - rp_b = rp_b->outer; - } - while (rp_b); - - return false; -} - -/* Return region number of region that is outer to both if REGION_A and - REGION_B in IFUN. */ - -int -eh_region_outermost (struct function *ifun, int region_a, int region_b) -{ - struct eh_region *rp_a, *rp_b; - sbitmap b_outer; - - gcc_assert (ifun->eh->last_region_number > 0); - gcc_assert (ifun->eh->region_tree); - - rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a); - rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b); - gcc_assert (rp_a != NULL); - gcc_assert (rp_b != NULL); - - b_outer = sbitmap_alloc (ifun->eh->last_region_number + 1); - sbitmap_zero (b_outer); - - do - { - SET_BIT (b_outer, rp_b->region_number); - rp_b = rp_b->outer; - } - while (rp_b); - - do - { - if (TEST_BIT (b_outer, rp_a->region_number)) - { - sbitmap_free (b_outer); - return rp_a->region_number; - } - rp_a = rp_a->outer; - } - while (rp_a); - - sbitmap_free (b_outer); - return -1; -} - -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)); -} - -static void -add_type_for_runtime (tree type) -{ - tree *slot; - - slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type, - TREE_HASH (type), INSERT); - if (*slot == NULL) - { - tree runtime = (*lang_eh_runtime_type) (type); - *slot = tree_cons (type, runtime, NULL_TREE); - } -} - -static tree -lookup_type_for_runtime (tree type) -{ - tree *slot; - - 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); -} - - -/* Represent an entry in @TTypes for either catch actions - or exception filter actions. */ -struct ttypes_filter GTY(()) -{ - tree t; - int filter; -}; - -/* 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 -ttypes_filter_eq (const void *pentry, const void *pdata) -{ - 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 -ttypes_filter_hash (const void *pentry) -{ - const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry; - return TREE_HASH (entry->t); -} - -/* 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 -ehspec_filter_eq (const void *pentry, const void *pdata) -{ - 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 -ehspec_filter_hash (const void *pentry) -{ - const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry; - hashval_t h = 0; - tree list; + 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)); @@ -1266,30 +806,38 @@ add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list) if ((n = *slot) == NULL) { + int len; + + if (targetm.arm_eabi_unwinder) + len = VEC_length (tree, cfun->eh->ehspec_data.arm_eabi); + else + len = VEC_length (uchar, 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; - n->filter = -(VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) + 1); + n->filter = -(len + 1); *slot = n; /* Generate a 0 terminated list of filter values. */ for (; list ; list = TREE_CHAIN (list)) { if (targetm.arm_eabi_unwinder) - VARRAY_PUSH_TREE (cfun->eh->ehspec_data, TREE_VALUE (list)); + VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, + 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, - add_ttypes_entry (ttypes_hash, TREE_VALUE (list))); + push_uleb128 (&cfun->eh->ehspec_data.other, + add_ttypes_entry (ttypes_hash, TREE_VALUE (list))); } } if (targetm.arm_eabi_unwinder) - VARRAY_PUSH_TREE (cfun->eh->ehspec_data, NULL_TREE); + VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, NULL_TREE); else - VARRAY_PUSH_UCHAR (cfun->eh->ehspec_data, 0); + VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, 0); } return n->filter; @@ -1300,64 +848,63 @@ add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list) we use lots of landing pads, and so every type or list can share the same filter value, which saves table space. */ -static void +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); if (targetm.arm_eabi_unwinder) - VARRAY_TREE_INIT (cfun->eh->ehspec_data, 64, "ehspec_data"); + cfun->eh->ehspec_data.arm_eabi = VEC_alloc (tree, gc, 64); else - VARRAY_UCHAR_INIT (cfun->eh->ehspec_data, 64, "ehspec_data"); + cfun->eh->ehspec_data.other = VEC_alloc (uchar, gc, 64); ttypes = htab_create (31, ttypes_filter_hash, ttypes_filter_eq, free); ehspec = htab_create (31, ehspec_filter_hash, ehspec_filter_eq, free); - for (i = cfun->eh->last_region_number; i > 0; --i) + for (i = 1; VEC_iterate (eh_region, cfun->eh->region_array, i, r); ++i) { - struct eh_region *r; - - r = VEC_index (eh_region, cfun->eh->region_array, i); - - /* Mind we don't process a region more than once. */ - if (!r || r->region_number != i) + if (r == NULL) continue; switch (r->type) { - 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; - - if (r->u.catch.type_list != NULL) + case ERT_TRY: + for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) { - /* 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; + /* Whatever type_list is (NULL or true list), we build a list + of filters for the region. */ + c->filter_list = NULL_TREE; - for (;tp_node; tp_node = TREE_CHAIN (tp_node)) + if (c->type_list != NULL) { - int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node)); - tree flt_node = build_int_cst (NULL_TREE, flt); + /* Get a filter value for each of the types caught and store + them in the region's dedicated list. */ + tree tp_node = c->type_list; - r->u.catch.filter_list - = tree_cons (NULL_TREE, flt_node, r->u.catch.filter_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); + + 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); - tree flt_node = build_int_cst (NULL_TREE, flt); + 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); + 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); + c->filter_list + = tree_cons (NULL_TREE, flt_node, NULL); + } } - break; case ERT_ALLOWED_EXCEPTIONS: @@ -1401,233 +948,30 @@ emit_to_new_bb_before (rtx seq, rtx insn) bb->flags |= BB_SUPERBLOCK; return bb; } - -/* Generate the code to actually handle exceptions, which will follow the - landing pads. */ - -static void -build_post_landing_pads (void) -{ - int i; - - for (i = cfun->eh->last_region_number; i > 0; --i) - { - struct eh_region *region; - rtx seq; - - region = VEC_index (eh_region, cfun->eh->region_array, i); - /* Mind we don't process a region more than once. */ - if (!region || region->region_number != i) - continue; - - switch (region->type) - { - case ERT_TRY: - /* ??? Collect the set of all non-overlapping catch handlers - all the way up the chain until blocked by a cleanup. */ - /* ??? Outer try regions can share landing pads with inner - try regions if the types are completely non-overlapping, - and there are no intervening cleanups. */ - - region->post_landing_pad = gen_label_rtx (); - - start_sequence (); - - emit_label (region->post_landing_pad); - - /* ??? It is mighty inconvenient to call back into the - 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) - { - if (c->u.catch.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; - - for (; tp_node; ) - { - emit_cmp_and_jump_insns - (cfun->eh->filter, - GEN_INT (tree_low_cst (TREE_VALUE (flt_node), 0)), - EQ, NULL_RTX, - targetm.eh_return_filter_mode (), 0, c->label); - - tp_node = TREE_CHAIN (tp_node); - flt_node = TREE_CHAIN (flt_node); - } - } - } - } - - /* We delay the generation of the _Unwind_Resume until we generate - landing pads. We emit a marker here so as to get good control - flow data in the meantime. */ - region->resume - = emit_jump_insn (gen_rtx_RESX (VOIDmode, region->region_number)); - emit_barrier (); - - seq = get_insns (); - end_sequence (); - - emit_to_new_bb_before (seq, region->u.try.catch->label); - - break; - - case ERT_ALLOWED_EXCEPTIONS: - region->post_landing_pad = gen_label_rtx (); - - start_sequence (); - - emit_label (region->post_landing_pad); - - emit_cmp_and_jump_insns (cfun->eh->filter, - GEN_INT (region->u.allowed.filter), - EQ, NULL_RTX, - targetm.eh_return_filter_mode (), 0, region->label); - - /* We delay the generation of the _Unwind_Resume until we generate - landing pads. We emit a marker here so as to get good control - flow data in the meantime. */ - region->resume - = emit_jump_insn (gen_rtx_RESX (VOIDmode, region->region_number)); - emit_barrier (); - - seq = get_insns (); - end_sequence (); - - emit_to_new_bb_before (seq, region->label); - break; - - case ERT_CLEANUP: - case ERT_MUST_NOT_THROW: - region->post_landing_pad = region->label; - break; - - case ERT_CATCH: - case ERT_THROW: - /* Nothing to do. */ - break; - - default: - gcc_unreachable (); - } - } -} - -/* Replace RESX patterns with jumps to the next handler if any, or calls to - _Unwind_Resume otherwise. */ - -static void -connect_post_landing_pads (void) -{ - int i; - - for (i = cfun->eh->last_region_number; i > 0; --i) - { - struct eh_region *region; - struct eh_region *outer; - rtx seq; - rtx barrier; - - region = VEC_index (eh_region, cfun->eh->region_array, i); - /* Mind we don't process a region more than once. */ - if (!region || region->region_number != i) - continue; - - /* If there is no RESX, or it has been deleted by flow, there's - nothing to fix up. */ - if (! region->resume || INSN_DELETED_P (region->resume)) - continue; - - /* Search for another landing pad in this function. */ - for (outer = region->outer; outer ; outer = outer->outer) - if (outer->post_landing_pad) - break; - - start_sequence (); - - if (outer) - { - edge e; - basic_block src, dest; - - emit_jump (outer->post_landing_pad); - src = BLOCK_FOR_INSN (region->resume); - dest = BLOCK_FOR_INSN (outer->post_landing_pad); - while (EDGE_COUNT (src->succs) > 0) - remove_edge (EDGE_SUCC (src, 0)); - e = make_edge (src, dest, 0); - e->probability = REG_BR_PROB_BASE; - e->count = src->count; - } - else - { - emit_library_call (unwind_resume_libfunc, LCT_THROW, - VOIDmode, 1, cfun->eh->exc_ptr, ptr_mode); - - /* What we just emitted was a throwing libcall, so it got a - barrier automatically added after it. If the last insn in - the libcall sequence isn't the barrier, it's because the - target emits multiple insns for a call, and there are insns - after the actual call insn (which are redundant and would be - optimized away). The barrier is inserted exactly after the - call insn, so let's go get that and delete the insns after - it, because below we need the barrier to be the last insn in - the sequence. */ - delete_insns_since (NEXT_INSN (last_call_insn ())); - } - - seq = get_insns (); - end_sequence (); - barrier = emit_insn_before (seq, region->resume); - /* Avoid duplicate barrier. */ - gcc_assert (BARRIER_P (barrier)); - delete_insn (barrier); - delete_insn (region->resume); - - /* ??? From tree-ssa we can wind up with catch regions whose - label is not instantiated, but whose resx is present. Now - that we've dealt with the resx, kill the region. */ - if (region->label == NULL && region->type == ERT_CLEANUP) - remove_eh_handler (region); - } -} - +/* Expand the extra code needed at landing pads for dwarf2 unwinding. */ + static void dw2_build_landing_pads (void) { int i; + eh_landing_pad lp; - for (i = cfun->eh->last_region_number; i > 0; --i) + for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i) { - struct eh_region *region; - rtx seq; + eh_region region; basic_block bb; + rtx seq; edge e; - region = VEC_index (eh_region, cfun->eh->region_array, i); - /* Mind we don't process a region more than once. */ - if (!region || region->region_number != i) - continue; - - if (region->type != ERT_CLEANUP - && region->type != ERT_TRY - && region->type != ERT_ALLOWED_EXCEPTIONS) + if (lp == NULL || lp->post_landing_pad == NULL) continue; start_sequence (); - region->landing_pad = gen_label_rtx (); - emit_label (region->landing_pad); + lp->landing_pad = gen_label_rtx (); + emit_label (lp->landing_pad); + LABEL_PRESERVE_P (lp->landing_pad) = 1; #ifdef HAVE_exception_receiver if (HAVE_exception_receiver) @@ -1641,16 +985,19 @@ dw2_build_landing_pads (void) #endif { /* Nothing */ } - emit_move_insn (cfun->eh->exc_ptr, - gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0))); - emit_move_insn (cfun->eh->filter, - gen_rtx_REG (targetm.eh_return_filter_mode (), - EH_RETURN_DATA_REGNO (1))); + 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, region->post_landing_pad); + bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad)); e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU); e->count = bb->count; e->probability = REG_BR_PROB_BASE; @@ -1658,136 +1005,71 @@ dw2_build_landing_pads (void) } -struct sjlj_lp_info -{ - int directly_reachable; - int action_index; - int dispatch_index; - int call_site_index; -}; - -static bool -sjlj_find_directly_reachable_regions (struct sjlj_lp_info *lp_info) -{ - rtx insn; - bool found_one = false; - - for (insn = get_insns (); insn ; insn = NEXT_INSN (insn)) - { - struct eh_region *region; - enum reachable_code rc; - tree type_thrown; - rtx note; - - if (! INSN_P (insn)) - continue; - - note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); - if (!note || INTVAL (XEXP (note, 0)) <= 0) - continue; - - region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0))); - - type_thrown = NULL_TREE; - if (region->type == ERT_THROW) - { - type_thrown = region->u.throw.type; - region = region->outer; - } +static VEC (int, heap) *sjlj_lp_call_site_index; - /* Find the first containing region that might handle the exception. - That's the landing pad to which we will transfer control. */ - rc = RNL_NOT_CAUGHT; - for (; region; region = region->outer) - { - rc = reachable_next_level (region, type_thrown, NULL); - if (rc != RNL_NOT_CAUGHT) - break; - } - if (rc == RNL_MAYBE_CAUGHT || rc == RNL_CAUGHT) - { - lp_info[region->region_number].directly_reachable = 1; - found_one = true; - } - } - - return found_one; -} +/* Process all active landing pads. Assign each one a compact dispatch + index, and a call-site index. */ -static void -sjlj_assign_call_site_values (rtx dispatch_label, struct sjlj_lp_info *lp_info) +static int +sjlj_assign_call_site_values (void) { htab_t ar_hash; - int i, index; - - /* First task: build the action table. */ + int i, disp_index; + eh_landing_pad lp; - VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data"); + crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64); ar_hash = htab_create (31, action_record_hash, action_record_eq, free); - 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); - - r->landing_pad = dispatch_label; - lp_info[i].action_index = collect_one_action_chain (ar_hash, r); - if (lp_info[i].action_index != -1) - cfun->uses_eh_lsda = 1; - } - - htab_delete (ar_hash); - - /* Next: assign dispatch values. In dwarf2 terms, this would be the - landing pad label for the region. For sjlj though, there is one - common landing pad from which we dispatch to the post-landing pads. - - A region receives a dispatch index if it is directly reachable - and requires in-function processing. Regions that share post-landing - pads may share dispatch indices. */ - /* ??? Post-landing pad sharing doesn't actually happen at the moment - (see build_post_landing_pads) so we don't bother checking for it. */ - - index = 0; - for (i = cfun->eh->last_region_number; i > 0; --i) - if (lp_info[i].directly_reachable) - lp_info[i].dispatch_index = index++; - - /* Finally: 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. */ - + disp_index = 0; call_site_base = 1; - for (i = cfun->eh->last_region_number; i > 0; --i) - if (lp_info[i].directly_reachable) + for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i) + if (lp && lp->post_landing_pad) { - int action = lp_info[i].action_index; + int action, call_site; + + /* First: build the action table. */ + action = collect_one_action_chain (ar_hash, lp->region); + if (action != -1) + crtl->uses_eh_lsda = 1; + /* 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. */ if (action == -2) - index = 0; + call_site = 0; /* Map no-action to otherwise unused call-site index -1. */ else if (action == -1) - index = -1; + call_site = -1; /* Otherwise, look it up in the table. */ else - index = add_call_site (GEN_INT (lp_info[i].dispatch_index), action); + call_site = add_call_site (GEN_INT (disp_index), action, 0); + VEC_replace (int, sjlj_lp_call_site_index, i, call_site); - lp_info[i].call_site_index = index; + 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 (struct sjlj_lp_info *lp_info) +sjlj_mark_call_sites (void) { int last_call_site = -2; rtx insn, mem; for (insn = get_insns (); insn ; insn = NEXT_INSN (insn)) { - struct eh_region *region; + eh_landing_pad lp; + eh_region r; + bool nothrow; int this_call_site; - rtx note, before, p; + rtx before, p; /* Reset value tracking at extended basic block boundaries. */ if (LABEL_P (insn)) @@ -1796,27 +1078,22 @@ sjlj_mark_call_sites (struct sjlj_lp_info *lp_info) if (! INSN_P (insn)) continue; - note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); - if (!note) + 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); + else if (r == NULL) { /* Calls (and trapping insns) without notes are outside any exception handling region in this function. Mark them as no action. */ - if (CALL_P (insn) - || (flag_non_call_exceptions - && may_trap_p (PATTERN (insn)))) - this_call_site = -1; - else - continue; + this_call_site = -1; } else { - /* Calls that are known to not throw need not be marked. */ - if (INTVAL (XEXP (note, 0)) <= 0) - continue; - - region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0))); - this_call_site = lp_info[region->region_number].call_site_index; + gcc_assert (r->type == ERT_MUST_NOT_THROW); + this_call_site = 0; } if (this_call_site == last_call_site) @@ -1828,7 +1105,7 @@ sjlj_mark_call_sites (struct sjlj_lp_info *lp_info) before = find_first_parameter_load (insn, NULL_RTX); start_sequence (); - mem = adjust_address (cfun->eh->sjlj_fc, TYPE_MODE (integer_type_node), + mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node), sjlj_fc_call_site_ofs); emit_move_insn (mem, GEN_INT (this_call_site)); p = get_insns (); @@ -1846,20 +1123,21 @@ sjlj_emit_function_enter (rtx dispatch_label) { rtx fn_begin, fc, mem, seq; bool fn_begin_outside_block; + rtx personality = get_personality_function (current_function_decl); - fc = cfun->eh->sjlj_fc; + fc = crtl->eh.sjlj_fc; start_sequence (); /* We're storing this libcall's address into memory instead of calling it directly. Thus, we must call assemble_external_libcall here, as we can not depend on emit_library_call to do it for us. */ - assemble_external_libcall (eh_personality_libfunc); + assemble_external_libcall (personality); mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs); - emit_move_insn (mem, eh_personality_libfunc); + emit_move_insn (mem, personality); mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs); - if (cfun->uses_eh_lsda) + if (crtl->uses_eh_lsda) { char buf[20]; rtx sym; @@ -1874,7 +1152,7 @@ sjlj_emit_function_enter (rtx dispatch_label) #ifdef DONT_USE_BUILTIN_SETJMP { - rtx x; + rtx x, last; x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE, TYPE_MODE (integer_type_node), 1, plus_constant (XEXP (fc, 0), @@ -1882,7 +1160,12 @@ sjlj_emit_function_enter (rtx dispatch_label) emit_cmp_and_jump_insns (x, const0_rtx, NE, 0, TYPE_MODE (integer_type_node), 0, dispatch_label); - add_reg_br_prob_note (get_insns (), REG_BR_PROB_BASE/100); + last = get_last_insn (); + 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), sjlj_fc_jbuf_ofs), @@ -1921,20 +1204,18 @@ sjlj_emit_function_enter (rtx dispatch_label) void sjlj_emit_function_exit_after (rtx after) { - cfun->eh->sjlj_exit_after = after; + crtl->eh.sjlj_exit_after = after; } static void sjlj_emit_function_exit (void) { - rtx seq; - edge e; - edge_iterator ei; + rtx seq, insn; start_sequence (); emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode, - 1, XEXP (cfun->eh->sjlj_fc, 0), Pmode); + 1, XEXP (crtl->eh.sjlj_fc, 0), Pmode); seq = get_insns (); end_sequence (); @@ -1943,43 +1224,28 @@ sjlj_emit_function_exit (void) post-dominates all can_throw_internal instructions. This is the last possible moment. */ - FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) - if (e->flags & EDGE_FALLTHRU) - break; - if (e) - { - rtx insn; + insn = crtl->eh.sjlj_exit_after; + if (LABEL_P (insn)) + insn = NEXT_INSN (insn); - /* Figure out whether the place we are supposed to insert libcall - is inside the last basic block or after it. In the other case - we need to emit to edge. */ - gcc_assert (e->src->next_bb == EXIT_BLOCK_PTR); - for (insn = BB_HEAD (e->src); ; insn = NEXT_INSN (insn)) - { - if (insn == cfun->eh->sjlj_exit_after) - { - if (LABEL_P (insn)) - insn = NEXT_INSN (insn); - emit_insn_after (seq, insn); - return; - } - if (insn == BB_END (e->src)) - break; - } - insert_insn_on_edge (seq, e); - } + emit_insn_after (seq, insn); } static void -sjlj_emit_dispatch_table (rtx dispatch_label, struct sjlj_lp_info *lp_info) +sjlj_emit_dispatch_table (rtx dispatch_label, int num_dispatch) { - int i, first_reachable; - rtx mem, dispatch, seq, fc; - rtx before; + enum machine_mode unwind_word_mode = targetm.unwind_word_mode (); + enum machine_mode filter_mode = targetm.eh_return_filter_mode (); + eh_landing_pad lp; + rtx mem, seq, fc, before, exc_ptr_reg, filter_reg; + rtx first_reachable_label; basic_block bb; + eh_region r; edge e; + int i, disp_index; + gimple switch_stmt; - fc = cfun->eh->sjlj_fc; + fc = crtl->eh.sjlj_fc; start_sequence (); @@ -1987,16 +1253,20 @@ sjlj_emit_dispatch_table (rtx dispatch_label, struct sjlj_lp_info *lp_info) #ifndef DONT_USE_BUILTIN_SETJMP expand_builtin_setjmp_receiver (dispatch_label); -#endif - /* Load up dispatch index, exc_ptr and filter values from the - function context. */ - mem = adjust_address (fc, TYPE_MODE (integer_type_node), - sjlj_fc_call_site_ofs); - dispatch = copy_to_reg (mem); + /* The caller of expand_builtin_setjmp_receiver is responsible for + 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 + = gen_rtx_EXPR_LIST (VOIDmode, dispatch_label, forced_labels); +#endif - mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs); - if (word_mode != ptr_mode) + /* 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) { #ifdef POINTERS_EXTEND_UNSIGNED mem = convert_memory_address (ptr_mode, mem); @@ -2004,810 +1274,590 @@ sjlj_emit_dispatch_table (rtx dispatch_label, struct sjlj_lp_info *lp_info) mem = convert_to_mode (ptr_mode, mem, 0); #endif } - emit_move_insn (cfun->eh->exc_ptr, mem); + exc_ptr_reg = force_reg (ptr_mode, mem); - mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs + UNITS_PER_WORD); - emit_move_insn (cfun->eh->filter, mem); + mem = adjust_address (fc, unwind_word_mode, + sjlj_fc_data_ofs + GET_MODE_SIZE (unwind_word_mode)); + if (unwind_word_mode != filter_mode) + mem = convert_to_mode (filter_mode, mem, 0); + filter_reg = force_reg (filter_mode, mem); /* Jump to one of the directly reachable regions. */ - /* ??? This really ought to be using a switch statement. */ - first_reachable = 0; - for (i = cfun->eh->last_region_number; i > 0; --i) + disp_index = 0; + 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) { - if (! lp_info[i].directly_reachable) - continue; + tree disp; - if (! first_reachable) - { - first_reachable = i; - continue; - } + mem = adjust_address (fc, TYPE_MODE (integer_type_node), + sjlj_fc_call_site_ofs); + disp = make_tree (integer_type_node, mem); - 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)) - ->post_landing_pad); + 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; + + start_sequence (); + + lp->landing_pad = dispatch_label; + + if (num_dispatch > 1) + { + tree t_label, case_elt; + + t_label = create_artificial_label (UNKNOWN_LOCATION); + case_elt = build3 (CASE_LABEL_EXPR, void_type_node, + build_int_cst (NULL, disp_index), + NULL, t_label); + gimple_switch_set_label (switch_stmt, disp_index, case_elt); + + label = label_rtx (t_label); + } + else + label = gen_label_rtx (); + + if (disp_index == 0) + first_reachable_label = label; + emit_label (label); + + r = lp->region; + if (r->exc_ptr_reg) + emit_move_insn (r->exc_ptr_reg, exc_ptr_reg); + if (r->filter_reg) + emit_move_insn (r->filter_reg, filter_reg); + + seq2 = get_insns (); + end_sequence (); + + before = label_rtx (lp->post_landing_pad); + bb = emit_to_new_bb_before (seq2, before); + e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU); + e->count = bb->count; + e->probability = REG_BR_PROB_BASE; + + disp_index++; + } + gcc_assert (disp_index == num_dispatch); + + if (num_dispatch > 1) + { + expand_case (switch_stmt); + expand_builtin_trap (); } seq = get_insns (); end_sequence (); - before = (((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, first_reachable)) - ->post_landing_pad); - - bb = emit_to_new_bb_before (seq, before); - e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU); - e->count = bb->count; - e->probability = REG_BR_PROB_BASE; + bb = emit_to_new_bb_before (seq, first_reachable_label); + if (num_dispatch == 1) + { + e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU); + e->count = bb->count; + e->probability = REG_BR_PROB_BASE; + } } static void sjlj_build_landing_pads (void) { - struct sjlj_lp_info *lp_info; + int num_dispatch; - lp_info = XCNEWVEC (struct sjlj_lp_info, cfun->eh->last_region_number + 1); + num_dispatch = VEC_length (eh_landing_pad, cfun->eh->lp_array); + if (num_dispatch == 0) + return; + VEC_safe_grow (int, heap, sjlj_lp_call_site_index, num_dispatch); - if (sjlj_find_directly_reachable_regions (lp_info)) + num_dispatch = sjlj_assign_call_site_values (); + if (num_dispatch > 0) { rtx dispatch_label = gen_label_rtx (); - - cfun->eh->sjlj_fc + 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), int_size_in_bytes (sjlj_fc_type_node), - TYPE_ALIGN (sjlj_fc_type_node)); - - sjlj_assign_call_site_values (dispatch_label, lp_info); - sjlj_mark_call_sites (lp_info); + align); + sjlj_mark_call_sites (); sjlj_emit_function_enter (dispatch_label); - sjlj_emit_dispatch_table (dispatch_label, lp_info); + sjlj_emit_dispatch_table (dispatch_label, num_dispatch); sjlj_emit_function_exit (); } - free (lp_info); + VEC_free (int, heap, sjlj_lp_call_site_index); } -void +/* After initial rtl generation, call back to finish generating + exception support code. */ + +static void finish_eh_generation (void) { basic_block bb; - /* Nothing to do if no regions created. */ - if (cfun->eh->region_tree == NULL) - return; - - /* The object here is to provide find_basic_blocks with detailed - information (via reachable_handlers) on how exception control - flows within the function. In this first pass, we can include - type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS - regions, and hope that it will be useful in deleting unreachable - handlers. Subsequently, we will generate landing pads which will - connect many of the handlers, and then type information will not - be effective. Still, this is a win over previous implementations. */ - - /* These registers are used by the landing pads. Make sure they - have been generated. */ - get_exception_pointer (cfun); - get_exception_filter (cfun); - /* Construct the landing pads. */ - - assign_filter_values (); - build_post_landing_pads (); - connect_post_landing_pads (); if (USING_SJLJ_EXCEPTIONS) sjlj_build_landing_pads (); else dw2_build_landing_pads (); - - cfun->eh->built_landing_pads = 1; - - /* We've totally changed the CFG. Start over. */ - find_exception_handler_labels (); break_superblocks (); - if (USING_SJLJ_EXCEPTIONS) + + if (USING_SJLJ_EXCEPTIONS + /* Kludge for Alpha/Tru64 (see alpha_gp_save_rtx). */ + || single_succ_edge (ENTRY_BLOCK_PTR)->insns.r) commit_edge_insertions (); + + /* Redirect all EH edges from the post_landing_pad to the landing pad. */ FOR_EACH_BB (bb) { - edge e; + eh_landing_pad lp; edge_iterator ei; - bool eh = false; - for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); ) + edge e; + + lp = get_eh_landing_pad_from_rtx (BB_END (bb)); + + FOR_EACH_EDGE (e, ei, bb->succs) + if (e->flags & EDGE_EH) + break; + + /* We should not have generated any new throwing insns during this + pass, and we should not have lost any EH edges, so we only need + to handle two cases here: + (1) reachable handler and an existing edge to post-landing-pad, + (2) no reachable handler and no edge. */ + gcc_assert ((lp != NULL) == (e != NULL)); + if (lp != NULL) { - if (e->flags & EDGE_EH) - { - remove_edge (e); - eh = true; - } - else - ei_next (&ei); + gcc_assert (BB_HEAD (e->dest) == label_rtx (lp->post_landing_pad)); + + redirect_edge_succ (e, BLOCK_FOR_INSN (lp->landing_pad)); + e->flags |= (CALL_P (BB_END (bb)) + ? EDGE_ABNORMAL | EDGE_ABNORMAL_CALL + : EDGE_ABNORMAL); } - if (eh) - rtl_make_eh_edge (NULL, bb, BB_END (bb)); } } - -static hashval_t -ehl_hash (const void *pentry) -{ - const struct ehl_map_entry *const entry - = (const struct ehl_map_entry *) pentry; - - /* 2^32 * ((sqrt(5) - 1) / 2) */ - const hashval_t scaled_golden_ratio = 0x9e3779b9; - return CODE_LABEL_NUMBER (entry->label) * scaled_golden_ratio; -} -static int -ehl_eq (const void *pentry, const void *pdata) +static bool +gate_handle_eh (void) { - const struct ehl_map_entry *const entry - = (const struct ehl_map_entry *) pentry; - const struct ehl_map_entry *const data - = (const struct ehl_map_entry *) pdata; - - return entry->label == data->label; + /* Nothing to do if no regions created. */ + return cfun->eh->region_tree != NULL; } -/* This section handles removing dead code for flow. */ - -/* Remove LABEL from exception_handler_label_map. */ - -static void -remove_exception_handler_label (rtx label) +/* Complete generation of exception handling code. */ +static unsigned int +rest_of_handle_eh (void) { - struct ehl_map_entry **slot, tmp; - - /* If exception_handler_label_map was not built yet, - there is nothing to do. */ - if (cfun->eh->exception_handler_label_map == NULL) - return; - - tmp.label = label; - slot = (struct ehl_map_entry **) - htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT); - gcc_assert (slot); - - htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot); + finish_eh_generation (); + cleanup_cfg (CLEANUP_NO_INSN_DEL); + return 0; } -/* Splice REGION from the region tree etc. */ - -static void -remove_eh_handler (struct eh_region *region) +struct rtl_opt_pass pass_rtl_eh = { - struct eh_region **pp, **pp_start, *p, *outer, *inner; - rtx lab; - - /* For the benefit of efficiently handling REG_EH_REGION notes, - replace this region in the region array with its containing - region. Note that previous region deletions may result in - multiple copies of this region in the array, so we have a - list of alternate numbers by which we are known. */ - - outer = region->outer; - VEC_replace (eh_region, cfun->eh->region_array, region->region_number, outer); - if (region->aka) - { - unsigned i; - bitmap_iterator bi; - - EXECUTE_IF_SET_IN_BITMAP (region->aka, 0, i, bi) - { - VEC_replace (eh_region, cfun->eh->region_array, i, outer); - } - } - - if (outer) - { - if (!outer->aka) - outer->aka = BITMAP_GGC_ALLOC (); - if (region->aka) - bitmap_ior_into (outer->aka, region->aka); - bitmap_set_bit (outer->aka, region->region_number); - } - - if (cfun->eh->built_landing_pads) - lab = region->landing_pad; - else - lab = region->label; - if (lab) - remove_exception_handler_label (lab); - - 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; - *pp = region->next_peer; - - inner = region->inner; - if (inner) - { - for (p = inner; p->next_peer ; p = p->next_peer) - p->outer = outer; - p->outer = outer; - - p->next_peer = *pp_start; - *pp_start = inner; - } - - if (region->type == ERT_CATCH) - { - struct eh_region *try, *next, *prev; - - for (try = region->next_peer; - try->type == ERT_CATCH; - try = try->next_peer) - continue; - gcc_assert (try->type == ERT_TRY); - - next = region->u.catch.next_catch; - prev = region->u.catch.prev_catch; - - if (next) - next->u.catch.prev_catch = prev; - else - try->u.try.last_catch = prev; - if (prev) - prev->u.catch.next_catch = next; - else - { - try->u.try.catch = next; - if (! next) - remove_eh_handler (try); - } - } -} - -/* LABEL heads a basic block that is about to be deleted. If this - label corresponds to an exception region, we may be able to - delete the region. */ + { + 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 -maybe_remove_eh_handler (rtx label) +remove_eh_landing_pad (eh_landing_pad lp) { - struct ehl_map_entry **slot, tmp; - struct eh_region *region; + eh_landing_pad *pp; - /* ??? After generating landing pads, it's not so simple to determine - if the region data is completely unused. One must examine the - landing pad and the post landing pad, and whether an inner try block - is referencing the catch handlers directly. */ - if (cfun->eh->built_landing_pads) - return; - - tmp.label = label; - slot = (struct ehl_map_entry **) - htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT); - if (! slot) - return; - region = (*slot)->region; - if (! region) - return; + for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp) + continue; + *pp = lp->next_lp; - /* Flow will want to remove MUST_NOT_THROW regions as unreachable - because there is no path to the fallback call to terminate. - But the region continues to affect call-site data until there - are no more contained calls, which we don't see here. */ - if (region->type == ERT_MUST_NOT_THROW) - { - htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot); - region->label = NULL_RTX; - } - else - remove_eh_handler (region); + 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); } -/* Invokes CALLBACK for every exception handler label. Only used by old - loop hackery; should not be used by new code. */ +/* Splice REGION from the region tree. */ void -for_each_eh_label (void (*callback) (rtx)) +remove_eh_handler (eh_region region) { - htab_traverse (cfun->eh->exception_handler_label_map, for_each_eh_label_1, - (void *) &callback); -} + eh_region *pp, *pp_start, p, outer; + eh_landing_pad lp; -static int -for_each_eh_label_1 (void **pentry, void *data) -{ - struct ehl_map_entry *entry = *(struct ehl_map_entry **)pentry; - void (*callback) (rtx) = *(void (**) (rtx)) data; + 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); + } - (*callback) (entry->label); - return 1; + 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) + { + *pp = p = region->inner; + do + { + p->outer = outer; + pp = &p->next_peer; + p = *pp; + } + while (p); + } + *pp = region->next_peer; + + VEC_replace (eh_region, cfun->eh->region_array, region->index, NULL); } -/* Invoke CALLBACK for every exception region in the current function. */ +/* Invokes CALLBACK for every exception handler landing pad label. + Only used by reload hackery; should not be used by new code. */ void -for_each_eh_region (void (*callback) (struct eh_region *)) +for_each_eh_label (void (*callback) (rtx)) { - int i, n = cfun->eh->last_region_number; - for (i = 1; i <= n; ++i) - { - struct eh_region *region; + eh_landing_pad lp; + int i; - region = VEC_index (eh_region, cfun->eh->region_array, i); - if (region) - (*callback) (region); + for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i) + { + if (lp) + { + rtx lab = lp->landing_pad; + if (lab && LABEL_P (lab)) + (*callback) (lab); + } } } -/* This section describes CFG exception edges for flow. */ - -/* For communicating between calls to reachable_next_level. */ -struct reachable_info -{ - tree types_caught; - tree types_allowed; - void (*callback) (struct eh_region *, void *); - void *callback_data; - bool saw_any_handlers; -}; +/* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a + call insn. + + At the gimple level, we use LP_NR + > 0 : The statement transfers to landing pad LP_NR + = 0 : The statement is outside any EH region + < 0 : The statement is within MUST_NOT_THROW region -LP_NR. + + At the rtl level, we use LP_NR + > 0 : The insn transfers to landing pad LP_NR + = 0 : The insn cannot throw + < 0 : The insn is within MUST_NOT_THROW region -LP_NR + = INT_MIN : The insn cannot throw or execute a nonlocal-goto. + missing note: The insn is outside any EH region. + + ??? This difference probably ought to be avoided. We could stand + to record nothrow for arbitrary gimple statements, and so avoid + some moderately complex lookups in stmt_could_throw_p. Perhaps + NOTHROW should be mapped on both sides to INT_MIN. Perhaps the + no-nonlocal-goto property should be recorded elsewhere as a bit + 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. */ -/* A subroutine of reachable_next_level. Return true if TYPE, or a - base class of TYPE, is in HANDLED. */ - -static int -check_handled (tree handled, tree type) +void +make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr) { - tree t; - - /* We can check for exact matches without front-end help. */ - if (! lang_eh_type_covers) - { - for (t = handled; t ; t = TREE_CHAIN (t)) - if (TREE_VALUE (t) == type) - return 1; - } + rtx value; + if (ecf_flags & ECF_NOTHROW) + value = const0_rtx; + else if (lp_nr != 0) + value = GEN_INT (lp_nr); else - { - for (t = handled; t ; t = TREE_CHAIN (t)) - if ((*lang_eh_type_covers) (TREE_VALUE (t), type)) - return 1; - } - - return 0; + return; + add_reg_note (insn, REG_EH_REGION, value); } -/* A subroutine of reachable_next_level. If we are collecting a list - of handlers, add one. After landing pad generation, reference - it instead of the handlers themselves. Further, the handlers are - all wired together, so by referencing one, we've got them all. - Before landing pad generation we reference each handler individually. +/* 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. */ - LP_REGION contains the landing pad; REGION is the handler. */ - -static void -add_reachable_handler (struct reachable_info *info, - struct eh_region *lp_region, struct eh_region *region) +void +make_reg_eh_region_note_nothrow_nononlocal (rtx insn) { - if (! info) - return; + rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); + rtx intmin = GEN_INT (INT_MIN); - info->saw_any_handlers = true; - - if (cfun->eh->built_landing_pads) - info->callback (lp_region, info->callback_data); + if (note != 0) + XEXP (note, 0) = intmin; else - info->callback (region, info->callback_data); + add_reg_note (insn, REG_EH_REGION, intmin); } -/* Process one level of exception regions for reachability. - If TYPE_THROWN is non-null, then it is the *exact* type being - propagated. If INFO is non-null, then collect handler labels - and caught/allowed type information between invocations. */ +/* Return true if INSN could throw, assuming no REG_EH_REGION note + to the contrary. */ -static enum reachable_code -reachable_next_level (struct eh_region *region, tree type_thrown, - struct reachable_info *info) +bool +insn_could_throw_p (const_rtx insn) { - switch (region->type) - { - case ERT_CLEANUP: - /* Before landing-pad generation, we model control flow - directly to the individual handlers. In this way we can - see that catch handler types may shadow one another. */ - add_reachable_handler (info, region, region); - return RNL_MAYBE_CAUGHT; - - case ERT_TRY: - { - struct eh_region *c; - enum reachable_code ret = RNL_NOT_CAUGHT; - - for (c = region->u.try.catch; c ; c = c->u.catch.next_catch) - { - /* A catch-all handler ends the search. */ - if (c->u.catch.type_list == NULL) - { - add_reachable_handler (info, region, c); - return RNL_CAUGHT; - } - - if (type_thrown) - { - /* If we have at least one type match, end the search. */ - tree tp_node = c->u.catch.type_list; - - for (; tp_node; tp_node = TREE_CHAIN (tp_node)) - { - tree type = TREE_VALUE (tp_node); - - if (type == type_thrown - || (lang_eh_type_covers - && (*lang_eh_type_covers) (type, type_thrown))) - { - add_reachable_handler (info, region, c); - return RNL_CAUGHT; - } - } - - /* If we have definitive information of a match failure, - the catch won't trigger. */ - if (lang_eh_type_covers) - return RNL_NOT_CAUGHT; - } - - /* At this point, we either don't know what type is thrown or - don't have front-end assistance to help deciding if it is - covered by one of the types in the list for this region. - - We'd then like to add this region to the list of reachable - handlers since it is indeed potentially reachable based on the - information we have. - - Actually, this handler is for sure not reachable if all the - types it matches have already been caught. That is, it is only - potentially reachable if at least one of the types it catches - has not been previously caught. */ - - if (! info) - ret = RNL_MAYBE_CAUGHT; - else - { - tree tp_node = c->u.catch.type_list; - bool maybe_reachable = false; - - /* Compute the potential reachability of this handler and - update the list of types caught at the same time. */ - for (; tp_node; tp_node = TREE_CHAIN (tp_node)) - { - tree type = TREE_VALUE (tp_node); - - if (! check_handled (info->types_caught, type)) - { - info->types_caught - = tree_cons (NULL, type, info->types_caught); - - maybe_reachable = true; - } - } - - if (maybe_reachable) - { - add_reachable_handler (info, region, c); - - /* ??? If the catch type is a base class of every allowed - type, then we know we can stop the search. */ - ret = RNL_MAYBE_CAUGHT; - } - } - } - - return ret; - } - - case ERT_ALLOWED_EXCEPTIONS: - /* An empty list of types definitely ends the search. */ - if (region->u.allowed.type_list == NULL_TREE) - { - add_reachable_handler (info, region, region); - return RNL_CAUGHT; - } + if (CALL_P (insn)) + return true; + if (INSN_P (insn) && flag_non_call_exceptions) + return may_trap_p (PATTERN (insn)); + return false; +} - /* Collect a list of lists of allowed types for use in detecting - when a catch may be transformed into a catch-all. */ - if (info) - info->types_allowed = tree_cons (NULL_TREE, - region->u.allowed.type_list, - info->types_allowed); - - /* If we have definitive information about the type hierarchy, - then we can tell if the thrown type will pass through the - filter. */ - if (type_thrown && lang_eh_type_covers) - { - if (check_handled (region->u.allowed.type_list, type_thrown)) - return RNL_NOT_CAUGHT; - else - { - add_reachable_handler (info, region, region); - return RNL_CAUGHT; - } - } +/* 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. */ - add_reachable_handler (info, region, region); - return RNL_MAYBE_CAUGHT; +void +copy_reg_eh_region_note_forward (rtx note_or_insn, rtx first, rtx last) +{ + rtx insn, note = note_or_insn; - case ERT_CATCH: - /* Catch regions are handled by their controlling try region. */ - return RNL_NOT_CAUGHT; + if (INSN_P (note_or_insn)) + { + note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX); + if (note == NULL) + return; + } + note = XEXP (note, 0); - case ERT_MUST_NOT_THROW: - /* Here we end our search, since no exceptions may propagate. - If we've touched down at some landing pad previous, then the - explicit function call we generated may be used. Otherwise - the call is made by the runtime. + for (insn = first; insn != last ; insn = NEXT_INSN (insn)) + if (!find_reg_note (insn, REG_EH_REGION, NULL_RTX) + && insn_could_throw_p (insn)) + add_reg_note (insn, REG_EH_REGION, note); +} - Before inlining, do not perform this optimization. We may - inline a subroutine that contains handlers, and that will - change the value of saw_any_handlers. */ +/* Likewise, but iterate backward. */ - if ((info && info->saw_any_handlers) || !cfun->after_inlining) - { - add_reachable_handler (info, region, region); - return RNL_CAUGHT; - } - else - return RNL_BLOCKED; +void +copy_reg_eh_region_note_backward (rtx note_or_insn, rtx last, rtx first) +{ + rtx insn, note = note_or_insn; - case ERT_THROW: - case ERT_UNKNOWN: - /* Shouldn't see these here. */ - gcc_unreachable (); - break; - default: - gcc_unreachable (); + if (INSN_P (note_or_insn)) + { + note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX); + if (note == NULL) + return; } + note = XEXP (note, 0); + + for (insn = last; insn != first; insn = PREV_INSN (insn)) + if (insn_could_throw_p (insn)) + add_reg_note (insn, REG_EH_REGION, note); } -/* Invoke CALLBACK on each region reachable from REGION_NUMBER. */ -void -foreach_reachable_handler (int region_number, bool is_resx, - void (*callback) (struct eh_region *, void *), - void *callback_data) +/* Extract all EH information from INSN. Return true if the insn + was marked NOTHROW. */ + +static bool +get_eh_region_and_lp_from_rtx (const_rtx insn, eh_region *pr, + eh_landing_pad *plp) { - struct reachable_info info; - struct eh_region *region; - tree type_thrown; + eh_landing_pad lp = NULL; + eh_region r = NULL; + bool ret = false; + rtx note; + int lp_nr; - memset (&info, 0, sizeof (info)); - info.callback = callback; - info.callback_data = callback_data; + if (! INSN_P (insn)) + goto egress; - region = VEC_index (eh_region, cfun->eh->region_array, region_number); + if (NONJUMP_INSN_P (insn) + && GET_CODE (PATTERN (insn)) == SEQUENCE) + insn = XVECEXP (PATTERN (insn), 0, 0); - type_thrown = NULL_TREE; - if (is_resx) + note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); + if (!note) { - /* A RESX leaves a region instead of entering it. Thus the - region itself may have been deleted out from under us. */ - if (region == NULL) - return; - region = region->outer; + ret = !insn_could_throw_p (insn); + goto egress; } - else if (region->type == ERT_THROW) + + lp_nr = INTVAL (XEXP (note, 0)); + if (lp_nr == 0 || lp_nr == INT_MIN) { - type_thrown = region->u.throw.type; - region = region->outer; + ret = true; + goto egress; } - while (region) + if (lp_nr < 0) + r = VEC_index (eh_region, cfun->eh->region_array, -lp_nr); + else { - if (reachable_next_level (region, type_thrown, &info) >= RNL_CAUGHT) - break; - /* If we have processed one cleanup, there is no point in - processing any more of them. Each cleanup will have an edge - to the next outer cleanup region, so the flow graph will be - accurate. */ - if (region->type == ERT_CLEANUP) - region = region->u.cleanup.prev_try; - else - region = region->outer; + lp = VEC_index (eh_landing_pad, cfun->eh->lp_array, lp_nr); + r = lp->region; } + + egress: + *plp = lp; + *pr = r; + return ret; } -/* Retrieve a list of labels of exception handlers which can be - reached by a given insn. */ +/* Return the landing pad to which INSN may go, or NULL if it does not + have a reachable landing pad within this function. */ -static void -arh_to_landing_pad (struct eh_region *region, void *data) +eh_landing_pad +get_eh_landing_pad_from_rtx (const_rtx insn) { - rtx *p_handlers = data; - if (! *p_handlers) - *p_handlers = alloc_INSN_LIST (region->landing_pad, NULL_RTX); -} + eh_landing_pad lp; + eh_region r; -static void -arh_to_label (struct eh_region *region, void *data) -{ - rtx *p_handlers = data; - *p_handlers = alloc_INSN_LIST (region->label, *p_handlers); + get_eh_region_and_lp_from_rtx (insn, &r, &lp); + return lp; } -rtx -reachable_handlers (rtx insn) -{ - bool is_resx = false; - rtx handlers = NULL; - int region_number; - - if (JUMP_P (insn) - && GET_CODE (PATTERN (insn)) == RESX) - { - region_number = XINT (PATTERN (insn), 0); - is_resx = true; - } - else - { - rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); - if (!note || INTVAL (XEXP (note, 0)) <= 0) - return NULL; - region_number = INTVAL (XEXP (note, 0)); - } +/* Return the region to which INSN may go, or NULL if it does not + have a reachable region within this function. */ - foreach_reachable_handler (region_number, is_resx, - (cfun->eh->built_landing_pads - ? arh_to_landing_pad - : arh_to_label), - &handlers); +eh_region +get_eh_region_from_rtx (const_rtx insn) +{ + eh_landing_pad lp; + eh_region r; - return handlers; + get_eh_region_and_lp_from_rtx (insn, &r, &lp); + return r; } -/* Determine if the given INSN can throw an exception that is caught - within the function. */ +/* Return true if INSN throws and is caught by something in this function. */ bool -can_throw_internal_1 (int region_number, bool is_resx) +can_throw_internal (const_rtx insn) { - struct eh_region *region; - tree type_thrown; - - region = VEC_index (eh_region, cfun->eh->region_array, region_number); - - type_thrown = NULL_TREE; - if (is_resx) - region = region->outer; - else if (region->type == ERT_THROW) - { - type_thrown = region->u.throw.type; - region = region->outer; - } - - /* If this exception is ignored by each and every containing region, - then control passes straight out. The runtime may handle some - regions, which also do not require processing internally. */ - for (; region; region = region->outer) - { - enum reachable_code how = reachable_next_level (region, type_thrown, 0); - if (how == RNL_BLOCKED) - return false; - if (how != RNL_NOT_CAUGHT) - return true; - } - - return false; + return get_eh_landing_pad_from_rtx (insn) != NULL; } +/* Return true if INSN throws and escapes from the current function. */ + bool -can_throw_internal (rtx insn) +can_throw_external (const_rtx insn) { - rtx note; + eh_landing_pad lp; + eh_region r; + bool nothrow; if (! INSN_P (insn)) return false; - if (JUMP_P (insn) - && GET_CODE (PATTERN (insn)) == RESX - && XINT (PATTERN (insn), 0) > 0) - return can_throw_internal_1 (XINT (PATTERN (insn), 0), true); - if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE) - insn = XVECEXP (PATTERN (insn), 0, 0); - - /* Every insn that might throw has an EH_REGION note. */ - note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); - if (!note || INTVAL (XEXP (note, 0)) <= 0) - return false; + { + rtx seq = PATTERN (insn); + int i, n = XVECLEN (seq, 0); - return can_throw_internal_1 (INTVAL (XEXP (note, 0)), false); -} + for (i = 0; i < n; i++) + if (can_throw_external (XVECEXP (seq, 0, i))) + return true; -/* Determine if the given INSN can throw an exception that is - visible outside the function. */ + return false; + } -bool -can_throw_external_1 (int region_number, bool is_resx) -{ - struct eh_region *region; - tree type_thrown; + nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp); - region = VEC_index (eh_region, cfun->eh->region_array, region_number); + /* If we can't throw, we obviously can't throw external. */ + if (nothrow) + return false; - type_thrown = NULL_TREE; - if (is_resx) - region = region->outer; - else if (region->type == ERT_THROW) - { - type_thrown = region->u.throw.type; - region = region->outer; - } + /* If we have an internal landing pad, then we're not external. */ + if (lp != NULL) + return false; - /* If the exception is caught or blocked by any containing region, - then it is not seen by any calling function. */ - for (; region ; region = region->outer) - if (reachable_next_level (region, type_thrown, NULL) >= RNL_CAUGHT) - return false; + /* If we're not within an EH region, then we are external. */ + if (r == NULL) + return true; - return true; + /* The only thing that ought to be left is MUST_NOT_THROW regions, + which don't always have landing pads. */ + gcc_assert (r->type == ERT_MUST_NOT_THROW); + return false; } +/* Return true if INSN cannot throw at all. */ + bool -can_throw_external (rtx insn) +insn_nothrow_p (const_rtx insn) { - rtx note; + eh_landing_pad lp; + eh_region r; if (! INSN_P (insn)) - return false; - - if (JUMP_P (insn) - && GET_CODE (PATTERN (insn)) == RESX - && XINT (PATTERN (insn), 0) > 0) - return can_throw_external_1 (XINT (PATTERN (insn), 0), true); + return true; if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE) - insn = XVECEXP (PATTERN (insn), 0, 0); - - note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); - if (!note) { - /* Calls (and trapping insns) without notes are outside any - exception handling region in this function. We have to - assume it might throw. Given that the front end and middle - ends mark known NOTHROW functions, this isn't so wildly - inaccurate. */ - return (CALL_P (insn) - || (flag_non_call_exceptions - && may_trap_p (PATTERN (insn)))); + rtx seq = PATTERN (insn); + int i, n = XVECLEN (seq, 0); + + for (i = 0; i < n; i++) + if (!insn_nothrow_p (XVECEXP (seq, 0, i))) + return false; + + return true; } - if (INTVAL (XEXP (note, 0)) <= 0) - return false; - return can_throw_external_1 (INTVAL (XEXP (note, 0)), false); + return get_eh_region_and_lp_from_rtx (insn, &r, &lp); } -/* Set TREE_NOTHROW and cfun->all_throwers_are_sibcalls. */ +/* 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) +{ + 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) + return true; + } + return false; +} + +/* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */ -unsigned int +static unsigned int set_nothrow_function_flags (void) { rtx insn; - /* If we don't know that this implementation of the function will - actually be used, then we must not set TREE_NOTHROW, since - callers must not assume that this function does not throw. */ - if (DECL_REPLACEABLE_P (current_function_decl)) - return 0; + crtl->nothrow = 1; - TREE_NOTHROW (current_function_decl) = 1; - - /* Assume cfun->all_throwers_are_sibcalls until we encounter + /* Assume crtl->all_throwers_are_sibcalls until we encounter something that can throw an exception. We specifically exempt CALL_INSNs that are SIBLING_CALL_P, as these are really jumps, and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this is optimistic. */ - cfun->all_throwers_are_sibcalls = 1; + crtl->all_throwers_are_sibcalls = 1; + + /* If we don't know that this implementation of the function will + actually be used, then we must not set TREE_NOTHROW, since + callers must not assume that this function does not throw. */ + if (TREE_NOTHROW (current_function_decl)) + return 0; if (! flag_exceptions) return 0; @@ -2815,50 +1865,140 @@ set_nothrow_function_flags (void) for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) if (can_throw_external (insn)) { - TREE_NOTHROW (current_function_decl) = 0; + crtl->nothrow = 0; if (!CALL_P (insn) || !SIBLING_CALL_P (insn)) { - cfun->all_throwers_are_sibcalls = 0; + crtl->all_throwers_are_sibcalls = 0; return 0; } } - for (insn = current_function_epilogue_delay_list; insn; + for (insn = crtl->epilogue_delay_list; insn; insn = XEXP (insn, 1)) if (can_throw_external (insn)) { - TREE_NOTHROW (current_function_decl) = 0; + crtl->nothrow = 0; if (!CALL_P (insn) || !SIBLING_CALL_P (insn)) { - cfun->all_throwers_are_sibcalls = 0; + crtl->all_throwers_are_sibcalls = 0; return 0; } } + if (crtl->nothrow + && (cgraph_function_body_availability (cgraph_node + (current_function_decl)) + >= AVAIL_AVAILABLE)) + { + struct cgraph_node *node = cgraph_node (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); + + if (dump_file) + fprintf (dump_file, "Marking function nothrow: %s\n\n", + current_function_name ()); + } return 0; } -struct tree_opt_pass pass_set_nothrow_function_flags = +struct rtl_opt_pass pass_set_nothrow_function_flags = { - NULL, /* name */ + { + RTL_PASS, + "nothrow", /* name */ NULL, /* gate */ set_nothrow_function_flags, /* execute */ NULL, /* sub */ NULL, /* next */ 0, /* static_pass_number */ - 0, /* tv_id */ + TV_NONE, /* tv_id */ 0, /* properties_required */ 0, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ - 0, /* todo_flags_finish */ - 0 /* letter */ + TODO_dump_func, /* todo_flags_finish */ + } }; /* Various hooks for unwind library. */ +/* Expand the EH support builtin functions: + __builtin_eh_pointer and __builtin_eh_filter. */ + +static eh_region +expand_builtin_eh_common (tree region_nr_t) +{ + HOST_WIDE_INT region_nr; + eh_region region; + + gcc_assert (host_integerp (region_nr_t, 0)); + region_nr = tree_low_cst (region_nr_t, 0); + + region = VEC_index (eh_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); + + return region; +} + +/* Expand to the exc_ptr value from the given eh region. */ + +rtx +expand_builtin_eh_pointer (tree exp) +{ + eh_region region + = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0)); + if (region->exc_ptr_reg == NULL) + region->exc_ptr_reg = gen_reg_rtx (ptr_mode); + return region->exc_ptr_reg; +} + +/* Expand to the filter value from the given eh region. */ + +rtx +expand_builtin_eh_filter (tree exp) +{ + eh_region region + = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0)); + if (region->filter_reg == NULL) + region->filter_reg = gen_reg_rtx (targetm.eh_return_filter_mode ()); + return region->filter_reg; +} + +/* Copy the exc_ptr and filter values from one landing pad's registers + to another. This is used to inline the resx statement. */ + +rtx +expand_builtin_eh_copy_values (tree exp) +{ + 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 (); + + 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); + + if (dst->filter_reg == NULL) + dst->filter_reg = gen_reg_rtx (fmode); + if (src->filter_reg == NULL) + src->filter_reg = gen_reg_rtx (fmode); + + emit_move_insn (dst->exc_ptr_reg, src->exc_ptr_reg); + emit_move_insn (dst->filter_reg, src->filter_reg); + + return const0_rtx; +} + /* Do any necessary initialization to access arbitrary stack frames. On the SPARC, this means flushing the register windows. */ @@ -2867,13 +2007,17 @@ expand_builtin_unwind_init (void) { /* Set this so all the registers get saved in our frame; we need to be able to copy the saved values for any registers from frames we unwind. */ - current_function_calls_unwind_init = 1; + 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. */ + rtx expand_builtin_eh_return_data_regno (tree exp) { @@ -2960,37 +2104,41 @@ expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED, rtx tmp; #ifdef EH_RETURN_STACKADJ_RTX - tmp = expand_expr (stackadj_tree, cfun->eh->ehr_stackadj, + tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj, VOIDmode, EXPAND_NORMAL); tmp = convert_memory_address (Pmode, tmp); - if (!cfun->eh->ehr_stackadj) - cfun->eh->ehr_stackadj = copy_to_reg (tmp); - else if (tmp != cfun->eh->ehr_stackadj) - emit_move_insn (cfun->eh->ehr_stackadj, tmp); + if (!crtl->eh.ehr_stackadj) + crtl->eh.ehr_stackadj = copy_to_reg (tmp); + else if (tmp != crtl->eh.ehr_stackadj) + emit_move_insn (crtl->eh.ehr_stackadj, tmp); #endif - tmp = expand_expr (handler_tree, cfun->eh->ehr_handler, + tmp = expand_expr (handler_tree, crtl->eh.ehr_handler, VOIDmode, EXPAND_NORMAL); tmp = convert_memory_address (Pmode, tmp); - if (!cfun->eh->ehr_handler) - cfun->eh->ehr_handler = copy_to_reg (tmp); - else if (tmp != cfun->eh->ehr_handler) - emit_move_insn (cfun->eh->ehr_handler, tmp); + if (!crtl->eh.ehr_handler) + crtl->eh.ehr_handler = copy_to_reg (tmp); + else if (tmp != crtl->eh.ehr_handler) + emit_move_insn (crtl->eh.ehr_handler, tmp); - if (!cfun->eh->ehr_label) - cfun->eh->ehr_label = gen_label_rtx (); - emit_jump (cfun->eh->ehr_label); + if (!crtl->eh.ehr_label) + crtl->eh.ehr_label = gen_label_rtx (); + emit_jump (crtl->eh.ehr_label); } +/* Expand __builtin_eh_return. This exit path from the function loads up + the eh return data registers, adjusts the stack, and branches to a + given PC other than the normal return address. */ + void expand_eh_return (void) { rtx around_label; - if (! cfun->eh->ehr_label) + if (! crtl->eh.ehr_label) return; - current_function_calls_eh_return = 1; + crtl->calls_eh_return = 1; #ifdef EH_RETURN_STACKADJ_RTX emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx); @@ -2999,21 +2147,21 @@ expand_eh_return (void) around_label = gen_label_rtx (); emit_jump (around_label); - emit_label (cfun->eh->ehr_label); + emit_label (crtl->eh.ehr_label); clobber_return_register (); #ifdef EH_RETURN_STACKADJ_RTX - emit_move_insn (EH_RETURN_STACKADJ_RTX, cfun->eh->ehr_stackadj); + emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj); #endif #ifdef HAVE_eh_return if (HAVE_eh_return) - emit_insn (gen_eh_return (cfun->eh->ehr_handler)); + emit_insn (gen_eh_return (crtl->eh.ehr_handler)); else #endif { #ifdef EH_RETURN_HANDLER_RTX - emit_move_insn (EH_RETURN_HANDLER_RTX, cfun->eh->ehr_handler); + emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler); #else error ("__builtin_eh_return not supported on this target"); #endif @@ -3039,7 +2187,7 @@ expand_builtin_extend_pointer (tree addr_tree) extend = 1; #endif - return convert_modes (word_mode, ptr_mode, addr, extend); + return convert_modes (targetm.unwind_word_mode (), ptr_mode, addr, extend); } /* In the following functions, we represent entries in the action table @@ -3078,38 +2226,37 @@ 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_ar, tmp; tmp.filter = filter; tmp.next = next; slot = (struct action_record **) htab_find_slot (ar_hash, &tmp, INSERT); - if ((new = *slot) == NULL) + if ((new_ar = *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_ar = XNEW (struct action_record); + new_ar->offset = VEC_length (uchar, crtl->eh.action_record_data) + 1; + new_ar->filter = filter; + new_ar->next = next; + *slot = new_ar; /* The filter value goes in untouched. The link to the next record is a "self-relative" byte offset, or zero to indicate that there is no next record. So convert the absolute 1 based indices we've been carrying around into a displacement. */ - push_sleb128 (&cfun->eh->action_record_data, filter); + push_sleb128 (&crtl->eh.action_record_data, filter); if (next) - next -= VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1; - push_sleb128 (&cfun->eh->action_record_data, next); + next -= VEC_length (uchar, crtl->eh.action_record_data) + 1; + push_sleb128 (&crtl->eh.action_record_data, next); } - return new->offset; + return new_ar->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; int next; /* If we've reached the top of the region chain, then we have @@ -3120,67 +2267,72 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region) switch (region->type) { case ERT_CLEANUP: - /* A cleanup adds a zero filter to the beginning of the chain, but - there are special cases to look out for. If there are *only* - cleanups along a path, then it compresses to a zero action. - Further, if there are multiple cleanups along a path, we only - need to represent one of them, as that is enough to trigger - entry to the landing pad at runtime. */ - next = collect_one_action_chain (ar_hash, region->outer); - if (next <= 0) - return 0; - for (c = region->outer; c ; c = c->outer) - if (c->type == ERT_CLEANUP) - return next; - return add_action_record (ar_hash, 0, next); + { + eh_region r; + /* A cleanup adds a zero filter to the beginning of the chain, but + there are special cases to look out for. If there are *only* + cleanups along a path, then it compresses to a zero action. + Further, if there are multiple cleanups along a path, we only + need to represent one of them, as that is enough to trigger + entry to the landing pad at runtime. */ + next = collect_one_action_chain (ar_hash, region->outer); + if (next <= 0) + return 0; + for (r = region->outer; r ; r = r->outer) + if (r->type == ERT_CLEANUP) + return next; + return add_action_record (ar_hash, 0, next); + } case ERT_TRY: - /* Process the associated catch regions in reverse order. - If there's a catch-all handler, then we don't need to - 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) - { - if (c->u.catch.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)); - - next = add_action_record (ar_hash, filter, 0); - } - else - { - /* Once the outer search is done, trigger an action record for - each filter we have. */ - tree flt_node; + { + eh_catch c; + + /* Process the associated catch regions in reverse order. + If there's a catch-all handler, then we don't need to + search outer regions. Use a magic -3 value to record + that we haven't done the outer search. */ + next = -3; + for (c = region->u.eh_try.last_catch; c ; c = c->prev_catch) + { + if (c->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->filter_list)); + next = add_action_record (ar_hash, filter, 0); + } + else + { + /* Once the outer search is done, trigger an action record for + each filter we have. */ + tree flt_node; - if (next == -3) - { - next = collect_one_action_chain (ar_hash, region->outer); - - /* If there is no next action, terminate the chain. */ - if (next == -1) - next = 0; - /* If all outer actions are cleanups or must_not_throw, - we'll have no action record for it, since we had wanted - to encode these states in the call-site record directly. - Add a cleanup action to the chain to catch these. */ - else if (next <= 0) - next = add_action_record (ar_hash, 0, 0); - } + if (next == -3) + { + next = collect_one_action_chain (ar_hash, region->outer); + + /* If there is no next action, terminate the chain. */ + if (next == -1) + next = 0; + /* If all outer actions are cleanups or must_not_throw, + we'll have no action record for it, since we had wanted + to encode these states in the call-site record directly. + Add a cleanup action to the chain to catch these. */ + else if (next <= 0) + next = add_action_record (ar_hash, 0, 0); + } - flt_node = c->u.catch.filter_list; - for (; flt_node; flt_node = TREE_CHAIN (flt_node)) - { - int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node)); - next = add_action_record (ar_hash, filter, next); - } - } - } - return next; + flt_node = c->filter_list; + for (; flt_node; flt_node = TREE_CHAIN (flt_node)) + { + int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node)); + next = add_action_record (ar_hash, filter, next); + } + } + } + return next; + } case ERT_ALLOWED_EXCEPTIONS: /* An exception specification adds its filter to the @@ -3205,46 +2357,32 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region) the no handler or cleanup case in that we do require an lsda to be generated. Return a magic -2 value to record this. */ return -2; - - case ERT_CATCH: - case ERT_THROW: - /* CATCH regions are handled in TRY above. THROW regions are - for optimization information only and produce no output. */ - return collect_one_action_chain (ar_hash, region->outer); - - default: - gcc_unreachable (); } + + gcc_unreachable (); } static int -add_call_site (rtx landing_pad, int action) +add_call_site (rtx landing_pad, int action, int section) { - struct call_site_record *data = cfun->eh->call_site_data; - int used = cfun->eh->call_site_data_used; - int size = cfun->eh->call_site_data_size; + call_site_record record; - if (used >= size) - { - size = (size ? size * 2 : 64); - data = ggc_realloc (data, sizeof (*data) * size); - cfun->eh->call_site_data = data; - cfun->eh->call_site_data_size = size; - } + record = GGC_NEW (struct call_site_record_d); + record->landing_pad = landing_pad; + record->action = action; - data[used].landing_pad = landing_pad; - data[used].action = action; + VEC_safe_push (call_site_record, gc, + crtl->eh.call_site_record[section], record); - cfun->eh->call_site_data_used = used + 1; - - return used + call_site_base; + return call_site_base + VEC_length (call_site_record, + crtl->eh.call_site_record[section]) - 1; } /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes. The new note numbers will not refer to region numbers, but instead to call site entries. */ -unsigned int +static unsigned int convert_to_eh_region_ranges (void) { rtx insn, iter, note; @@ -3254,18 +2392,25 @@ convert_to_eh_region_ranges (void) rtx last_landing_pad = NULL_RTX; rtx first_no_action_insn = NULL_RTX; int call_site = 0; + int cur_sec = 0; + rtx section_switch_note = NULL_RTX; + rtx first_no_action_insn_before_switch = NULL_RTX; + rtx last_no_action_insn_before_switch = NULL_RTX; + rtx *pad_map = NULL; + sbitmap pad_loc = NULL; + int min_labelno = 0, max_labelno = 0; + int saved_call_site_base = call_site_base; - if (USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL) - return 0; - - VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data"); + crtl->eh.action_record_data = VEC_alloc (uchar, gc, 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)) { - struct eh_region *region; + eh_landing_pad lp; + eh_region region; + bool nothrow; int this_action; rtx this_landing_pad; @@ -3274,28 +2419,18 @@ convert_to_eh_region_ranges (void) && GET_CODE (PATTERN (insn)) == SEQUENCE) insn = XVECEXP (PATTERN (insn), 0, 0); - note = find_reg_note (insn, REG_EH_REGION, NULL_RTX); - if (!note) - { - if (! (CALL_P (insn) - || (flag_non_call_exceptions - && may_trap_p (PATTERN (insn))))) - continue; - this_action = -1; - region = NULL; - } + nothrow = get_eh_region_and_lp_from_rtx (insn, ®ion, &lp); + if (nothrow) + continue; + if (region) + this_action = collect_one_action_chain (ar_hash, region); else - { - if (INTVAL (XEXP (note, 0)) <= 0) - continue; - region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0))); - this_action = collect_one_action_chain (ar_hash, region); - } + this_action = -1; /* Existence of catch handlers, or must-not-throw regions implies that an lsda is needed (even if empty). */ if (this_action != -1) - cfun->uses_eh_lsda = 1; + crtl->uses_eh_lsda = 1; /* Delay creation of region notes for no-action regions until we're sure that an lsda will be required. */ @@ -3305,15 +2440,8 @@ convert_to_eh_region_ranges (void) last_action = -1; } - /* Cleanups and handlers may share action chains but not - landing pads. Collect the landing pad for this region. */ if (this_action >= 0) - { - struct eh_region *o; - for (o = region; ! o->landing_pad ; o = o->outer) - continue; - this_landing_pad = o->landing_pad; - } + this_landing_pad = lp->landing_pad; else this_landing_pad = NULL_RTX; @@ -3328,9 +2456,27 @@ convert_to_eh_region_ranges (void) if (last_action >= -1) { /* If we delayed the creation of the begin, do it now. */ + if (first_no_action_insn_before_switch) + { + 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; + if (first_no_action_insn) + { + note + = emit_note_after (NOTE_INSN_EH_REGION_END, + last_no_action_insn_before_switch); + NOTE_EH_HANDLER (note) = call_site; + } + else + gcc_assert (last_action_insn + == last_no_action_insn_before_switch); + } if (first_no_action_insn) { - call_site = add_call_site (NULL_RTX, 0); + 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; @@ -3347,7 +2493,8 @@ convert_to_eh_region_ranges (void) if (this_action >= -1) { call_site = add_call_site (this_landing_pad, - this_action < 0 ? 0 : this_action); + this_action < 0 ? 0 : this_action, + cur_sec); note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter); NOTE_EH_HANDLER (note) = call_site; } @@ -3357,6 +2504,37 @@ convert_to_eh_region_ranges (void) } last_action_insn = iter; } + else if (NOTE_P (iter) + && NOTE_KIND (iter) == NOTE_INSN_SWITCH_TEXT_SECTIONS) + { + gcc_assert (section_switch_note == NULL_RTX); + gcc_assert (flag_reorder_blocks_and_partition); + 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; + 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, + crtl->eh.call_site_record[cur_sec]); + cur_sec++; + gcc_assert (crtl->eh.call_site_record[cur_sec] == NULL); + crtl->eh.call_site_record[cur_sec] + = 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) { @@ -3364,30 +2542,137 @@ convert_to_eh_region_ranges (void) 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; } -struct tree_opt_pass pass_convert_to_eh_region_ranges = +static bool +gate_convert_to_eh_region_ranges (void) { - "eh-ranges", /* name */ - NULL, /* gate */ + /* Nothing to do for SJLJ exceptions or if no regions created. */ + return !(USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL); +} + +struct rtl_opt_pass pass_convert_to_eh_region_ranges = +{ + { + RTL_PASS, + "eh_ranges", /* name */ + gate_convert_to_eh_region_ranges, /* gate */ convert_to_eh_region_ranges, /* execute */ NULL, /* sub */ NULL, /* next */ 0, /* static_pass_number */ - 0, /* tv_id */ + TV_NONE, /* tv_id */ 0, /* properties_required */ 0, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ TODO_dump_func, /* todo_flags_finish */ - 0 /* letter */ + } }; - static void -push_uleb128 (varray_type *data_area, unsigned int value) +push_uleb128 (VEC (uchar, gc) **data_area, unsigned int value) { do { @@ -3395,13 +2680,13 @@ push_uleb128 (varray_type *data_area, unsigned int value) value >>= 7; if (value) byte |= 0x80; - VARRAY_PUSH_UCHAR (*data_area, byte); + VEC_safe_push (uchar, gc, *data_area, byte); } while (value); } static void -push_sleb128 (varray_type *data_area, int value) +push_sleb128 (VEC (uchar, gc) **data_area, int value) { unsigned char byte; int more; @@ -3414,7 +2699,7 @@ push_sleb128 (varray_type *data_area, int value) || (value == -1 && (byte & 0x40) != 0)); if (more) byte |= 0x80; - VARRAY_PUSH_UCHAR (*data_area, byte); + VEC_safe_push (uchar, gc, *data_area, byte); } while (more); } @@ -3422,15 +2707,16 @@ push_sleb128 (varray_type *data_area, int value) #ifndef HAVE_AS_LEB128 static int -dw2_size_of_call_site_table (void) +dw2_size_of_call_site_table (int section) { - int n = cfun->eh->call_site_data_used; + int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]); int size = n * (4 + 4 + 4); int i; for (i = 0; i < n; ++i) { - struct call_site_record *cs = &cfun->eh->call_site_data[i]; + struct call_site_record_d *cs = + VEC_index (call_site_record, crtl->eh.call_site_record[section], i); size += size_of_uleb128 (cs->action); } @@ -3440,13 +2726,14 @@ dw2_size_of_call_site_table (void) static int sjlj_size_of_call_site_table (void) { - int n = cfun->eh->call_site_data_used; + int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]); int size = 0; int i; for (i = 0; i < n; ++i) { - struct call_site_record *cs = &cfun->eh->call_site_data[i]; + struct call_site_record_d *cs = + VEC_index (call_site_record, crtl->eh.call_site_record[0], i); size += size_of_uleb128 (INTVAL (cs->landing_pad)); size += size_of_uleb128 (cs->action); } @@ -3456,14 +2743,23 @@ sjlj_size_of_call_site_table (void) #endif static void -dw2_output_call_site_table (void) +dw2_output_call_site_table (int cs_format, int section) { - int n = cfun->eh->call_site_data_used; + int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]); int i; + const char *begin; + + if (section == 0) + begin = current_function_func_begin_label; + else if (first_function_block_is_cold) + begin = crtl->subsections.hot_section_label; + else + begin = crtl->subsections.cold_section_label; for (i = 0; i < n; ++i) { - struct call_site_record *cs = &cfun->eh->call_site_data[i]; + struct call_site_record_d *cs = + 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]; @@ -3479,30 +2775,29 @@ dw2_output_call_site_table (void) generic arithmetic. */ /* ??? Perhaps use attr_length to choose data1 or data2 instead of data4 if the function is small enough. */ -#ifdef HAVE_AS_LEB128 - dw2_asm_output_delta_uleb128 (reg_start_lab, - current_function_func_begin_label, - "region %d start", i); - dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab, - "length"); - if (cs->landing_pad) - dw2_asm_output_delta_uleb128 (landing_pad_lab, - current_function_func_begin_label, - "landing pad"); - else - dw2_asm_output_data_uleb128 (0, "landing pad"); -#else - dw2_asm_output_delta (4, reg_start_lab, - current_function_func_begin_label, - "region %d start", i); - dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length"); - if (cs->landing_pad) - dw2_asm_output_delta (4, landing_pad_lab, - current_function_func_begin_label, - "landing pad"); + if (cs_format == DW_EH_PE_uleb128) + { + dw2_asm_output_delta_uleb128 (reg_start_lab, begin, + "region %d start", i); + dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab, + "length"); + if (cs->landing_pad) + dw2_asm_output_delta_uleb128 (landing_pad_lab, begin, + "landing pad"); + else + dw2_asm_output_data_uleb128 (0, "landing pad"); + } else - dw2_asm_output_data (4, 0, "landing pad"); -#endif + { + dw2_asm_output_delta (4, reg_start_lab, begin, + "region %d start", i); + dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length"); + if (cs->landing_pad) + dw2_asm_output_delta (4, landing_pad_lab, begin, + "landing pad"); + else + dw2_asm_output_data (4, 0, "landing pad"); + } dw2_asm_output_data_uleb128 (cs->action, "action"); } @@ -3512,12 +2807,13 @@ dw2_output_call_site_table (void) static void sjlj_output_call_site_table (void) { - int n = cfun->eh->call_site_data_used; + int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]); int i; for (i = 0; i < n; ++i) { - struct call_site_record *cs = &cfun->eh->call_site_data[i]; + struct call_site_record_d *cs = + 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); @@ -3560,7 +2856,7 @@ switch_to_exception_section (const char * ARG_UNUSED (fnname)) #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); @@ -3588,7 +2884,7 @@ static void output_ttype (tree type, int tt_format, int tt_format_size) { rtx value; - bool public = true; + bool is_public = true; if (type == NULL_TREE) value = const0_rtx; @@ -3596,7 +2892,14 @@ output_ttype (tree type, int tt_format, int tt_format_size) { struct varpool_node *node; - type = lookup_type_for_runtime (type); + /* 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. */ + if (TYPE_P (type)) + type = lookup_type_for_runtime (type); + value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); /* Let cgraph know that the rtti decl is used. Not all of the @@ -3611,7 +2914,7 @@ output_ttype (tree type, int tt_format, int tt_format_size) node = varpool_node (type); if (node) varpool_mark_needed_node (node); - public = TREE_PUBLIC (type); + is_public = TREE_PUBLIC (type); } } else @@ -3626,13 +2929,14 @@ output_ttype (tree type, int tt_format, int tt_format_size) 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, is_public, NULL); } -void -output_function_exception_table (const char * ARG_UNUSED (fnname)) +static void +output_one_function_exception_table (const char * ARG_UNUSED (fnname), + int section, rtx ARG_UNUSED (personality)) { - int tt_format, cs_format, lp_format, i, n; + int tt_format, cs_format, lp_format, i; #ifdef HAVE_AS_LEB128 char ttype_label[32]; char cs_after_size_label[32]; @@ -3643,17 +2947,10 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) int have_tt_data; int tt_format_size = 0; - /* Not all functions need anything. */ - if (! cfun->uses_eh_lsda) - return; - - if (eh_personality_libfunc) - assemble_external_libcall (eh_personality_libfunc); - #ifdef TARGET_UNWIND_INFO /* TODO: Move this into target file. */ fputs ("\t.personality\t", asm_out_file); - output_addr_const (asm_out_file, eh_personality_libfunc); + output_addr_const (asm_out_file, personality); fputs ("\n\t.handlerdata\n", asm_out_file); /* Note that varasm still thinks we're in the function's code section. The ".endp" directive that will immediately follow will take us back. */ @@ -3664,8 +2961,10 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) /* If the target wants a label to begin the table, emit it here. */ targetm.asm_out.except_table_label (asm_out_file); - have_tt_data = (VEC_length (tree, cfun->eh->ttype_data) > 0 - || VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) > 0); + have_tt_data = (VEC_length (tree, cfun->eh->ttype_data) + || (targetm.arm_eabi_unwinder + ? VEC_length (tree, cfun->eh->ehspec_data.arm_eabi) + : VEC_length (uchar, cfun->eh->ehspec_data.other))); /* Indicate the format of the @TType entries. */ if (! have_tt_data) @@ -3674,7 +2973,8 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) { tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1); #ifdef HAVE_AS_LEB128 - ASM_GENERATE_INTERNAL_LABEL (ttype_label, "LLSDATT", + ASM_GENERATE_INTERNAL_LABEL (ttype_label, + section ? "LLSDATTC" : "LLSDATT", current_function_funcdef_no); #endif tt_format_size = size_of_encoded_value (tt_format); @@ -3682,8 +2982,8 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) assemble_align (tt_format_size * BITS_PER_UNIT); } - targetm.asm_out.internal_label (asm_out_file, "LLSDA", - current_function_funcdef_no); + targetm.asm_out.internal_label (asm_out_file, section ? "LLSDAC" : "LLSDA", + current_function_funcdef_no); /* The LSDA header. */ @@ -3706,7 +3006,7 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) if (USING_SJLJ_EXCEPTIONS) call_site_len = sjlj_size_of_call_site_table (); else - call_site_len = dw2_size_of_call_site_table (); + call_site_len = dw2_size_of_call_site_table (section); #endif /* A pc-relative 4-byte displacement to the @TType data. */ @@ -3714,7 +3014,8 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) { #ifdef HAVE_AS_LEB128 char ttype_after_disp_label[32]; - ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label, "LLSDATTD", + 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"); @@ -3726,7 +3027,7 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) before_disp = 1 + 1; after_disp = (1 + size_of_uleb128 (call_site_len) + call_site_len - + VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + + VEC_length (uchar, crtl->eh.action_record_data) + (VEC_length (tree, cfun->eh->ttype_data) * tt_format_size)); @@ -3760,9 +3061,11 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) eh_data_format_name (cs_format)); #ifdef HAVE_AS_LEB128 - ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label, "LLSDACSB", + ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label, + section ? "LLSDACSBC" : "LLSDACSB", current_function_funcdef_no); - ASM_GENERATE_INTERNAL_LABEL (cs_end_label, "LLSDACSE", + ASM_GENERATE_INTERNAL_LABEL (cs_end_label, + section ? "LLSDACSEC" : "LLSDACSE", current_function_funcdef_no); dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label, "Call-site table length"); @@ -3770,21 +3073,22 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) if (USING_SJLJ_EXCEPTIONS) sjlj_output_call_site_table (); else - dw2_output_call_site_table (); + dw2_output_call_site_table (cs_format, section); ASM_OUTPUT_LABEL (asm_out_file, cs_end_label); #else - dw2_asm_output_data_uleb128 (call_site_len,"Call-site table length"); + dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length"); if (USING_SJLJ_EXCEPTIONS) sjlj_output_call_site_table (); else - dw2_output_call_site_table (); + dw2_output_call_site_table (cs_format, section); #endif /* ??? Decode and interpret the data for flag_debug_asm. */ - n = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data); - for (i = 0; i < n; ++i) - dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->action_record_data, i), - (i ? NULL : "Action record table")); + { + uchar uc; + for (i = 0; VEC_iterate (uchar, crtl->eh.action_record_data, i, uc); ++i) + dw2_asm_output_data (1, uc, i ? NULL : "Action record table"); + } if (have_tt_data) assemble_align (tt_format_size * BITS_PER_UNIT); @@ -3802,18 +3106,38 @@ output_function_exception_table (const char * ARG_UNUSED (fnname)) #endif /* ??? Decode and interpret the data for flag_debug_asm. */ - n = VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data); - for (i = 0; i < n; ++i) + if (targetm.arm_eabi_unwinder) { - if (targetm.arm_eabi_unwinder) - { - tree type = VARRAY_TREE (cfun->eh->ehspec_data, i); - output_ttype (type, tt_format, tt_format_size); - } - else - dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->ehspec_data, i), - (i ? NULL : "Exception specification table")); + tree type; + for (i = 0; + VEC_iterate (tree, 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) + dw2_asm_output_data (1, uc, + i ? NULL : "Exception specification table"); } +} + +void +output_function_exception_table (const char * ARG_UNUSED (fnname)) +{ + rtx personality = get_personality_function (current_function_decl); + + /* Not all functions need anything. */ + if (! crtl->uses_eh_lsda) + return; + + if (personality) + assemble_external_libcall (personality); + + output_one_function_exception_table (fnname, 0, personality); + if (crtl->eh.call_site_record[1] != NULL) + output_one_function_exception_table (fnname, 1, personality); switch_to_section (current_function_section ()); } @@ -3829,32 +3153,135 @@ get_eh_throw_stmt_table (struct function *fun) { return fun->eh->throw_stmt_table; } + +/* Determine if the function needs an EH personality function. */ + +enum eh_personality_kind +function_needs_eh_personality (struct function *fn) +{ + enum eh_personality_kind kind = eh_personality_none; + eh_region i; + + FOR_ALL_EH_REGION_FN (i, fn) + { + switch (i->type) + { + case ERT_CLEANUP: + /* Can do with any personality including the generic C one. */ + kind = eh_personality_any; + break; + + case ERT_TRY: + case ERT_ALLOWED_EXCEPTIONS: + /* Always needs a EH personality function. The generic C + personality doesn't handle these even for empty type lists. */ + return eh_personality_lang; + + case ERT_MUST_NOT_THROW: + /* Always needs a EH personality function. The language may specify + what abort routine that must be used, e.g. std::terminate. */ + return eh_personality_lang; + } + } + return kind; +} + /* Dump EH information to OUT. */ + void -dump_eh_tree (FILE *out, struct function *fun) +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", - "throw"}; + static const char *const type_name[] = { + "cleanup", "try", "allowed_exceptions", "must_not_throw" + }; i = fun->eh->region_tree; - if (! i) + if (!i) return; fprintf (out, "Eh tree:\n"); while (1) { fprintf (out, " %*s %i %s", depth * 2, "", - i->region_number, type_name [(int)i->type]); - if (i->tree_label) + i->index, type_name[(int) i->type]); + + if (i->landing_pads) + { + eh_landing_pad lp; + + fprintf (out, " land:"); + 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); + fputc ('}', out); + if (lp->next_lp) + fputc (',', out); + } + } + else + { + for (lp = i->landing_pads; lp ; lp = lp->next_lp); + { + fprintf (out, "{%i,", lp->index); + if (lp->landing_pad) + fprintf (out, "%i%s,", INSN_UID (lp->landing_pad), + NOTE_P (lp->landing_pad) ? "(del)" : ""); + else + fprintf (out, "(nil),"); + if (lp->post_landing_pad) + { + rtx lab = label_rtx (lp->post_landing_pad); + fprintf (out, "%i%s}", INSN_UID (lab), + NOTE_P (lab) ? "(del)" : ""); + } + else + fprintf (out, "(nil)}"); + if (lp->next_lp) + fputc (',', out); + } + } + } + + switch (i->type) { - fprintf (out, " tree_label:"); - print_generic_expr (out, i->tree_label, 0); + case ERT_CLEANUP: + case ERT_MUST_NOT_THROW: + break; + + case ERT_TRY: + { + eh_catch c; + fprintf (out, " catch:"); + for (c = i->u.eh_try.first_catch; c; c = c->next_catch) + { + fputc ('{', out); + if (c->label) + { + fprintf (out, "lab:"); + print_generic_expr (out, c->label, 0); + fputc (';', out); + } + print_generic_expr (out, c->type_list, 0); + 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); + break; } - fprintf (out, "\n"); + fputc ('\n', out); + /* If there are sub-regions, process them. */ if (i->inner) i = i->inner, depth++; @@ -3864,148 +3291,144 @@ dump_eh_tree (FILE *out, struct function *fun) /* Otherwise, step back up the tree to the next peer. */ else { - do { - i = i->outer; - depth--; - if (i == NULL) - return; - } while (i->next_peer == NULL); + do + { + i = i->outer; + depth--; + if (i == NULL) + return; + } + while (i->next_peer == NULL); i = i->next_peer; } } } -/* Verify some basic invariants on EH datastructures. Could be extended to - catch more. */ +/* Dump the EH tree for FN on stderr. */ + +void +debug_eh_tree (struct function *fn) +{ + dump_eh_tree (stderr, fn); +} + +/* Verify invariants on EH datastructures. */ + void verify_eh_tree (struct function *fun) { - struct eh_region *i, *outer = NULL; + eh_region r, outer; + int nvisited_lp, nvisited_r; + int count_lp, count_r, depth, i; + eh_landing_pad lp; bool err = false; - int nvisited = 0; - int count = 0; - int j; - int depth = 0; - i = fun->eh->region_tree; - if (! i) + if (!fun->eh->region_tree) return; - for (j = fun->eh->last_region_number; j > 0; --j) - if ((i = VEC_index (eh_region, cfun->eh->region_array, j))) + + count_r = 0; + for (i = 1; VEC_iterate (eh_region, fun->eh->region_array, i, r); ++i) + if (r) + { + if (r->index == i) + count_r++; + else + { + error ("region_array is corrupted for region %i", r->index); + err = true; + } + } + + count_lp = 0; + for (i = 1; VEC_iterate (eh_landing_pad, fun->eh->lp_array, i, lp); ++i) + if (lp) { - count++; - if (i->region_number != j) + if (lp->index == i) + count_lp++; + else { - error ("region_array is corrupted for region %i", i->region_number); + error ("lp_array is corrupted for lp %i", lp->index); err = true; } } + depth = nvisited_lp = nvisited_r = 0; + outer = NULL; + r = fun->eh->region_tree; while (1) { - if (VEC_index (eh_region, cfun->eh->region_array, i->region_number) != i) + if (VEC_index (eh_region, fun->eh->region_array, r->index) != r) { - error ("region_array is corrupted for region %i", i->region_number); + error ("region_array is corrupted for region %i", r->index); err = true; } - if (i->outer != outer) + if (r->outer != outer) { - error ("outer block of region %i is wrong", i->region_number); + error ("outer block of region %i is wrong", r->index); err = true; } - if (i->may_contain_throw && outer && !outer->may_contain_throw) + if (depth < 0) { - error ("region %i may contain throw and is contained in region that may not", - i->region_number); + error ("negative nesting depth of region %i", r->index); err = true; } - if (depth < 0) + nvisited_r++; + + for (lp = r->landing_pads; lp ; lp = lp->next_lp) { - error ("negative nesting depth of region %i", i->region_number); - err = true; + if (VEC_index (eh_landing_pad, fun->eh->lp_array, lp->index) != lp) + { + error ("lp_array is corrupted for lp %i", lp->index); + err = true; + } + if (lp->region != r) + { + error ("region of lp %i is wrong", lp->index); + err = true; + } + nvisited_lp++; } - nvisited ++; - /* If there are sub-regions, process them. */ - if (i->inner) - outer = i, i = i->inner, depth++; - /* If there are peers, process them. */ - else if (i->next_peer) - i = i->next_peer; - /* Otherwise, step back up the tree to the next peer. */ + + if (r->inner) + outer = r, r = r->inner, depth++; + else if (r->next_peer) + r = r->next_peer; else { - do { - i = i->outer; - depth--; - if (i == NULL) - { - if (depth != -1) - { - error ("tree list ends on depth %i", depth + 1); - err = true; - } - if (count != nvisited) - { - error ("array does not match the region tree"); - err = true; - } - if (err) - { - dump_eh_tree (stderr, fun); - internal_error ("verify_eh_tree failed"); - } - return; - } - outer = i->outer; - } while (i->next_peer == NULL); - i = i->next_peer; + do + { + r = r->outer; + if (r == NULL) + goto region_done; + depth--; + outer = r->outer; + } + while (r->next_peer == NULL); + r = r->next_peer; } } -} - -/* Initialize unwind_resume_libfunc. */ + region_done: + if (depth != 0) + { + error ("tree list ends on depth %i", depth); + err = true; + } + if (count_r != nvisited_r) + { + error ("region_array does not match region_tree"); + err = true; + } + if (count_lp != nvisited_lp) + { + error ("lp_array does not match region_tree"); + err = true; + } -void -default_init_unwind_resume_libfunc (void) -{ - /* The default c++ routines aren't actually c++ specific, so use those. */ - unwind_resume_libfunc = - init_one_libfunc ( USING_SJLJ_EXCEPTIONS ? "_Unwind_SjLj_Resume" - : "_Unwind_Resume"); + if (err) + { + dump_eh_tree (stderr, fun); + internal_error ("verify_eh_tree failed"); + } } - -static bool -gate_handle_eh (void) -{ - return doing_eh (0); -} - -/* Complete generation of exception handling code. */ -static unsigned int -rest_of_handle_eh (void) -{ - cleanup_cfg (CLEANUP_NO_INSN_DEL); - finish_eh_generation (); - cleanup_cfg (CLEANUP_NO_INSN_DEL); - return 0; -} - -struct tree_opt_pass pass_rtl_eh = -{ - "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 */ - 'h' /* letter */ -}; - #include "gt-except.h"