1 /* Implements exception handling.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Mike Stump <mrs@cygnus.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* An exception is an event that can be "thrown" from within a
25 function. This event can then be "caught" by the callers of
28 The representation of exceptions changes several times during
29 the compilation process:
31 In the beginning, in the front end, we have the GENERIC trees
32 TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
33 CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
35 During initial gimplification (gimplify.c) these are lowered
36 to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
37 The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
38 into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
41 During pass_lower_eh (tree-eh.c) we record the nested structure
42 of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
43 We expand the lang_protect_cleanup_actions hook into MUST_NOT_THROW
44 regions at this time. We can then flatten the statements within
45 the TRY nodes to straight-line code. Statements that had been within
46 TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,
47 so that we may remember what action is supposed to be taken if
48 a given statement does throw. During this lowering process,
49 we create an EH_LANDING_PAD node for each EH_REGION that has
50 some code within the function that needs to be executed if a
51 throw does happen. We also create RESX statements that are
52 used to transfer control from an inner EH_REGION to an outer
53 EH_REGION. We also create EH_DISPATCH statements as placeholders
54 for a runtime type comparison that should be made in order to
55 select the action to perform among different CATCH and EH_FILTER
58 During pass_lower_eh_dispatch (tree-eh.c), which is run after
59 all inlining is complete, we are able to run assign_filter_values,
60 which allows us to map the set of types manipulated by all of the
61 CATCH and EH_FILTER regions to a set of integers. This set of integers
62 will be how the exception runtime communicates with the code generated
63 within the function. We then expand the GIMPLE_EH_DISPATCH statements
64 to a switch or conditional branches that use the argument provided by
65 the runtime (__builtin_eh_filter) and the set of integers we computed
66 in assign_filter_values.
68 During pass_lower_resx (tree-eh.c), which is run near the end
69 of optimization, we expand RESX statements. If the eh region
70 that is outer to the RESX statement is a MUST_NOT_THROW, then
71 the RESX expands to some form of abort statement. If the eh
72 region that is outer to the RESX statement is within the current
73 function, then the RESX expands to a bookkeeping call
74 (__builtin_eh_copy_values) and a goto. Otherwise, the next
75 handler for the exception must be within a function somewhere
76 up the call chain, so we call back into the exception runtime
77 (__builtin_unwind_resume).
79 During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
80 that create an rtl to eh_region mapping that corresponds to the
81 gimple to eh_region mapping that had been recorded in the
84 During pass_rtl_eh (except.c), we generate the real landing pads
85 to which the runtime will actually transfer control. These new
86 landing pads perform whatever bookkeeping is needed by the target
87 backend in order to resume execution within the current function.
88 Each of these new landing pads falls through into the post_landing_pad
89 label which had been used within the CFG up to this point. All
90 exception edges within the CFG are redirected to the new landing pads.
91 If the target uses setjmp to implement exceptions, the various extra
92 calls into the runtime to register and unregister the current stack
93 frame are emitted at this time.
95 During pass_convert_to_eh_region_ranges (except.c), we transform
96 the REG_EH_REGION notes attached to individual insns into
97 non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG
98 and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the
99 same associated action within the exception region tree, meaning
100 that (1) the exception is caught by the same landing pad within the
101 current function, (2) the exception is blocked by the runtime with
102 a MUST_NOT_THROW region, or (3) the exception is not handled at all
103 within the current function.
105 Finally, during assembly generation, we call
106 output_function_exception_table (except.c) to emit the tables with
107 which the exception runtime can determine if a given stack frame
108 handles a given exception, and if so what filter value to provide
109 to the function when the non-local control transfer is effected.
110 If the target uses dwarf2 unwinding to implement exceptions, then
111 output_call_frame_info (dwarf2out.c) emits the required unwind data. */
116 #include "coretypes.h"
121 #include "function.h"
123 #include "libfuncs.h"
124 #include "insn-config.h"
126 #include "integrate.h"
127 #include "hard-reg-set.h"
128 #include "basic-block.h"
130 #include "dwarf2asm.h"
131 #include "dwarf2out.h"
139 #include "langhooks.h"
141 #include "diagnostic.h"
142 #include "tree-pass.h"
144 #include "tree-flow.h"
146 /* Provide defaults for stuff that may not be defined when using
148 #ifndef EH_RETURN_DATA_REGNO
149 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
152 /* Protect cleanup actions with must-not-throw regions, with a call
153 to the given failure handler. */
154 tree (*lang_protect_cleanup_actions) (void);
156 /* Return true if type A catches type B. */
157 int (*lang_eh_type_covers) (tree a, tree b);
159 static GTY(()) int call_site_base;
160 static GTY ((param_is (union tree_node)))
161 htab_t type_to_runtime_map;
163 /* Describe the SjLj_Function_Context structure. */
164 static GTY(()) tree sjlj_fc_type_node;
165 static int sjlj_fc_call_site_ofs;
166 static int sjlj_fc_data_ofs;
167 static int sjlj_fc_personality_ofs;
168 static int sjlj_fc_lsda_ofs;
169 static int sjlj_fc_jbuf_ofs;
172 struct GTY(()) call_site_record_d
178 static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *,
181 static int t2r_eq (const void *, const void *);
182 static hashval_t t2r_hash (const void *);
184 static int ttypes_filter_eq (const void *, const void *);
185 static hashval_t ttypes_filter_hash (const void *);
186 static int ehspec_filter_eq (const void *, const void *);
187 static hashval_t ehspec_filter_hash (const void *);
188 static int add_ttypes_entry (htab_t, tree);
189 static int add_ehspec_entry (htab_t, htab_t, tree);
190 static void dw2_build_landing_pads (void);
192 static int action_record_eq (const void *, const void *);
193 static hashval_t action_record_hash (const void *);
194 static int add_action_record (htab_t, int, int);
195 static int collect_one_action_chain (htab_t, eh_region);
196 static int add_call_site (rtx, int, int);
198 static void push_uleb128 (VEC (uchar, gc) **, unsigned int);
199 static void push_sleb128 (VEC (uchar, gc) **, int);
200 #ifndef HAVE_AS_LEB128
201 static int dw2_size_of_call_site_table (int);
202 static int sjlj_size_of_call_site_table (void);
204 static void dw2_output_call_site_table (int, int);
205 static void sjlj_output_call_site_table (void);
208 /* Routine to see if exception handling is turned on.
209 DO_WARN is nonzero if we want to inform the user that exception
210 handling is turned off.
212 This is used to ensure that -fexceptions has been specified if the
213 compiler tries to use any exception-specific functions. */
216 doing_eh (int do_warn)
218 if (! flag_exceptions)
220 static int warned = 0;
221 if (! warned && do_warn)
223 error ("exception handling disabled, use -fexceptions to enable");
235 if (! flag_exceptions)
238 type_to_runtime_map = htab_create_ggc (31, t2r_hash, t2r_eq, NULL);
240 /* Create the SjLj_Function_Context structure. This should match
241 the definition in unwind-sjlj.c. */
242 if (USING_SJLJ_EXCEPTIONS)
244 tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp;
246 sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE);
248 f_prev = build_decl (BUILTINS_LOCATION,
249 FIELD_DECL, get_identifier ("__prev"),
250 build_pointer_type (sjlj_fc_type_node));
251 DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node;
253 f_cs = build_decl (BUILTINS_LOCATION,
254 FIELD_DECL, get_identifier ("__call_site"),
256 DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;
258 tmp = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
259 tmp = build_array_type (lang_hooks.types.type_for_mode
260 (targetm.unwind_word_mode (), 1),
262 f_data = build_decl (BUILTINS_LOCATION,
263 FIELD_DECL, get_identifier ("__data"), tmp);
264 DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node;
266 f_per = build_decl (BUILTINS_LOCATION,
267 FIELD_DECL, get_identifier ("__personality"),
269 DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node;
271 f_lsda = build_decl (BUILTINS_LOCATION,
272 FIELD_DECL, get_identifier ("__lsda"),
274 DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node;
276 #ifdef DONT_USE_BUILTIN_SETJMP
278 tmp = build_int_cst (NULL_TREE, JMP_BUF_SIZE - 1);
280 /* Should be large enough for most systems, if it is not,
281 JMP_BUF_SIZE should be defined with the proper value. It will
282 also tend to be larger than necessary for most systems, a more
283 optimal port will define JMP_BUF_SIZE. */
284 tmp = build_int_cst (NULL_TREE, FIRST_PSEUDO_REGISTER + 2 - 1);
287 /* builtin_setjmp takes a pointer to 5 words. */
288 tmp = build_int_cst (NULL_TREE, 5 * BITS_PER_WORD / POINTER_SIZE - 1);
290 tmp = build_index_type (tmp);
291 tmp = build_array_type (ptr_type_node, tmp);
292 f_jbuf = build_decl (BUILTINS_LOCATION,
293 FIELD_DECL, get_identifier ("__jbuf"), tmp);
294 #ifdef DONT_USE_BUILTIN_SETJMP
295 /* We don't know what the alignment requirements of the
296 runtime's jmp_buf has. Overestimate. */
297 DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT;
298 DECL_USER_ALIGN (f_jbuf) = 1;
300 DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node;
302 TYPE_FIELDS (sjlj_fc_type_node) = f_prev;
303 TREE_CHAIN (f_prev) = f_cs;
304 TREE_CHAIN (f_cs) = f_data;
305 TREE_CHAIN (f_data) = f_per;
306 TREE_CHAIN (f_per) = f_lsda;
307 TREE_CHAIN (f_lsda) = f_jbuf;
309 layout_type (sjlj_fc_type_node);
311 /* Cache the interesting field offsets so that we have
312 easy access from rtl. */
313 sjlj_fc_call_site_ofs
314 = (tree_low_cst (DECL_FIELD_OFFSET (f_cs), 1)
315 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs), 1) / BITS_PER_UNIT);
317 = (tree_low_cst (DECL_FIELD_OFFSET (f_data), 1)
318 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data), 1) / BITS_PER_UNIT);
319 sjlj_fc_personality_ofs
320 = (tree_low_cst (DECL_FIELD_OFFSET (f_per), 1)
321 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per), 1) / BITS_PER_UNIT);
323 = (tree_low_cst (DECL_FIELD_OFFSET (f_lsda), 1)
324 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda), 1) / BITS_PER_UNIT);
326 = (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf), 1)
327 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf), 1) / BITS_PER_UNIT);
332 init_eh_for_function (void)
334 cfun->eh = GGC_CNEW (struct eh_status);
336 /* Make sure zero'th entries are used. */
337 VEC_safe_push (eh_region, gc, cfun->eh->region_array, NULL);
338 VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, NULL);
341 /* Routines to generate the exception tree somewhat directly.
342 These are used from tree-eh.c when processing exception related
343 nodes during tree optimization. */
346 gen_eh_region (enum eh_region_type type, eh_region outer)
350 #ifdef ENABLE_CHECKING
351 gcc_assert (doing_eh (0));
354 /* Insert a new blank region as a leaf in the tree. */
355 new_eh = GGC_CNEW (struct eh_region_d);
357 new_eh->outer = outer;
360 new_eh->next_peer = outer->inner;
361 outer->inner = new_eh;
365 new_eh->next_peer = cfun->eh->region_tree;
366 cfun->eh->region_tree = new_eh;
369 new_eh->index = VEC_length (eh_region, cfun->eh->region_array);
370 VEC_safe_push (eh_region, gc, cfun->eh->region_array, new_eh);
372 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
373 if (targetm.arm_eabi_unwinder && lang_hooks.eh_use_cxa_end_cleanup)
374 new_eh->use_cxa_end_cleanup = true;
380 gen_eh_region_cleanup (eh_region outer)
382 return gen_eh_region (ERT_CLEANUP, outer);
386 gen_eh_region_try (eh_region outer)
388 return gen_eh_region (ERT_TRY, outer);
392 gen_eh_region_catch (eh_region t, tree type_or_list)
395 tree type_list, type_node;
397 gcc_assert (t->type == ERT_TRY);
399 /* Ensure to always end up with a type list to normalize further
400 processing, then register each type against the runtime types map. */
401 type_list = type_or_list;
404 if (TREE_CODE (type_or_list) != TREE_LIST)
405 type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);
407 type_node = type_list;
408 for (; type_node; type_node = TREE_CHAIN (type_node))
409 add_type_for_runtime (TREE_VALUE (type_node));
412 c = GGC_CNEW (struct eh_catch_d);
413 c->type_list = type_list;
414 l = t->u.eh_try.last_catch;
419 t->u.eh_try.first_catch = c;
420 t->u.eh_try.last_catch = c;
426 gen_eh_region_allowed (eh_region outer, tree allowed)
428 eh_region region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
429 region->u.allowed.type_list = allowed;
431 for (; allowed ; allowed = TREE_CHAIN (allowed))
432 add_type_for_runtime (TREE_VALUE (allowed));
438 gen_eh_region_must_not_throw (eh_region outer)
440 return gen_eh_region (ERT_MUST_NOT_THROW, outer);
444 gen_eh_landing_pad (eh_region region)
446 eh_landing_pad lp = GGC_CNEW (struct eh_landing_pad_d);
448 lp->next_lp = region->landing_pads;
450 lp->index = VEC_length (eh_landing_pad, cfun->eh->lp_array);
451 region->landing_pads = lp;
453 VEC_safe_push (eh_landing_pad, gc, cfun->eh->lp_array, lp);
459 get_eh_region_from_number_fn (struct function *ifun, int i)
461 return VEC_index (eh_region, ifun->eh->region_array, i);
465 get_eh_region_from_number (int i)
467 return get_eh_region_from_number_fn (cfun, i);
471 get_eh_landing_pad_from_number_fn (struct function *ifun, int i)
473 return VEC_index (eh_landing_pad, ifun->eh->lp_array, i);
477 get_eh_landing_pad_from_number (int i)
479 return get_eh_landing_pad_from_number_fn (cfun, i);
483 get_eh_region_from_lp_number_fn (struct function *ifun, int i)
486 return VEC_index (eh_region, ifun->eh->region_array, -i);
492 lp = VEC_index (eh_landing_pad, ifun->eh->lp_array, i);
498 get_eh_region_from_lp_number (int i)
500 return get_eh_region_from_lp_number_fn (cfun, i);
503 /* Returns true if the current function has exception handling regions. */
506 current_function_has_exception_handlers (void)
508 return cfun->eh->region_tree != NULL;
511 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
512 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
514 struct duplicate_eh_regions_data
516 duplicate_eh_regions_map label_map;
517 void *label_map_data;
518 struct pointer_map_t *eh_map;
522 duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,
523 eh_region old_r, eh_region outer)
525 eh_landing_pad old_lp, new_lp;
529 new_r = gen_eh_region (old_r->type, outer);
530 slot = pointer_map_insert (data->eh_map, (void *)old_r);
531 gcc_assert (*slot == NULL);
532 *slot = (void *)new_r;
542 for (oc = old_r->u.eh_try.first_catch; oc ; oc = oc->next_catch)
544 /* We should be doing all our region duplication before and
545 during inlining, which is before filter lists are created. */
546 gcc_assert (oc->filter_list == NULL);
547 nc = gen_eh_region_catch (new_r, oc->type_list);
548 nc->label = data->label_map (oc->label, data->label_map_data);
553 case ERT_ALLOWED_EXCEPTIONS:
554 new_r->u.allowed.type_list = old_r->u.allowed.type_list;
555 if (old_r->u.allowed.label)
556 new_r->u.allowed.label
557 = data->label_map (old_r->u.allowed.label, data->label_map_data);
559 new_r->u.allowed.label = NULL_TREE;
562 case ERT_MUST_NOT_THROW:
563 new_r->u.must_not_throw = old_r->u.must_not_throw;
567 for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp)
569 /* Don't bother copying unused landing pads. */
570 if (old_lp->post_landing_pad == NULL)
573 new_lp = gen_eh_landing_pad (new_r);
574 slot = pointer_map_insert (data->eh_map, (void *)old_lp);
575 gcc_assert (*slot == NULL);
576 *slot = (void *)new_lp;
578 new_lp->post_landing_pad
579 = data->label_map (old_lp->post_landing_pad, data->label_map_data);
580 EH_LANDING_PAD_NR (new_lp->post_landing_pad) = new_lp->index;
583 /* Make sure to preserve the original use of __cxa_end_cleanup. */
584 new_r->use_cxa_end_cleanup = old_r->use_cxa_end_cleanup;
586 for (old_r = old_r->inner; old_r ; old_r = old_r->next_peer)
587 duplicate_eh_regions_1 (data, old_r, new_r);
590 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
591 the current function and root the tree below OUTER_REGION.
592 The special case of COPY_REGION of NULL means all regions.
593 Remap labels using MAP/MAP_DATA callback. Return a pointer map
594 that allows the caller to remap uses of both EH regions and
597 struct pointer_map_t *
598 duplicate_eh_regions (struct function *ifun,
599 eh_region copy_region, int outer_lp,
600 duplicate_eh_regions_map map, void *map_data)
602 struct duplicate_eh_regions_data data;
603 eh_region outer_region;
605 #ifdef ENABLE_CHECKING
606 verify_eh_tree (ifun);
609 data.label_map = map;
610 data.label_map_data = map_data;
611 data.eh_map = pointer_map_create ();
613 outer_region = get_eh_region_from_lp_number (outer_lp);
615 /* Copy all the regions in the subtree. */
617 duplicate_eh_regions_1 (&data, copy_region, outer_region);
621 for (r = ifun->eh->region_tree; r ; r = r->next_peer)
622 duplicate_eh_regions_1 (&data, r, outer_region);
625 #ifdef ENABLE_CHECKING
626 verify_eh_tree (cfun);
632 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
635 eh_region_outermost (struct function *ifun, eh_region region_a,
640 gcc_assert (ifun->eh->region_array);
641 gcc_assert (ifun->eh->region_tree);
643 b_outer = sbitmap_alloc (VEC_length (eh_region, ifun->eh->region_array));
644 sbitmap_zero (b_outer);
648 SET_BIT (b_outer, region_b->index);
649 region_b = region_b->outer;
655 if (TEST_BIT (b_outer, region_a->index))
657 region_a = region_a->outer;
661 sbitmap_free (b_outer);
666 t2r_eq (const void *pentry, const void *pdata)
668 const_tree const entry = (const_tree) pentry;
669 const_tree const data = (const_tree) pdata;
671 return TREE_PURPOSE (entry) == data;
675 t2r_hash (const void *pentry)
677 const_tree const entry = (const_tree) pentry;
678 return TREE_HASH (TREE_PURPOSE (entry));
682 add_type_for_runtime (tree type)
686 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
687 if (TREE_CODE (type) == NOP_EXPR)
690 slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
691 TREE_HASH (type), INSERT);
694 tree runtime = lang_hooks.eh_runtime_type (type);
695 *slot = tree_cons (type, runtime, NULL_TREE);
700 lookup_type_for_runtime (tree type)
704 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
705 if (TREE_CODE (type) == NOP_EXPR)
708 slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
709 TREE_HASH (type), NO_INSERT);
711 /* We should have always inserted the data earlier. */
712 return TREE_VALUE (*slot);
716 /* Represent an entry in @TTypes for either catch actions
717 or exception filter actions. */
718 struct GTY(()) ttypes_filter {
723 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
724 (a tree) for a @TTypes type node we are thinking about adding. */
727 ttypes_filter_eq (const void *pentry, const void *pdata)
729 const struct ttypes_filter *const entry
730 = (const struct ttypes_filter *) pentry;
731 const_tree const data = (const_tree) pdata;
733 return entry->t == data;
737 ttypes_filter_hash (const void *pentry)
739 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
740 return TREE_HASH (entry->t);
743 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
744 exception specification list we are thinking about adding. */
745 /* ??? Currently we use the type lists in the order given. Someone
746 should put these in some canonical order. */
749 ehspec_filter_eq (const void *pentry, const void *pdata)
751 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
752 const struct ttypes_filter *data = (const struct ttypes_filter *) pdata;
754 return type_list_equal (entry->t, data->t);
757 /* Hash function for exception specification lists. */
760 ehspec_filter_hash (const void *pentry)
762 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
766 for (list = entry->t; list ; list = TREE_CHAIN (list))
767 h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list));
771 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
772 to speed up the search. Return the filter value to be used. */
775 add_ttypes_entry (htab_t ttypes_hash, tree type)
777 struct ttypes_filter **slot, *n;
779 slot = (struct ttypes_filter **)
780 htab_find_slot_with_hash (ttypes_hash, type, TREE_HASH (type), INSERT);
782 if ((n = *slot) == NULL)
784 /* Filter value is a 1 based table index. */
786 n = XNEW (struct ttypes_filter);
788 n->filter = VEC_length (tree, cfun->eh->ttype_data) + 1;
791 VEC_safe_push (tree, gc, cfun->eh->ttype_data, type);
797 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
798 to speed up the search. Return the filter value to be used. */
801 add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list)
803 struct ttypes_filter **slot, *n;
804 struct ttypes_filter dummy;
807 slot = (struct ttypes_filter **)
808 htab_find_slot (ehspec_hash, &dummy, INSERT);
810 if ((n = *slot) == NULL)
814 if (targetm.arm_eabi_unwinder)
815 len = VEC_length (tree, cfun->eh->ehspec_data.arm_eabi);
817 len = VEC_length (uchar, cfun->eh->ehspec_data.other);
819 /* Filter value is a -1 based byte index into a uleb128 buffer. */
821 n = XNEW (struct ttypes_filter);
823 n->filter = -(len + 1);
826 /* Generate a 0 terminated list of filter values. */
827 for (; list ; list = TREE_CHAIN (list))
829 if (targetm.arm_eabi_unwinder)
830 VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi,
834 /* Look up each type in the list and encode its filter
835 value as a uleb128. */
836 push_uleb128 (&cfun->eh->ehspec_data.other,
837 add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
840 if (targetm.arm_eabi_unwinder)
841 VEC_safe_push (tree, gc, cfun->eh->ehspec_data.arm_eabi, NULL_TREE);
843 VEC_safe_push (uchar, gc, cfun->eh->ehspec_data.other, 0);
849 /* Generate the action filter values to be used for CATCH and
850 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
851 we use lots of landing pads, and so every type or list can share
852 the same filter value, which saves table space. */
855 assign_filter_values (void)
858 htab_t ttypes, ehspec;
862 cfun->eh->ttype_data = VEC_alloc (tree, gc, 16);
863 if (targetm.arm_eabi_unwinder)
864 cfun->eh->ehspec_data.arm_eabi = VEC_alloc (tree, gc, 64);
866 cfun->eh->ehspec_data.other = VEC_alloc (uchar, gc, 64);
868 ttypes = htab_create (31, ttypes_filter_hash, ttypes_filter_eq, free);
869 ehspec = htab_create (31, ehspec_filter_hash, ehspec_filter_eq, free);
871 for (i = 1; VEC_iterate (eh_region, cfun->eh->region_array, i, r); ++i)
879 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
881 /* Whatever type_list is (NULL or true list), we build a list
882 of filters for the region. */
883 c->filter_list = NULL_TREE;
885 if (c->type_list != NULL)
887 /* Get a filter value for each of the types caught and store
888 them in the region's dedicated list. */
889 tree tp_node = c->type_list;
891 for ( ; tp_node; tp_node = TREE_CHAIN (tp_node))
893 int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
894 tree flt_node = build_int_cst (NULL_TREE, flt);
897 = tree_cons (NULL_TREE, flt_node, c->filter_list);
902 /* Get a filter value for the NULL list also since it
903 will need an action record anyway. */
904 int flt = add_ttypes_entry (ttypes, NULL);
905 tree flt_node = build_int_cst (NULL_TREE, flt);
908 = tree_cons (NULL_TREE, flt_node, NULL);
913 case ERT_ALLOWED_EXCEPTIONS:
915 = add_ehspec_entry (ehspec, ttypes, r->u.allowed.type_list);
923 htab_delete (ttypes);
924 htab_delete (ehspec);
927 /* Emit SEQ into basic block just before INSN (that is assumed to be
928 first instruction of some existing BB and return the newly
931 emit_to_new_bb_before (rtx seq, rtx insn)
938 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
939 call), we don't want it to go into newly created landing pad or other EH
941 for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); )
942 if (e->flags & EDGE_FALLTHRU)
943 force_nonfallthru (e);
946 last = emit_insn_before (seq, insn);
947 if (BARRIER_P (last))
948 last = PREV_INSN (last);
949 bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);
950 update_bb_for_insn (bb);
951 bb->flags |= BB_SUPERBLOCK;
955 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
958 dw2_build_landing_pads (void)
963 for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
970 if (lp == NULL || lp->post_landing_pad == NULL)
975 lp->landing_pad = gen_label_rtx ();
976 emit_label (lp->landing_pad);
978 #ifdef HAVE_exception_receiver
979 if (HAVE_exception_receiver)
980 emit_insn (gen_exception_receiver ());
983 #ifdef HAVE_nonlocal_goto_receiver
984 if (HAVE_nonlocal_goto_receiver)
985 emit_insn (gen_nonlocal_goto_receiver ());
991 if (region->exc_ptr_reg)
992 emit_move_insn (region->exc_ptr_reg,
993 gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
994 if (region->filter_reg)
995 emit_move_insn (region->filter_reg,
996 gen_rtx_REG (targetm.eh_return_filter_mode (),
997 EH_RETURN_DATA_REGNO (1)));
1002 bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad));
1003 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
1004 e->count = bb->count;
1005 e->probability = REG_BR_PROB_BASE;
1010 static VEC (int, heap) *sjlj_lp_call_site_index;
1012 /* Process all active landing pads. Assign each one a compact dispatch
1013 index, and a call-site index. */
1016 sjlj_assign_call_site_values (void)
1022 crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64);
1023 ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
1027 for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
1028 if (lp && lp->post_landing_pad)
1030 int action, call_site;
1032 /* First: build the action table. */
1033 action = collect_one_action_chain (ar_hash, lp->region);
1035 crtl->uses_eh_lsda = 1;
1037 /* Next: assign call-site values. If dwarf2 terms, this would be
1038 the region number assigned by convert_to_eh_region_ranges, but
1039 handles no-action and must-not-throw differently. */
1040 /* Map must-not-throw to otherwise unused call-site index 0. */
1043 /* Map no-action to otherwise unused call-site index -1. */
1044 else if (action == -1)
1046 /* Otherwise, look it up in the table. */
1048 call_site = add_call_site (GEN_INT (disp_index), action, 0);
1049 VEC_replace (int, sjlj_lp_call_site_index, i, call_site);
1054 htab_delete (ar_hash);
1059 /* Emit code to record the current call-site index before every
1060 insn that can throw. */
1063 sjlj_mark_call_sites (void)
1065 int last_call_site = -2;
1068 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
1076 /* Reset value tracking at extended basic block boundaries. */
1078 last_call_site = -2;
1080 if (! INSN_P (insn))
1083 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1087 this_call_site = VEC_index (int, sjlj_lp_call_site_index, lp->index);
1090 /* Calls (and trapping insns) without notes are outside any
1091 exception handling region in this function. Mark them as
1093 this_call_site = -1;
1097 gcc_assert (r->type == ERT_MUST_NOT_THROW);
1101 if (this_call_site == last_call_site)
1104 /* Don't separate a call from it's argument loads. */
1107 before = find_first_parameter_load (insn, NULL_RTX);
1110 mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node),
1111 sjlj_fc_call_site_ofs);
1112 emit_move_insn (mem, GEN_INT (this_call_site));
1116 emit_insn_before (p, before);
1117 last_call_site = this_call_site;
1121 /* Construct the SjLj_Function_Context. */
1124 sjlj_emit_function_enter (rtx dispatch_label)
1126 rtx fn_begin, fc, mem, seq;
1127 bool fn_begin_outside_block;
1128 rtx personality = get_personality_function (current_function_decl);
1130 fc = crtl->eh.sjlj_fc;
1134 /* We're storing this libcall's address into memory instead of
1135 calling it directly. Thus, we must call assemble_external_libcall
1136 here, as we can not depend on emit_library_call to do it for us. */
1137 assemble_external_libcall (personality);
1138 mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
1139 emit_move_insn (mem, personality);
1141 mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
1142 if (crtl->uses_eh_lsda)
1147 ASM_GENERATE_INTERNAL_LABEL (buf, "LLSDA", current_function_funcdef_no);
1148 sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
1149 SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_LOCAL;
1150 emit_move_insn (mem, sym);
1153 emit_move_insn (mem, const0_rtx);
1155 #ifdef DONT_USE_BUILTIN_SETJMP
1158 x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE,
1159 TYPE_MODE (integer_type_node), 1,
1160 plus_constant (XEXP (fc, 0),
1161 sjlj_fc_jbuf_ofs), Pmode);
1163 emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
1164 TYPE_MODE (integer_type_node), 0, dispatch_label);
1165 last = get_last_insn ();
1166 if (JUMP_P (last) && any_condjump_p (last))
1168 gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
1169 add_reg_note (last, REG_BR_PROB, GEN_INT (REG_BR_PROB_BASE / 100));
1173 expand_builtin_setjmp_setup (plus_constant (XEXP (fc, 0), sjlj_fc_jbuf_ofs),
1177 emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
1178 1, XEXP (fc, 0), Pmode);
1183 /* ??? Instead of doing this at the beginning of the function,
1184 do this in a block that is at loop level 0 and dominates all
1185 can_throw_internal instructions. */
1187 fn_begin_outside_block = true;
1188 for (fn_begin = get_insns (); ; fn_begin = NEXT_INSN (fn_begin))
1189 if (NOTE_P (fn_begin))
1191 if (NOTE_KIND (fn_begin) == NOTE_INSN_FUNCTION_BEG)
1193 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin))
1194 fn_begin_outside_block = false;
1197 if (fn_begin_outside_block)
1198 insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR));
1200 emit_insn_after (seq, fn_begin);
1203 /* Call back from expand_function_end to know where we should put
1204 the call to unwind_sjlj_unregister_libfunc if needed. */
1207 sjlj_emit_function_exit_after (rtx after)
1209 crtl->eh.sjlj_exit_after = after;
1213 sjlj_emit_function_exit (void)
1219 emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
1220 1, XEXP (crtl->eh.sjlj_fc, 0), Pmode);
1225 /* ??? Really this can be done in any block at loop level 0 that
1226 post-dominates all can_throw_internal instructions. This is
1227 the last possible moment. */
1229 insn = crtl->eh.sjlj_exit_after;
1231 insn = NEXT_INSN (insn);
1233 emit_insn_after (seq, insn);
1237 sjlj_emit_dispatch_table (rtx dispatch_label, int num_dispatch)
1239 enum machine_mode unwind_word_mode = targetm.unwind_word_mode ();
1240 enum machine_mode filter_mode = targetm.eh_return_filter_mode ();
1242 rtx mem, seq, fc, before, exc_ptr_reg, filter_reg;
1243 rtx first_reachable_label;
1250 fc = crtl->eh.sjlj_fc;
1254 emit_label (dispatch_label);
1256 #ifndef DONT_USE_BUILTIN_SETJMP
1257 expand_builtin_setjmp_receiver (dispatch_label);
1259 /* The caller of expand_builtin_setjmp_receiver is responsible for
1260 making sure that the label doesn't vanish. The only other caller
1261 is the expander for __builtin_setjmp_receiver, which places this
1262 label on the nonlocal_goto_label list. Since we're modeling these
1263 CFG edges more exactly, we can use the forced_labels list instead. */
1264 LABEL_PRESERVE_P (dispatch_label) = 1;
1266 = gen_rtx_EXPR_LIST (VOIDmode, dispatch_label, forced_labels);
1269 /* Load up exc_ptr and filter values from the function context. */
1270 mem = adjust_address (fc, unwind_word_mode, sjlj_fc_data_ofs);
1271 if (unwind_word_mode != ptr_mode)
1273 #ifdef POINTERS_EXTEND_UNSIGNED
1274 mem = convert_memory_address (ptr_mode, mem);
1276 mem = convert_to_mode (ptr_mode, mem, 0);
1279 exc_ptr_reg = force_reg (ptr_mode, mem);
1281 mem = adjust_address (fc, unwind_word_mode,
1282 sjlj_fc_data_ofs + GET_MODE_SIZE (unwind_word_mode));
1283 if (unwind_word_mode != filter_mode)
1284 mem = convert_to_mode (filter_mode, mem, 0);
1285 filter_reg = force_reg (filter_mode, mem);
1287 /* Jump to one of the directly reachable regions. */
1290 first_reachable_label = NULL;
1292 /* If there's exactly one call site in the function, don't bother
1293 generating a switch statement. */
1295 if (num_dispatch > 1)
1299 mem = adjust_address (fc, TYPE_MODE (integer_type_node),
1300 sjlj_fc_call_site_ofs);
1301 disp = make_tree (integer_type_node, mem);
1303 switch_stmt = gimple_build_switch_nlabels (num_dispatch, disp, NULL);
1306 for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
1307 if (lp && lp->post_landing_pad)
1313 lp->landing_pad = dispatch_label;
1315 if (num_dispatch > 1)
1317 tree t_label, case_elt;
1319 t_label = create_artificial_label (UNKNOWN_LOCATION);
1320 case_elt = build3 (CASE_LABEL_EXPR, void_type_node,
1321 build_int_cst (NULL, disp_index),
1323 gimple_switch_set_label (switch_stmt, disp_index, case_elt);
1325 label = label_rtx (t_label);
1328 label = gen_label_rtx ();
1330 if (disp_index == 0)
1331 first_reachable_label = label;
1336 emit_move_insn (r->exc_ptr_reg, exc_ptr_reg);
1338 emit_move_insn (r->filter_reg, filter_reg);
1340 seq2 = get_insns ();
1343 before = label_rtx (lp->post_landing_pad);
1344 bb = emit_to_new_bb_before (seq2, before);
1345 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
1346 e->count = bb->count;
1347 e->probability = REG_BR_PROB_BASE;
1351 gcc_assert (disp_index == num_dispatch);
1353 if (num_dispatch > 1)
1355 expand_case (switch_stmt);
1356 expand_builtin_trap ();
1362 bb = emit_to_new_bb_before (seq, first_reachable_label);
1363 if (num_dispatch == 1)
1365 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
1366 e->count = bb->count;
1367 e->probability = REG_BR_PROB_BASE;
1372 sjlj_build_landing_pads (void)
1376 num_dispatch = VEC_length (eh_landing_pad, cfun->eh->lp_array);
1377 if (num_dispatch == 0)
1379 VEC_safe_grow (int, heap, sjlj_lp_call_site_index, num_dispatch);
1381 num_dispatch = sjlj_assign_call_site_values ();
1382 if (num_dispatch > 0)
1384 rtx dispatch_label = gen_label_rtx ();
1385 int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node,
1386 TYPE_MODE (sjlj_fc_type_node),
1387 TYPE_ALIGN (sjlj_fc_type_node));
1389 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
1390 int_size_in_bytes (sjlj_fc_type_node),
1393 sjlj_mark_call_sites ();
1394 sjlj_emit_function_enter (dispatch_label);
1395 sjlj_emit_dispatch_table (dispatch_label, num_dispatch);
1396 sjlj_emit_function_exit ();
1399 VEC_free (int, heap, sjlj_lp_call_site_index);
1402 /* After initial rtl generation, call back to finish generating
1403 exception support code. */
1406 finish_eh_generation (void)
1410 /* Construct the landing pads. */
1411 if (USING_SJLJ_EXCEPTIONS)
1412 sjlj_build_landing_pads ();
1414 dw2_build_landing_pads ();
1415 break_superblocks ();
1417 if (USING_SJLJ_EXCEPTIONS
1418 /* Kludge for Alpha/Tru64 (see alpha_gp_save_rtx). */
1419 || single_succ_edge (ENTRY_BLOCK_PTR)->insns.r)
1420 commit_edge_insertions ();
1422 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1429 lp = get_eh_landing_pad_from_rtx (BB_END (bb));
1431 FOR_EACH_EDGE (e, ei, bb->succs)
1432 if (e->flags & EDGE_EH)
1435 /* We should not have generated any new throwing insns during this
1436 pass, and we should not have lost any EH edges, so we only need
1437 to handle two cases here:
1438 (1) reachable handler and an existing edge to post-landing-pad,
1439 (2) no reachable handler and no edge. */
1440 gcc_assert ((lp != NULL) == (e != NULL));
1443 gcc_assert (BB_HEAD (e->dest) == label_rtx (lp->post_landing_pad));
1445 redirect_edge_succ (e, BLOCK_FOR_INSN (lp->landing_pad));
1446 e->flags |= (CALL_P (BB_END (bb))
1447 ? EDGE_ABNORMAL | EDGE_ABNORMAL_CALL
1454 gate_handle_eh (void)
1456 /* Nothing to do if no regions created. */
1457 return cfun->eh->region_tree != NULL;
1460 /* Complete generation of exception handling code. */
1462 rest_of_handle_eh (void)
1464 finish_eh_generation ();
1465 cleanup_cfg (CLEANUP_NO_INSN_DEL);
1469 struct rtl_opt_pass pass_rtl_eh =
1473 "rtl eh", /* name */
1474 gate_handle_eh, /* gate */
1475 rest_of_handle_eh, /* execute */
1478 0, /* static_pass_number */
1479 TV_JUMP, /* tv_id */
1480 0, /* properties_required */
1481 0, /* properties_provided */
1482 0, /* properties_destroyed */
1483 0, /* todo_flags_start */
1484 TODO_dump_func /* todo_flags_finish */
1488 /* This section handles removing dead code for flow. */
1491 remove_eh_landing_pad (eh_landing_pad lp)
1495 for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp)
1499 if (lp->post_landing_pad)
1500 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1501 VEC_replace (eh_landing_pad, cfun->eh->lp_array, lp->index, NULL);
1504 /* Splice REGION from the region tree. */
1507 remove_eh_handler (eh_region region)
1509 eh_region *pp, *pp_start, p, outer;
1512 for (lp = region->landing_pads; lp ; lp = lp->next_lp)
1514 if (lp->post_landing_pad)
1515 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1516 VEC_replace (eh_landing_pad, cfun->eh->lp_array, lp->index, NULL);
1519 outer = region->outer;
1521 pp_start = &outer->inner;
1523 pp_start = &cfun->eh->region_tree;
1524 for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp)
1528 *pp = p = region->inner;
1537 *pp = region->next_peer;
1539 VEC_replace (eh_region, cfun->eh->region_array, region->index, NULL);
1542 /* Invokes CALLBACK for every exception handler landing pad label.
1543 Only used by reload hackery; should not be used by new code. */
1546 for_each_eh_label (void (*callback) (rtx))
1551 for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
1555 rtx lab = lp->landing_pad;
1556 if (lab && LABEL_P (lab))
1562 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1565 At the gimple level, we use LP_NR
1566 > 0 : The statement transfers to landing pad LP_NR
1567 = 0 : The statement is outside any EH region
1568 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1570 At the rtl level, we use LP_NR
1571 > 0 : The insn transfers to landing pad LP_NR
1572 = 0 : The insn cannot throw
1573 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1574 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1575 missing note: The insn is outside any EH region.
1577 ??? This difference probably ought to be avoided. We could stand
1578 to record nothrow for arbitrary gimple statements, and so avoid
1579 some moderately complex lookups in stmt_could_throw_p. Perhaps
1580 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1581 no-nonlocal-goto property should be recorded elsewhere as a bit
1582 on the call_insn directly. Perhaps we should make more use of
1583 attaching the trees to call_insns (reachable via symbol_ref in
1584 direct call cases) and just pull the data out of the trees. */
1587 make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr)
1590 if (ecf_flags & ECF_NOTHROW)
1592 else if (lp_nr != 0)
1593 value = GEN_INT (lp_nr);
1596 add_reg_note (insn, REG_EH_REGION, value);
1599 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1600 nor perform a non-local goto. Replace the region note if it
1604 make_reg_eh_region_note_nothrow_nononlocal (rtx insn)
1606 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1607 rtx intmin = GEN_INT (INT_MIN);
1610 XEXP (note, 0) = intmin;
1612 add_reg_note (insn, REG_EH_REGION, intmin);
1615 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1619 insn_could_throw_p (const_rtx insn)
1623 if (INSN_P (insn) && flag_non_call_exceptions)
1624 return may_trap_p (PATTERN (insn));
1628 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1629 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1630 to look for a note, or the note itself. */
1633 copy_reg_eh_region_note_forward (rtx note_or_insn, rtx first, rtx last)
1635 rtx insn, note = note_or_insn;
1637 if (INSN_P (note_or_insn))
1639 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
1643 note = XEXP (note, 0);
1645 for (insn = first; insn != last ; insn = NEXT_INSN (insn))
1646 if (!find_reg_note (insn, REG_EH_REGION, NULL_RTX)
1647 && insn_could_throw_p (insn))
1648 add_reg_note (insn, REG_EH_REGION, note);
1651 /* Likewise, but iterate backward. */
1654 copy_reg_eh_region_note_backward (rtx note_or_insn, rtx last, rtx first)
1656 rtx insn, note = note_or_insn;
1658 if (INSN_P (note_or_insn))
1660 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
1664 note = XEXP (note, 0);
1666 for (insn = last; insn != first; insn = PREV_INSN (insn))
1667 if (insn_could_throw_p (insn))
1668 add_reg_note (insn, REG_EH_REGION, note);
1672 /* Extract all EH information from INSN. Return true if the insn
1673 was marked NOTHROW. */
1676 get_eh_region_and_lp_from_rtx (const_rtx insn, eh_region *pr,
1677 eh_landing_pad *plp)
1679 eh_landing_pad lp = NULL;
1685 if (! INSN_P (insn))
1688 if (NONJUMP_INSN_P (insn)
1689 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1690 insn = XVECEXP (PATTERN (insn), 0, 0);
1692 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1695 ret = !insn_could_throw_p (insn);
1699 lp_nr = INTVAL (XEXP (note, 0));
1700 if (lp_nr == 0 || lp_nr == INT_MIN)
1707 r = VEC_index (eh_region, cfun->eh->region_array, -lp_nr);
1710 lp = VEC_index (eh_landing_pad, cfun->eh->lp_array, lp_nr);
1720 /* Return the landing pad to which INSN may go, or NULL if it does not
1721 have a reachable landing pad within this function. */
1724 get_eh_landing_pad_from_rtx (const_rtx insn)
1729 get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1733 /* Return the region to which INSN may go, or NULL if it does not
1734 have a reachable region within this function. */
1737 get_eh_region_from_rtx (const_rtx insn)
1742 get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1746 /* Return true if INSN throws and is caught by something in this function. */
1749 can_throw_internal (const_rtx insn)
1751 return get_eh_landing_pad_from_rtx (insn) != NULL;
1754 /* Return true if INSN throws and escapes from the current function. */
1757 can_throw_external (const_rtx insn)
1763 if (! INSN_P (insn))
1766 if (NONJUMP_INSN_P (insn)
1767 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1769 rtx seq = PATTERN (insn);
1770 int i, n = XVECLEN (seq, 0);
1772 for (i = 0; i < n; i++)
1773 if (can_throw_external (XVECEXP (seq, 0, i)))
1779 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1781 /* If we can't throw, we obviously can't throw external. */
1785 /* If we have an internal landing pad, then we're not external. */
1789 /* If we're not within an EH region, then we are external. */
1793 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1794 which don't always have landing pads. */
1795 gcc_assert (r->type == ERT_MUST_NOT_THROW);
1799 /* Return true if INSN cannot throw at all. */
1802 insn_nothrow_p (const_rtx insn)
1807 if (! INSN_P (insn))
1810 if (NONJUMP_INSN_P (insn)
1811 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1813 rtx seq = PATTERN (insn);
1814 int i, n = XVECLEN (seq, 0);
1816 for (i = 0; i < n; i++)
1817 if (!insn_nothrow_p (XVECEXP (seq, 0, i)))
1823 return get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1826 /* Return true if INSN can perform a non-local goto. */
1827 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1830 can_nonlocal_goto (const_rtx insn)
1832 if (nonlocal_goto_handler_labels && CALL_P (insn))
1834 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1835 if (!note || INTVAL (XEXP (note, 0)) != INT_MIN)
1841 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1844 set_nothrow_function_flags (void)
1850 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1851 something that can throw an exception. We specifically exempt
1852 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1853 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1856 crtl->all_throwers_are_sibcalls = 1;
1858 /* If we don't know that this implementation of the function will
1859 actually be used, then we must not set TREE_NOTHROW, since
1860 callers must not assume that this function does not throw. */
1861 if (TREE_NOTHROW (current_function_decl))
1864 if (! flag_exceptions)
1867 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1868 if (can_throw_external (insn))
1872 if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
1874 crtl->all_throwers_are_sibcalls = 0;
1879 for (insn = crtl->epilogue_delay_list; insn;
1880 insn = XEXP (insn, 1))
1881 if (can_throw_external (insn))
1885 if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
1887 crtl->all_throwers_are_sibcalls = 0;
1892 && (cgraph_function_body_availability (cgraph_node
1893 (current_function_decl))
1894 >= AVAIL_AVAILABLE))
1896 struct cgraph_node *node = cgraph_node (current_function_decl);
1897 struct cgraph_edge *e;
1898 for (e = node->callers; e; e = e->next_caller)
1899 e->can_throw_external = false;
1900 cgraph_set_nothrow_flag (node, true);
1903 fprintf (dump_file, "Marking function nothrow: %s\n\n",
1904 current_function_name ());
1909 struct rtl_opt_pass pass_set_nothrow_function_flags =
1913 "nothrow", /* name */
1915 set_nothrow_function_flags, /* execute */
1918 0, /* static_pass_number */
1919 TV_NONE, /* tv_id */
1920 0, /* properties_required */
1921 0, /* properties_provided */
1922 0, /* properties_destroyed */
1923 0, /* todo_flags_start */
1924 TODO_dump_func, /* todo_flags_finish */
1929 /* Various hooks for unwind library. */
1931 /* Expand the EH support builtin functions:
1932 __builtin_eh_pointer and __builtin_eh_filter. */
1935 expand_builtin_eh_common (tree region_nr_t)
1937 HOST_WIDE_INT region_nr;
1940 gcc_assert (host_integerp (region_nr_t, 0));
1941 region_nr = tree_low_cst (region_nr_t, 0);
1943 region = VEC_index (eh_region, cfun->eh->region_array, region_nr);
1945 /* ??? We shouldn't have been able to delete a eh region without
1946 deleting all the code that depended on it. */
1947 gcc_assert (region != NULL);
1952 /* Expand to the exc_ptr value from the given eh region. */
1955 expand_builtin_eh_pointer (tree exp)
1958 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
1959 if (region->exc_ptr_reg == NULL)
1960 region->exc_ptr_reg = gen_reg_rtx (ptr_mode);
1961 return region->exc_ptr_reg;
1964 /* Expand to the filter value from the given eh region. */
1967 expand_builtin_eh_filter (tree exp)
1970 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
1971 if (region->filter_reg == NULL)
1972 region->filter_reg = gen_reg_rtx (targetm.eh_return_filter_mode ());
1973 return region->filter_reg;
1976 /* Copy the exc_ptr and filter values from one landing pad's registers
1977 to another. This is used to inline the resx statement. */
1980 expand_builtin_eh_copy_values (tree exp)
1983 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
1985 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1));
1986 enum machine_mode fmode = targetm.eh_return_filter_mode ();
1988 if (dst->exc_ptr_reg == NULL)
1989 dst->exc_ptr_reg = gen_reg_rtx (ptr_mode);
1990 if (src->exc_ptr_reg == NULL)
1991 src->exc_ptr_reg = gen_reg_rtx (ptr_mode);
1993 if (dst->filter_reg == NULL)
1994 dst->filter_reg = gen_reg_rtx (fmode);
1995 if (src->filter_reg == NULL)
1996 src->filter_reg = gen_reg_rtx (fmode);
1998 emit_move_insn (dst->exc_ptr_reg, src->exc_ptr_reg);
1999 emit_move_insn (dst->filter_reg, src->filter_reg);
2004 /* Do any necessary initialization to access arbitrary stack frames.
2005 On the SPARC, this means flushing the register windows. */
2008 expand_builtin_unwind_init (void)
2010 /* Set this so all the registers get saved in our frame; we need to be
2011 able to copy the saved values for any registers from frames we unwind. */
2012 crtl->saves_all_registers = 1;
2014 #ifdef SETUP_FRAME_ADDRESSES
2015 SETUP_FRAME_ADDRESSES ();
2019 /* Map a non-negative number to an eh return data register number; expands
2020 to -1 if no return data register is associated with the input number.
2021 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2024 expand_builtin_eh_return_data_regno (tree exp)
2026 tree which = CALL_EXPR_ARG (exp, 0);
2027 unsigned HOST_WIDE_INT iwhich;
2029 if (TREE_CODE (which) != INTEGER_CST)
2031 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2035 iwhich = tree_low_cst (which, 1);
2036 iwhich = EH_RETURN_DATA_REGNO (iwhich);
2037 if (iwhich == INVALID_REGNUM)
2040 #ifdef DWARF_FRAME_REGNUM
2041 iwhich = DWARF_FRAME_REGNUM (iwhich);
2043 iwhich = DBX_REGISTER_NUMBER (iwhich);
2046 return GEN_INT (iwhich);
2049 /* Given a value extracted from the return address register or stack slot,
2050 return the actual address encoded in that value. */
2053 expand_builtin_extract_return_addr (tree addr_tree)
2055 rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
2057 if (GET_MODE (addr) != Pmode
2058 && GET_MODE (addr) != VOIDmode)
2060 #ifdef POINTERS_EXTEND_UNSIGNED
2061 addr = convert_memory_address (Pmode, addr);
2063 addr = convert_to_mode (Pmode, addr, 0);
2067 /* First mask out any unwanted bits. */
2068 #ifdef MASK_RETURN_ADDR
2069 expand_and (Pmode, addr, MASK_RETURN_ADDR, addr);
2072 /* Then adjust to find the real return address. */
2073 #if defined (RETURN_ADDR_OFFSET)
2074 addr = plus_constant (addr, RETURN_ADDR_OFFSET);
2080 /* Given an actual address in addr_tree, do any necessary encoding
2081 and return the value to be stored in the return address register or
2082 stack slot so the epilogue will return to that address. */
2085 expand_builtin_frob_return_addr (tree addr_tree)
2087 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
2089 addr = convert_memory_address (Pmode, addr);
2091 #ifdef RETURN_ADDR_OFFSET
2092 addr = force_reg (Pmode, addr);
2093 addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
2099 /* Set up the epilogue with the magic bits we'll need to return to the
2100 exception handler. */
2103 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED,
2108 #ifdef EH_RETURN_STACKADJ_RTX
2109 tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj,
2110 VOIDmode, EXPAND_NORMAL);
2111 tmp = convert_memory_address (Pmode, tmp);
2112 if (!crtl->eh.ehr_stackadj)
2113 crtl->eh.ehr_stackadj = copy_to_reg (tmp);
2114 else if (tmp != crtl->eh.ehr_stackadj)
2115 emit_move_insn (crtl->eh.ehr_stackadj, tmp);
2118 tmp = expand_expr (handler_tree, crtl->eh.ehr_handler,
2119 VOIDmode, EXPAND_NORMAL);
2120 tmp = convert_memory_address (Pmode, tmp);
2121 if (!crtl->eh.ehr_handler)
2122 crtl->eh.ehr_handler = copy_to_reg (tmp);
2123 else if (tmp != crtl->eh.ehr_handler)
2124 emit_move_insn (crtl->eh.ehr_handler, tmp);
2126 if (!crtl->eh.ehr_label)
2127 crtl->eh.ehr_label = gen_label_rtx ();
2128 emit_jump (crtl->eh.ehr_label);
2131 /* Expand __builtin_eh_return. This exit path from the function loads up
2132 the eh return data registers, adjusts the stack, and branches to a
2133 given PC other than the normal return address. */
2136 expand_eh_return (void)
2140 if (! crtl->eh.ehr_label)
2143 crtl->calls_eh_return = 1;
2145 #ifdef EH_RETURN_STACKADJ_RTX
2146 emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx);
2149 around_label = gen_label_rtx ();
2150 emit_jump (around_label);
2152 emit_label (crtl->eh.ehr_label);
2153 clobber_return_register ();
2155 #ifdef EH_RETURN_STACKADJ_RTX
2156 emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj);
2159 #ifdef HAVE_eh_return
2161 emit_insn (gen_eh_return (crtl->eh.ehr_handler));
2165 #ifdef EH_RETURN_HANDLER_RTX
2166 emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler);
2168 error ("__builtin_eh_return not supported on this target");
2172 emit_label (around_label);
2175 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2176 POINTERS_EXTEND_UNSIGNED and return it. */
2179 expand_builtin_extend_pointer (tree addr_tree)
2181 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
2184 #ifdef POINTERS_EXTEND_UNSIGNED
2185 extend = POINTERS_EXTEND_UNSIGNED;
2187 /* The previous EH code did an unsigned extend by default, so we do this also
2192 return convert_modes (targetm.unwind_word_mode (), ptr_mode, addr, extend);
2195 /* In the following functions, we represent entries in the action table
2196 as 1-based indices. Special cases are:
2198 0: null action record, non-null landing pad; implies cleanups
2199 -1: null action record, null landing pad; implies no action
2200 -2: no call-site entry; implies must_not_throw
2201 -3: we have yet to process outer regions
2203 Further, no special cases apply to the "next" field of the record.
2204 For next, 0 means end of list. */
2206 struct action_record
2214 action_record_eq (const void *pentry, const void *pdata)
2216 const struct action_record *entry = (const struct action_record *) pentry;
2217 const struct action_record *data = (const struct action_record *) pdata;
2218 return entry->filter == data->filter && entry->next == data->next;
2222 action_record_hash (const void *pentry)
2224 const struct action_record *entry = (const struct action_record *) pentry;
2225 return entry->next * 1009 + entry->filter;
2229 add_action_record (htab_t ar_hash, int filter, int next)
2231 struct action_record **slot, *new_ar, tmp;
2233 tmp.filter = filter;
2235 slot = (struct action_record **) htab_find_slot (ar_hash, &tmp, INSERT);
2237 if ((new_ar = *slot) == NULL)
2239 new_ar = XNEW (struct action_record);
2240 new_ar->offset = VEC_length (uchar, crtl->eh.action_record_data) + 1;
2241 new_ar->filter = filter;
2242 new_ar->next = next;
2245 /* The filter value goes in untouched. The link to the next
2246 record is a "self-relative" byte offset, or zero to indicate
2247 that there is no next record. So convert the absolute 1 based
2248 indices we've been carrying around into a displacement. */
2250 push_sleb128 (&crtl->eh.action_record_data, filter);
2252 next -= VEC_length (uchar, crtl->eh.action_record_data) + 1;
2253 push_sleb128 (&crtl->eh.action_record_data, next);
2256 return new_ar->offset;
2260 collect_one_action_chain (htab_t ar_hash, eh_region region)
2264 /* If we've reached the top of the region chain, then we have
2265 no actions, and require no landing pad. */
2269 switch (region->type)
2274 /* A cleanup adds a zero filter to the beginning of the chain, but
2275 there are special cases to look out for. If there are *only*
2276 cleanups along a path, then it compresses to a zero action.
2277 Further, if there are multiple cleanups along a path, we only
2278 need to represent one of them, as that is enough to trigger
2279 entry to the landing pad at runtime. */
2280 next = collect_one_action_chain (ar_hash, region->outer);
2283 for (r = region->outer; r ; r = r->outer)
2284 if (r->type == ERT_CLEANUP)
2286 return add_action_record (ar_hash, 0, next);
2293 /* Process the associated catch regions in reverse order.
2294 If there's a catch-all handler, then we don't need to
2295 search outer regions. Use a magic -3 value to record
2296 that we haven't done the outer search. */
2298 for (c = region->u.eh_try.last_catch; c ; c = c->prev_catch)
2300 if (c->type_list == NULL)
2302 /* Retrieve the filter from the head of the filter list
2303 where we have stored it (see assign_filter_values). */
2304 int filter = TREE_INT_CST_LOW (TREE_VALUE (c->filter_list));
2305 next = add_action_record (ar_hash, filter, 0);
2309 /* Once the outer search is done, trigger an action record for
2310 each filter we have. */
2315 next = collect_one_action_chain (ar_hash, region->outer);
2317 /* If there is no next action, terminate the chain. */
2320 /* If all outer actions are cleanups or must_not_throw,
2321 we'll have no action record for it, since we had wanted
2322 to encode these states in the call-site record directly.
2323 Add a cleanup action to the chain to catch these. */
2325 next = add_action_record (ar_hash, 0, 0);
2328 flt_node = c->filter_list;
2329 for (; flt_node; flt_node = TREE_CHAIN (flt_node))
2331 int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node));
2332 next = add_action_record (ar_hash, filter, next);
2339 case ERT_ALLOWED_EXCEPTIONS:
2340 /* An exception specification adds its filter to the
2341 beginning of the chain. */
2342 next = collect_one_action_chain (ar_hash, region->outer);
2344 /* If there is no next action, terminate the chain. */
2347 /* If all outer actions are cleanups or must_not_throw,
2348 we'll have no action record for it, since we had wanted
2349 to encode these states in the call-site record directly.
2350 Add a cleanup action to the chain to catch these. */
2352 next = add_action_record (ar_hash, 0, 0);
2354 return add_action_record (ar_hash, region->u.allowed.filter, next);
2356 case ERT_MUST_NOT_THROW:
2357 /* A must-not-throw region with no inner handlers or cleanups
2358 requires no call-site entry. Note that this differs from
2359 the no handler or cleanup case in that we do require an lsda
2360 to be generated. Return a magic -2 value to record this. */
2368 add_call_site (rtx landing_pad, int action, int section)
2370 call_site_record record;
2372 record = GGC_NEW (struct call_site_record_d);
2373 record->landing_pad = landing_pad;
2374 record->action = action;
2376 VEC_safe_push (call_site_record, gc,
2377 crtl->eh.call_site_record[section], record);
2379 return call_site_base + VEC_length (call_site_record,
2380 crtl->eh.call_site_record[section]) - 1;
2383 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2384 The new note numbers will not refer to region numbers, but
2385 instead to call site entries. */
2388 convert_to_eh_region_ranges (void)
2390 rtx insn, iter, note;
2392 int last_action = -3;
2393 rtx last_action_insn = NULL_RTX;
2394 rtx last_landing_pad = NULL_RTX;
2395 rtx first_no_action_insn = NULL_RTX;
2398 rtx section_switch_note = NULL_RTX;
2399 rtx first_no_action_insn_before_switch = NULL_RTX;
2400 rtx last_no_action_insn_before_switch = NULL_RTX;
2401 rtx *pad_map = NULL;
2402 sbitmap pad_loc = NULL;
2403 int min_labelno = 0, max_labelno = 0;
2404 int saved_call_site_base = call_site_base;
2406 crtl->eh.action_record_data = VEC_alloc (uchar, gc, 64);
2408 ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
2410 for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
2417 rtx this_landing_pad;
2420 if (NONJUMP_INSN_P (insn)
2421 && GET_CODE (PATTERN (insn)) == SEQUENCE)
2422 insn = XVECEXP (PATTERN (insn), 0, 0);
2424 nothrow = get_eh_region_and_lp_from_rtx (insn, ®ion, &lp);
2428 this_action = collect_one_action_chain (ar_hash, region);
2432 /* Existence of catch handlers, or must-not-throw regions
2433 implies that an lsda is needed (even if empty). */
2434 if (this_action != -1)
2435 crtl->uses_eh_lsda = 1;
2437 /* Delay creation of region notes for no-action regions
2438 until we're sure that an lsda will be required. */
2439 else if (last_action == -3)
2441 first_no_action_insn = iter;
2445 if (this_action >= 0)
2446 this_landing_pad = lp->landing_pad;
2448 this_landing_pad = NULL_RTX;
2450 /* Differing actions or landing pads implies a change in call-site
2451 info, which implies some EH_REGION note should be emitted. */
2452 if (last_action != this_action
2453 || last_landing_pad != this_landing_pad)
2455 /* If we'd not seen a previous action (-3) or the previous
2456 action was must-not-throw (-2), then we do not need an
2458 if (last_action >= -1)
2460 /* If we delayed the creation of the begin, do it now. */
2461 if (first_no_action_insn_before_switch)
2463 call_site = add_call_site (NULL_RTX, 0, 0);
2465 = emit_note_before (NOTE_INSN_EH_REGION_BEG,
2466 first_no_action_insn_before_switch);
2467 NOTE_EH_HANDLER (note) = call_site;
2468 if (first_no_action_insn)
2471 = emit_note_after (NOTE_INSN_EH_REGION_END,
2472 last_no_action_insn_before_switch);
2473 NOTE_EH_HANDLER (note) = call_site;
2476 gcc_assert (last_action_insn
2477 == last_no_action_insn_before_switch);
2479 if (first_no_action_insn)
2481 call_site = add_call_site (NULL_RTX, 0, cur_sec);
2482 note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
2483 first_no_action_insn);
2484 NOTE_EH_HANDLER (note) = call_site;
2485 first_no_action_insn = NULL_RTX;
2488 note = emit_note_after (NOTE_INSN_EH_REGION_END,
2490 NOTE_EH_HANDLER (note) = call_site;
2493 /* If the new action is must-not-throw, then no region notes
2495 if (this_action >= -1)
2497 call_site = add_call_site (this_landing_pad,
2498 this_action < 0 ? 0 : this_action,
2500 note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter);
2501 NOTE_EH_HANDLER (note) = call_site;
2504 last_action = this_action;
2505 last_landing_pad = this_landing_pad;
2507 last_action_insn = iter;
2509 else if (NOTE_P (iter)
2510 && NOTE_KIND (iter) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
2512 gcc_assert (section_switch_note == NULL_RTX);
2513 gcc_assert (flag_reorder_blocks_and_partition);
2514 section_switch_note = iter;
2515 if (first_no_action_insn)
2517 first_no_action_insn_before_switch = first_no_action_insn;
2518 last_no_action_insn_before_switch = last_action_insn;
2519 first_no_action_insn = NULL_RTX;
2520 gcc_assert (last_action == -1);
2523 /* Force closing of current EH region before section switch and
2524 opening a new one afterwards. */
2525 else if (last_action != -3)
2526 last_landing_pad = pc_rtx;
2527 call_site_base += VEC_length (call_site_record,
2528 crtl->eh.call_site_record[cur_sec]);
2530 gcc_assert (crtl->eh.call_site_record[cur_sec] == NULL);
2531 crtl->eh.call_site_record[cur_sec]
2532 = VEC_alloc (call_site_record, gc, 10);
2533 max_labelno = max_label_num ();
2534 min_labelno = get_first_label_num ();
2535 pad_map = XCNEWVEC (rtx, max_labelno - min_labelno + 1);
2536 pad_loc = sbitmap_alloc (max_labelno - min_labelno + 1);
2538 else if (LABEL_P (iter) && pad_map)
2539 SET_BIT (pad_loc, CODE_LABEL_NUMBER (iter) - min_labelno);
2541 if (last_action >= -1 && ! first_no_action_insn)
2543 note = emit_note_after (NOTE_INSN_EH_REGION_END, last_action_insn);
2544 NOTE_EH_HANDLER (note) = call_site;
2547 call_site_base = saved_call_site_base;
2551 /* When doing hot/cold partitioning, ensure landing pads are
2552 always in the same section as the EH region, .gcc_except_table
2553 can't express it otherwise. */
2554 for (cur_sec = 0; cur_sec < 2; cur_sec++)
2557 int n = VEC_length (call_site_record,
2558 crtl->eh.call_site_record[cur_sec]);
2559 basic_block prev_bb = NULL, padbb;
2561 for (i = 0; i < n; ++i)
2563 struct call_site_record_d *cs =
2564 VEC_index (call_site_record,
2565 crtl->eh.call_site_record[cur_sec], i);
2568 if (cs->landing_pad == NULL_RTX)
2570 idx = CODE_LABEL_NUMBER (cs->landing_pad) - min_labelno;
2571 /* If the landing pad is in the correct section, nothing
2573 if (TEST_BIT (pad_loc, idx) ^ (cur_sec == 0))
2575 /* Otherwise, if we haven't seen this pad yet, we need to
2576 add a new label and jump to the correct section. */
2577 if (pad_map[idx] == NULL_RTX)
2579 pad_map[idx] = gen_label_rtx ();
2580 if (prev_bb == NULL)
2581 for (iter = section_switch_note;
2582 iter; iter = PREV_INSN (iter))
2583 if (NOTE_INSN_BASIC_BLOCK_P (iter))
2585 prev_bb = NOTE_BASIC_BLOCK (iter);
2590 note = emit_label_before (pad_map[idx],
2591 section_switch_note);
2592 jump = emit_jump_insn_before (gen_jump (cs->landing_pad),
2593 section_switch_note);
2597 jump = emit_jump_insn_after (gen_jump (cs->landing_pad),
2598 section_switch_note);
2599 note = emit_label_after (pad_map[idx],
2600 section_switch_note);
2602 JUMP_LABEL (jump) = cs->landing_pad;
2603 add_reg_note (jump, REG_CROSSING_JUMP, NULL_RTX);
2604 iter = NEXT_INSN (cs->landing_pad);
2605 if (iter && NOTE_INSN_BASIC_BLOCK_P (iter))
2606 padbb = NOTE_BASIC_BLOCK (iter);
2609 if (padbb && prev_bb
2610 && BB_PARTITION (padbb) != BB_UNPARTITIONED)
2614 = BB_PARTITION (padbb) == BB_COLD_PARTITION
2615 ? BB_HOT_PARTITION : BB_COLD_PARTITION;
2619 bb = create_basic_block (note, jump, prev_bb);
2620 make_single_succ_edge (bb, padbb, EDGE_CROSSING);
2621 BB_SET_PARTITION (bb, part);
2622 for (ei = ei_start (padbb->preds);
2623 (e = ei_safe_edge (ei)); )
2625 if ((e->flags & (EDGE_EH|EDGE_CROSSING))
2626 == (EDGE_EH|EDGE_CROSSING))
2628 redirect_edge_succ (e, bb);
2629 e->flags &= ~EDGE_CROSSING;
2638 cs->landing_pad = pad_map[idx];
2642 sbitmap_free (pad_loc);
2643 XDELETEVEC (pad_map);
2646 htab_delete (ar_hash);
2651 gate_convert_to_eh_region_ranges (void)
2653 /* Nothing to do for SJLJ exceptions or if no regions created. */
2654 return !(USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL);
2657 struct rtl_opt_pass pass_convert_to_eh_region_ranges =
2661 "eh_ranges", /* name */
2662 gate_convert_to_eh_region_ranges, /* gate */
2663 convert_to_eh_region_ranges, /* execute */
2666 0, /* static_pass_number */
2667 TV_NONE, /* tv_id */
2668 0, /* properties_required */
2669 0, /* properties_provided */
2670 0, /* properties_destroyed */
2671 0, /* todo_flags_start */
2672 TODO_dump_func, /* todo_flags_finish */
2677 push_uleb128 (VEC (uchar, gc) **data_area, unsigned int value)
2681 unsigned char byte = value & 0x7f;
2685 VEC_safe_push (uchar, gc, *data_area, byte);
2691 push_sleb128 (VEC (uchar, gc) **data_area, int value)
2698 byte = value & 0x7f;
2700 more = ! ((value == 0 && (byte & 0x40) == 0)
2701 || (value == -1 && (byte & 0x40) != 0));
2704 VEC_safe_push (uchar, gc, *data_area, byte);
2710 #ifndef HAVE_AS_LEB128
2712 dw2_size_of_call_site_table (int section)
2714 int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]);
2715 int size = n * (4 + 4 + 4);
2718 for (i = 0; i < n; ++i)
2720 struct call_site_record_d *cs =
2721 VEC_index (call_site_record, crtl->eh.call_site_record[section], i);
2722 size += size_of_uleb128 (cs->action);
2729 sjlj_size_of_call_site_table (void)
2731 int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]);
2735 for (i = 0; i < n; ++i)
2737 struct call_site_record_d *cs =
2738 VEC_index (call_site_record, crtl->eh.call_site_record[0], i);
2739 size += size_of_uleb128 (INTVAL (cs->landing_pad));
2740 size += size_of_uleb128 (cs->action);
2748 dw2_output_call_site_table (int cs_format, int section)
2750 int n = VEC_length (call_site_record, crtl->eh.call_site_record[section]);
2755 begin = current_function_func_begin_label;
2756 else if (first_function_block_is_cold)
2757 begin = crtl->subsections.hot_section_label;
2759 begin = crtl->subsections.cold_section_label;
2761 for (i = 0; i < n; ++i)
2763 struct call_site_record_d *cs =
2764 VEC_index (call_site_record, crtl->eh.call_site_record[section], i);
2765 char reg_start_lab[32];
2766 char reg_end_lab[32];
2767 char landing_pad_lab[32];
2769 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab, "LEHB", call_site_base + i);
2770 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab, "LEHE", call_site_base + i);
2772 if (cs->landing_pad)
2773 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab, "L",
2774 CODE_LABEL_NUMBER (cs->landing_pad));
2776 /* ??? Perhaps use insn length scaling if the assembler supports
2777 generic arithmetic. */
2778 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2779 data4 if the function is small enough. */
2780 if (cs_format == DW_EH_PE_uleb128)
2782 dw2_asm_output_delta_uleb128 (reg_start_lab, begin,
2783 "region %d start", i);
2784 dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab,
2786 if (cs->landing_pad)
2787 dw2_asm_output_delta_uleb128 (landing_pad_lab, begin,
2790 dw2_asm_output_data_uleb128 (0, "landing pad");
2794 dw2_asm_output_delta (4, reg_start_lab, begin,
2795 "region %d start", i);
2796 dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length");
2797 if (cs->landing_pad)
2798 dw2_asm_output_delta (4, landing_pad_lab, begin,
2801 dw2_asm_output_data (4, 0, "landing pad");
2803 dw2_asm_output_data_uleb128 (cs->action, "action");
2806 call_site_base += n;
2810 sjlj_output_call_site_table (void)
2812 int n = VEC_length (call_site_record, crtl->eh.call_site_record[0]);
2815 for (i = 0; i < n; ++i)
2817 struct call_site_record_d *cs =
2818 VEC_index (call_site_record, crtl->eh.call_site_record[0], i);
2820 dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
2821 "region %d landing pad", i);
2822 dw2_asm_output_data_uleb128 (cs->action, "action");
2825 call_site_base += n;
2828 #ifndef TARGET_UNWIND_INFO
2829 /* Switch to the section that should be used for exception tables. */
2832 switch_to_exception_section (const char * ARG_UNUSED (fnname))
2836 if (exception_section)
2837 s = exception_section;
2840 /* Compute the section and cache it into exception_section,
2841 unless it depends on the function name. */
2842 if (targetm.have_named_sections)
2846 if (EH_TABLES_CAN_BE_READ_ONLY)
2849 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2850 flags = ((! flag_pic
2851 || ((tt_format & 0x70) != DW_EH_PE_absptr
2852 && (tt_format & 0x70) != DW_EH_PE_aligned))
2853 ? 0 : SECTION_WRITE);
2856 flags = SECTION_WRITE;
2858 #ifdef HAVE_LD_EH_GC_SECTIONS
2859 if (flag_function_sections)
2861 char *section_name = XNEWVEC (char, strlen (fnname) + 32);
2862 sprintf (section_name, ".gcc_except_table.%s", fnname);
2863 s = get_section (section_name, flags, NULL);
2864 free (section_name);
2869 = s = get_section (".gcc_except_table", flags, NULL);
2873 = s = flag_pic ? data_section : readonly_data_section;
2876 switch_to_section (s);
2881 /* Output a reference from an exception table to the type_info object TYPE.
2882 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2886 output_ttype (tree type, int tt_format, int tt_format_size)
2889 bool is_public = true;
2891 if (type == NULL_TREE)
2895 struct varpool_node *node;
2897 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2898 runtime types so TYPE should already be a runtime type
2899 reference. When pass_ipa_free_lang data is made a default
2900 pass, we can then remove the call to lookup_type_for_runtime
2903 type = lookup_type_for_runtime (type);
2905 value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2907 /* Let cgraph know that the rtti decl is used. Not all of the
2908 paths below go through assemble_integer, which would take
2909 care of this for us. */
2911 if (TREE_CODE (type) == ADDR_EXPR)
2913 type = TREE_OPERAND (type, 0);
2914 if (TREE_CODE (type) == VAR_DECL)
2916 node = varpool_node (type);
2918 varpool_mark_needed_node (node);
2919 is_public = TREE_PUBLIC (type);
2923 gcc_assert (TREE_CODE (type) == INTEGER_CST);
2926 /* Allow the target to override the type table entry format. */
2927 if (targetm.asm_out.ttype (value))
2930 if (tt_format == DW_EH_PE_absptr || tt_format == DW_EH_PE_aligned)
2931 assemble_integer (value, tt_format_size,
2932 tt_format_size * BITS_PER_UNIT, 1);
2934 dw2_asm_output_encoded_addr_rtx (tt_format, value, is_public, NULL);
2938 output_one_function_exception_table (const char * ARG_UNUSED (fnname),
2939 int section, rtx ARG_UNUSED (personality))
2941 int tt_format, cs_format, lp_format, i;
2942 #ifdef HAVE_AS_LEB128
2943 char ttype_label[32];
2944 char cs_after_size_label[32];
2945 char cs_end_label[32];
2950 int tt_format_size = 0;
2952 #ifdef TARGET_UNWIND_INFO
2953 /* TODO: Move this into target file. */
2954 fputs ("\t.personality\t", asm_out_file);
2955 output_addr_const (asm_out_file, personality);
2956 fputs ("\n\t.handlerdata\n", asm_out_file);
2957 /* Note that varasm still thinks we're in the function's code section.
2958 The ".endp" directive that will immediately follow will take us back. */
2960 switch_to_exception_section (fnname);
2963 /* If the target wants a label to begin the table, emit it here. */
2964 targetm.asm_out.except_table_label (asm_out_file);
2966 have_tt_data = (VEC_length (tree, cfun->eh->ttype_data)
2967 || (targetm.arm_eabi_unwinder
2968 ? VEC_length (tree, cfun->eh->ehspec_data.arm_eabi)
2969 : VEC_length (uchar, cfun->eh->ehspec_data.other)));
2971 /* Indicate the format of the @TType entries. */
2973 tt_format = DW_EH_PE_omit;
2976 tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2977 #ifdef HAVE_AS_LEB128
2978 ASM_GENERATE_INTERNAL_LABEL (ttype_label,
2979 section ? "LLSDATTC" : "LLSDATT",
2980 current_function_funcdef_no);
2982 tt_format_size = size_of_encoded_value (tt_format);
2984 assemble_align (tt_format_size * BITS_PER_UNIT);
2987 targetm.asm_out.internal_label (asm_out_file, section ? "LLSDAC" : "LLSDA",
2988 current_function_funcdef_no);
2990 /* The LSDA header. */
2992 /* Indicate the format of the landing pad start pointer. An omitted
2993 field implies @LPStart == @Start. */
2994 /* Currently we always put @LPStart == @Start. This field would
2995 be most useful in moving the landing pads completely out of
2996 line to another section, but it could also be used to minimize
2997 the size of uleb128 landing pad offsets. */
2998 lp_format = DW_EH_PE_omit;
2999 dw2_asm_output_data (1, lp_format, "@LPStart format (%s)",
3000 eh_data_format_name (lp_format));
3002 /* @LPStart pointer would go here. */
3004 dw2_asm_output_data (1, tt_format, "@TType format (%s)",
3005 eh_data_format_name (tt_format));
3007 #ifndef HAVE_AS_LEB128
3008 if (USING_SJLJ_EXCEPTIONS)
3009 call_site_len = sjlj_size_of_call_site_table ();
3011 call_site_len = dw2_size_of_call_site_table (section);
3014 /* A pc-relative 4-byte displacement to the @TType data. */
3017 #ifdef HAVE_AS_LEB128
3018 char ttype_after_disp_label[32];
3019 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label,
3020 section ? "LLSDATTDC" : "LLSDATTD",
3021 current_function_funcdef_no);
3022 dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
3023 "@TType base offset");
3024 ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label);
3026 /* Ug. Alignment queers things. */
3027 unsigned int before_disp, after_disp, last_disp, disp;
3029 before_disp = 1 + 1;
3030 after_disp = (1 + size_of_uleb128 (call_site_len)
3032 + VEC_length (uchar, crtl->eh.action_record_data)
3033 + (VEC_length (tree, cfun->eh->ttype_data)
3039 unsigned int disp_size, pad;
3042 disp_size = size_of_uleb128 (disp);
3043 pad = before_disp + disp_size + after_disp;
3044 if (pad % tt_format_size)
3045 pad = tt_format_size - (pad % tt_format_size);
3048 disp = after_disp + pad;
3050 while (disp != last_disp);
3052 dw2_asm_output_data_uleb128 (disp, "@TType base offset");
3056 /* Indicate the format of the call-site offsets. */
3057 #ifdef HAVE_AS_LEB128
3058 cs_format = DW_EH_PE_uleb128;
3060 cs_format = DW_EH_PE_udata4;
3062 dw2_asm_output_data (1, cs_format, "call-site format (%s)",
3063 eh_data_format_name (cs_format));
3065 #ifdef HAVE_AS_LEB128
3066 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label,
3067 section ? "LLSDACSBC" : "LLSDACSB",
3068 current_function_funcdef_no);
3069 ASM_GENERATE_INTERNAL_LABEL (cs_end_label,
3070 section ? "LLSDACSEC" : "LLSDACSE",
3071 current_function_funcdef_no);
3072 dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label,
3073 "Call-site table length");
3074 ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label);
3075 if (USING_SJLJ_EXCEPTIONS)
3076 sjlj_output_call_site_table ();
3078 dw2_output_call_site_table (cs_format, section);
3079 ASM_OUTPUT_LABEL (asm_out_file, cs_end_label);
3081 dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length");
3082 if (USING_SJLJ_EXCEPTIONS)
3083 sjlj_output_call_site_table ();
3085 dw2_output_call_site_table (cs_format, section);
3088 /* ??? Decode and interpret the data for flag_debug_asm. */
3091 for (i = 0; VEC_iterate (uchar, crtl->eh.action_record_data, i, uc); ++i)
3092 dw2_asm_output_data (1, uc, i ? NULL : "Action record table");
3096 assemble_align (tt_format_size * BITS_PER_UNIT);
3098 i = VEC_length (tree, cfun->eh->ttype_data);
3101 tree type = VEC_index (tree, cfun->eh->ttype_data, i);
3102 output_ttype (type, tt_format, tt_format_size);
3105 #ifdef HAVE_AS_LEB128
3107 ASM_OUTPUT_LABEL (asm_out_file, ttype_label);
3110 /* ??? Decode and interpret the data for flag_debug_asm. */
3111 if (targetm.arm_eabi_unwinder)
3115 VEC_iterate (tree, cfun->eh->ehspec_data.arm_eabi, i, type); ++i)
3116 output_ttype (type, tt_format, tt_format_size);
3122 VEC_iterate (uchar, cfun->eh->ehspec_data.other, i, uc); ++i)
3123 dw2_asm_output_data (1, uc,
3124 i ? NULL : "Exception specification table");
3129 output_function_exception_table (const char * ARG_UNUSED (fnname))
3131 rtx personality = get_personality_function (current_function_decl);
3133 /* Not all functions need anything. */
3134 if (! crtl->uses_eh_lsda)
3138 assemble_external_libcall (personality);
3140 output_one_function_exception_table (fnname, 0, personality);
3141 if (crtl->eh.call_site_record[1] != NULL)
3142 output_one_function_exception_table (fnname, 1, personality);
3144 switch_to_section (current_function_section ());
3148 set_eh_throw_stmt_table (struct function *fun, struct htab *table)
3150 fun->eh->throw_stmt_table = table;
3154 get_eh_throw_stmt_table (struct function *fun)
3156 return fun->eh->throw_stmt_table;
3159 /* Determine if the function needs an EH personality function. */
3161 enum eh_personality_kind
3162 function_needs_eh_personality (struct function *fn)
3164 enum eh_personality_kind kind = eh_personality_none;
3167 FOR_ALL_EH_REGION_FN (i, fn)
3172 /* Can do with any personality including the generic C one. */
3173 kind = eh_personality_any;
3177 case ERT_ALLOWED_EXCEPTIONS:
3178 /* Always needs a EH personality function. The generic C
3179 personality doesn't handle these even for empty type lists. */
3180 return eh_personality_lang;
3182 case ERT_MUST_NOT_THROW:
3183 /* Always needs a EH personality function. The language may specify
3184 what abort routine that must be used, e.g. std::terminate. */
3185 return eh_personality_lang;
3192 /* Dump EH information to OUT. */
3195 dump_eh_tree (FILE * out, struct function *fun)
3199 static const char *const type_name[] = {
3200 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3203 i = fun->eh->region_tree;
3207 fprintf (out, "Eh tree:\n");
3210 fprintf (out, " %*s %i %s", depth * 2, "",
3211 i->index, type_name[(int) i->type]);
3213 if (i->landing_pads)
3217 fprintf (out, " land:");
3218 if (current_ir_type () == IR_GIMPLE)
3220 for (lp = i->landing_pads; lp ; lp = lp->next_lp)
3222 fprintf (out, "{%i,", lp->index);
3223 print_generic_expr (out, lp->post_landing_pad, 0);
3231 for (lp = i->landing_pads; lp ; lp = lp->next_lp);
3233 fprintf (out, "{%i,", lp->index);
3234 if (lp->landing_pad)
3235 fprintf (out, "%i%s,", INSN_UID (lp->landing_pad),
3236 NOTE_P (lp->landing_pad) ? "(del)" : "");
3238 fprintf (out, "(nil),");
3239 if (lp->post_landing_pad)
3241 rtx lab = label_rtx (lp->post_landing_pad);
3242 fprintf (out, "%i%s}", INSN_UID (lab),
3243 NOTE_P (lab) ? "(del)" : "");
3246 fprintf (out, "(nil)}");
3256 case ERT_MUST_NOT_THROW:
3262 fprintf (out, " catch:");
3263 for (c = i->u.eh_try.first_catch; c; c = c->next_catch)
3268 fprintf (out, "lab:");
3269 print_generic_expr (out, c->label, 0);
3272 print_generic_expr (out, c->type_list, 0);
3280 case ERT_ALLOWED_EXCEPTIONS:
3281 fprintf (out, " filter :%i types:", i->u.allowed.filter);
3282 print_generic_expr (out, i->u.allowed.type_list, 0);
3287 /* If there are sub-regions, process them. */
3289 i = i->inner, depth++;
3290 /* If there are peers, process them. */
3291 else if (i->next_peer)
3293 /* Otherwise, step back up the tree to the next peer. */
3303 while (i->next_peer == NULL);
3309 /* Dump the EH tree for FN on stderr. */
3312 debug_eh_tree (struct function *fn)
3314 dump_eh_tree (stderr, fn);
3317 /* Verify invariants on EH datastructures. */
3320 verify_eh_tree (struct function *fun)
3323 int nvisited_lp, nvisited_r;
3324 int count_lp, count_r, depth, i;
3328 if (!fun->eh->region_tree)
3332 for (i = 1; VEC_iterate (eh_region, fun->eh->region_array, i, r); ++i)
3339 error ("region_array is corrupted for region %i", r->index);
3345 for (i = 1; VEC_iterate (eh_landing_pad, fun->eh->lp_array, i, lp); ++i)
3352 error ("lp_array is corrupted for lp %i", lp->index);
3357 depth = nvisited_lp = nvisited_r = 0;
3359 r = fun->eh->region_tree;
3362 if (VEC_index (eh_region, fun->eh->region_array, r->index) != r)
3364 error ("region_array is corrupted for region %i", r->index);
3367 if (r->outer != outer)
3369 error ("outer block of region %i is wrong", r->index);
3374 error ("negative nesting depth of region %i", r->index);
3379 for (lp = r->landing_pads; lp ; lp = lp->next_lp)
3381 if (VEC_index (eh_landing_pad, fun->eh->lp_array, lp->index) != lp)
3383 error ("lp_array is corrupted for lp %i", lp->index);
3386 if (lp->region != r)
3388 error ("region of lp %i is wrong", lp->index);
3395 outer = r, r = r->inner, depth++;
3396 else if (r->next_peer)
3408 while (r->next_peer == NULL);
3415 error ("tree list ends on depth %i", depth);
3418 if (count_r != nvisited_r)
3420 error ("region_array does not match region_tree");
3423 if (count_lp != nvisited_lp)
3425 error ("lp_array does not match region_tree");
3431 dump_eh_tree (stderr, fun);
3432 internal_error ("verify_eh_tree failed");
3436 #include "gt-except.h"