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 2011, 2012 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 eh_protect_cleanup_actions langhook 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 Then, via finish_eh_generation, 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 "common/common-target.h"
140 #include "langhooks.h"
142 #include "diagnostic.h"
143 #include "tree-pretty-print.h"
144 #include "tree-pass.h"
146 #include "tree-flow.h"
149 /* Provide defaults for stuff that may not be defined when using
151 #ifndef EH_RETURN_DATA_REGNO
152 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
155 static GTY(()) int call_site_base
;
156 static GTY ((param_is (union tree_node
)))
157 htab_t type_to_runtime_map
;
159 /* Describe the SjLj_Function_Context structure. */
160 static GTY(()) tree sjlj_fc_type_node
;
161 static int sjlj_fc_call_site_ofs
;
162 static int sjlj_fc_data_ofs
;
163 static int sjlj_fc_personality_ofs
;
164 static int sjlj_fc_lsda_ofs
;
165 static int sjlj_fc_jbuf_ofs
;
168 struct GTY(()) call_site_record_d
174 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
177 static int t2r_eq (const void *, const void *);
178 static hashval_t
t2r_hash (const void *);
180 static int ttypes_filter_eq (const void *, const void *);
181 static hashval_t
ttypes_filter_hash (const void *);
182 static int ehspec_filter_eq (const void *, const void *);
183 static hashval_t
ehspec_filter_hash (const void *);
184 static int add_ttypes_entry (htab_t
, tree
);
185 static int add_ehspec_entry (htab_t
, htab_t
, tree
);
186 static void dw2_build_landing_pads (void);
188 static int action_record_eq (const void *, const void *);
189 static hashval_t
action_record_hash (const void *);
190 static int add_action_record (htab_t
, int, int);
191 static int collect_one_action_chain (htab_t
, eh_region
);
192 static int add_call_site (rtx
, int, int);
194 static void push_uleb128 (VEC (uchar
, gc
) **, unsigned int);
195 static void push_sleb128 (VEC (uchar
, gc
) **, int);
196 #ifndef HAVE_AS_LEB128
197 static int dw2_size_of_call_site_table (int);
198 static int sjlj_size_of_call_site_table (void);
200 static void dw2_output_call_site_table (int, int);
201 static void sjlj_output_call_site_table (void);
207 if (! flag_exceptions
)
210 type_to_runtime_map
= htab_create_ggc (31, t2r_hash
, t2r_eq
, NULL
);
212 /* Create the SjLj_Function_Context structure. This should match
213 the definition in unwind-sjlj.c. */
214 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
216 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
218 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
220 f_prev
= build_decl (BUILTINS_LOCATION
,
221 FIELD_DECL
, get_identifier ("__prev"),
222 build_pointer_type (sjlj_fc_type_node
));
223 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
225 f_cs
= build_decl (BUILTINS_LOCATION
,
226 FIELD_DECL
, get_identifier ("__call_site"),
228 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
230 tmp
= build_index_type (size_int (4 - 1));
231 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
232 (targetm
.unwind_word_mode (), 1),
234 f_data
= build_decl (BUILTINS_LOCATION
,
235 FIELD_DECL
, get_identifier ("__data"), tmp
);
236 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
238 f_per
= build_decl (BUILTINS_LOCATION
,
239 FIELD_DECL
, get_identifier ("__personality"),
241 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
243 f_lsda
= build_decl (BUILTINS_LOCATION
,
244 FIELD_DECL
, get_identifier ("__lsda"),
246 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
248 #ifdef DONT_USE_BUILTIN_SETJMP
250 tmp
= size_int (JMP_BUF_SIZE
- 1);
252 /* Should be large enough for most systems, if it is not,
253 JMP_BUF_SIZE should be defined with the proper value. It will
254 also tend to be larger than necessary for most systems, a more
255 optimal port will define JMP_BUF_SIZE. */
256 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
259 /* builtin_setjmp takes a pointer to 5 words. */
260 tmp
= size_int (5 * BITS_PER_WORD
/ POINTER_SIZE
- 1);
262 tmp
= build_index_type (tmp
);
263 tmp
= build_array_type (ptr_type_node
, tmp
);
264 f_jbuf
= build_decl (BUILTINS_LOCATION
,
265 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
266 #ifdef DONT_USE_BUILTIN_SETJMP
267 /* We don't know what the alignment requirements of the
268 runtime's jmp_buf has. Overestimate. */
269 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
270 DECL_USER_ALIGN (f_jbuf
) = 1;
272 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
274 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
275 TREE_CHAIN (f_prev
) = f_cs
;
276 TREE_CHAIN (f_cs
) = f_data
;
277 TREE_CHAIN (f_data
) = f_per
;
278 TREE_CHAIN (f_per
) = f_lsda
;
279 TREE_CHAIN (f_lsda
) = f_jbuf
;
281 layout_type (sjlj_fc_type_node
);
283 /* Cache the interesting field offsets so that we have
284 easy access from rtl. */
285 sjlj_fc_call_site_ofs
286 = (tree_low_cst (DECL_FIELD_OFFSET (f_cs
), 1)
287 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs
), 1) / BITS_PER_UNIT
);
289 = (tree_low_cst (DECL_FIELD_OFFSET (f_data
), 1)
290 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data
), 1) / BITS_PER_UNIT
);
291 sjlj_fc_personality_ofs
292 = (tree_low_cst (DECL_FIELD_OFFSET (f_per
), 1)
293 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per
), 1) / BITS_PER_UNIT
);
295 = (tree_low_cst (DECL_FIELD_OFFSET (f_lsda
), 1)
296 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda
), 1) / BITS_PER_UNIT
);
298 = (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf
), 1)
299 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf
), 1) / BITS_PER_UNIT
);
304 init_eh_for_function (void)
306 cfun
->eh
= ggc_alloc_cleared_eh_status ();
308 /* Make sure zero'th entries are used. */
309 VEC_safe_push (eh_region
, gc
, cfun
->eh
->region_array
, NULL
);
310 VEC_safe_push (eh_landing_pad
, gc
, cfun
->eh
->lp_array
, NULL
);
313 /* Routines to generate the exception tree somewhat directly.
314 These are used from tree-eh.c when processing exception related
315 nodes during tree optimization. */
318 gen_eh_region (enum eh_region_type type
, eh_region outer
)
322 /* Insert a new blank region as a leaf in the tree. */
323 new_eh
= ggc_alloc_cleared_eh_region_d ();
325 new_eh
->outer
= outer
;
328 new_eh
->next_peer
= outer
->inner
;
329 outer
->inner
= new_eh
;
333 new_eh
->next_peer
= cfun
->eh
->region_tree
;
334 cfun
->eh
->region_tree
= new_eh
;
337 new_eh
->index
= VEC_length (eh_region
, cfun
->eh
->region_array
);
338 VEC_safe_push (eh_region
, gc
, cfun
->eh
->region_array
, new_eh
);
340 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
341 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
342 new_eh
->use_cxa_end_cleanup
= true;
348 gen_eh_region_cleanup (eh_region outer
)
350 return gen_eh_region (ERT_CLEANUP
, outer
);
354 gen_eh_region_try (eh_region outer
)
356 return gen_eh_region (ERT_TRY
, outer
);
360 gen_eh_region_catch (eh_region t
, tree type_or_list
)
363 tree type_list
, type_node
;
365 gcc_assert (t
->type
== ERT_TRY
);
367 /* Ensure to always end up with a type list to normalize further
368 processing, then register each type against the runtime types map. */
369 type_list
= type_or_list
;
372 if (TREE_CODE (type_or_list
) != TREE_LIST
)
373 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
375 type_node
= type_list
;
376 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
377 add_type_for_runtime (TREE_VALUE (type_node
));
380 c
= ggc_alloc_cleared_eh_catch_d ();
381 c
->type_list
= type_list
;
382 l
= t
->u
.eh_try
.last_catch
;
387 t
->u
.eh_try
.first_catch
= c
;
388 t
->u
.eh_try
.last_catch
= c
;
394 gen_eh_region_allowed (eh_region outer
, tree allowed
)
396 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
397 region
->u
.allowed
.type_list
= allowed
;
399 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
400 add_type_for_runtime (TREE_VALUE (allowed
));
406 gen_eh_region_must_not_throw (eh_region outer
)
408 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
412 gen_eh_landing_pad (eh_region region
)
414 eh_landing_pad lp
= ggc_alloc_cleared_eh_landing_pad_d ();
416 lp
->next_lp
= region
->landing_pads
;
418 lp
->index
= VEC_length (eh_landing_pad
, cfun
->eh
->lp_array
);
419 region
->landing_pads
= lp
;
421 VEC_safe_push (eh_landing_pad
, gc
, cfun
->eh
->lp_array
, lp
);
427 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
429 return VEC_index (eh_region
, ifun
->eh
->region_array
, i
);
433 get_eh_region_from_number (int i
)
435 return get_eh_region_from_number_fn (cfun
, i
);
439 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
441 return VEC_index (eh_landing_pad
, ifun
->eh
->lp_array
, i
);
445 get_eh_landing_pad_from_number (int i
)
447 return get_eh_landing_pad_from_number_fn (cfun
, i
);
451 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
454 return VEC_index (eh_region
, ifun
->eh
->region_array
, -i
);
460 lp
= VEC_index (eh_landing_pad
, ifun
->eh
->lp_array
, i
);
466 get_eh_region_from_lp_number (int i
)
468 return get_eh_region_from_lp_number_fn (cfun
, i
);
471 /* Returns true if the current function has exception handling regions. */
474 current_function_has_exception_handlers (void)
476 return cfun
->eh
->region_tree
!= NULL
;
479 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
480 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
482 struct duplicate_eh_regions_data
484 duplicate_eh_regions_map label_map
;
485 void *label_map_data
;
486 struct pointer_map_t
*eh_map
;
490 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
491 eh_region old_r
, eh_region outer
)
493 eh_landing_pad old_lp
, new_lp
;
497 new_r
= gen_eh_region (old_r
->type
, outer
);
498 slot
= pointer_map_insert (data
->eh_map
, (void *)old_r
);
499 gcc_assert (*slot
== NULL
);
500 *slot
= (void *)new_r
;
510 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
512 /* We should be doing all our region duplication before and
513 during inlining, which is before filter lists are created. */
514 gcc_assert (oc
->filter_list
== NULL
);
515 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
516 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
521 case ERT_ALLOWED_EXCEPTIONS
:
522 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
523 if (old_r
->u
.allowed
.label
)
524 new_r
->u
.allowed
.label
525 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
527 new_r
->u
.allowed
.label
= NULL_TREE
;
530 case ERT_MUST_NOT_THROW
:
531 new_r
->u
.must_not_throw
= old_r
->u
.must_not_throw
;
535 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
537 /* Don't bother copying unused landing pads. */
538 if (old_lp
->post_landing_pad
== NULL
)
541 new_lp
= gen_eh_landing_pad (new_r
);
542 slot
= pointer_map_insert (data
->eh_map
, (void *)old_lp
);
543 gcc_assert (*slot
== NULL
);
544 *slot
= (void *)new_lp
;
546 new_lp
->post_landing_pad
547 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
548 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
551 /* Make sure to preserve the original use of __cxa_end_cleanup. */
552 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
554 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
555 duplicate_eh_regions_1 (data
, old_r
, new_r
);
558 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
559 the current function and root the tree below OUTER_REGION.
560 The special case of COPY_REGION of NULL means all regions.
561 Remap labels using MAP/MAP_DATA callback. Return a pointer map
562 that allows the caller to remap uses of both EH regions and
565 struct pointer_map_t
*
566 duplicate_eh_regions (struct function
*ifun
,
567 eh_region copy_region
, int outer_lp
,
568 duplicate_eh_regions_map map
, void *map_data
)
570 struct duplicate_eh_regions_data data
;
571 eh_region outer_region
;
573 #ifdef ENABLE_CHECKING
574 verify_eh_tree (ifun
);
577 data
.label_map
= map
;
578 data
.label_map_data
= map_data
;
579 data
.eh_map
= pointer_map_create ();
581 outer_region
= get_eh_region_from_lp_number (outer_lp
);
583 /* Copy all the regions in the subtree. */
585 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
589 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
590 duplicate_eh_regions_1 (&data
, r
, outer_region
);
593 #ifdef ENABLE_CHECKING
594 verify_eh_tree (cfun
);
600 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
603 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
608 gcc_assert (ifun
->eh
->region_array
);
609 gcc_assert (ifun
->eh
->region_tree
);
611 b_outer
= sbitmap_alloc (VEC_length (eh_region
, ifun
->eh
->region_array
));
612 sbitmap_zero (b_outer
);
616 SET_BIT (b_outer
, region_b
->index
);
617 region_b
= region_b
->outer
;
623 if (TEST_BIT (b_outer
, region_a
->index
))
625 region_a
= region_a
->outer
;
629 sbitmap_free (b_outer
);
634 t2r_eq (const void *pentry
, const void *pdata
)
636 const_tree
const entry
= (const_tree
) pentry
;
637 const_tree
const data
= (const_tree
) pdata
;
639 return TREE_PURPOSE (entry
) == data
;
643 t2r_hash (const void *pentry
)
645 const_tree
const entry
= (const_tree
) pentry
;
646 return TREE_HASH (TREE_PURPOSE (entry
));
650 add_type_for_runtime (tree type
)
654 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
655 if (TREE_CODE (type
) == NOP_EXPR
)
658 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
659 TREE_HASH (type
), INSERT
);
662 tree runtime
= lang_hooks
.eh_runtime_type (type
);
663 *slot
= tree_cons (type
, runtime
, NULL_TREE
);
668 lookup_type_for_runtime (tree type
)
672 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
673 if (TREE_CODE (type
) == NOP_EXPR
)
676 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
677 TREE_HASH (type
), NO_INSERT
);
679 /* We should have always inserted the data earlier. */
680 return TREE_VALUE (*slot
);
684 /* Represent an entry in @TTypes for either catch actions
685 or exception filter actions. */
686 struct ttypes_filter
{
691 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
692 (a tree) for a @TTypes type node we are thinking about adding. */
695 ttypes_filter_eq (const void *pentry
, const void *pdata
)
697 const struct ttypes_filter
*const entry
698 = (const struct ttypes_filter
*) pentry
;
699 const_tree
const data
= (const_tree
) pdata
;
701 return entry
->t
== data
;
705 ttypes_filter_hash (const void *pentry
)
707 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
708 return TREE_HASH (entry
->t
);
711 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
712 exception specification list we are thinking about adding. */
713 /* ??? Currently we use the type lists in the order given. Someone
714 should put these in some canonical order. */
717 ehspec_filter_eq (const void *pentry
, const void *pdata
)
719 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
720 const struct ttypes_filter
*data
= (const struct ttypes_filter
*) pdata
;
722 return type_list_equal (entry
->t
, data
->t
);
725 /* Hash function for exception specification lists. */
728 ehspec_filter_hash (const void *pentry
)
730 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
734 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
735 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
739 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
740 to speed up the search. Return the filter value to be used. */
743 add_ttypes_entry (htab_t ttypes_hash
, tree type
)
745 struct ttypes_filter
**slot
, *n
;
747 slot
= (struct ttypes_filter
**)
748 htab_find_slot_with_hash (ttypes_hash
, type
, TREE_HASH (type
), INSERT
);
750 if ((n
= *slot
) == NULL
)
752 /* Filter value is a 1 based table index. */
754 n
= XNEW (struct ttypes_filter
);
756 n
->filter
= VEC_length (tree
, cfun
->eh
->ttype_data
) + 1;
759 VEC_safe_push (tree
, gc
, cfun
->eh
->ttype_data
, type
);
765 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
766 to speed up the search. Return the filter value to be used. */
769 add_ehspec_entry (htab_t ehspec_hash
, htab_t ttypes_hash
, tree list
)
771 struct ttypes_filter
**slot
, *n
;
772 struct ttypes_filter dummy
;
775 slot
= (struct ttypes_filter
**)
776 htab_find_slot (ehspec_hash
, &dummy
, INSERT
);
778 if ((n
= *slot
) == NULL
)
782 if (targetm
.arm_eabi_unwinder
)
783 len
= VEC_length (tree
, cfun
->eh
->ehspec_data
.arm_eabi
);
785 len
= VEC_length (uchar
, cfun
->eh
->ehspec_data
.other
);
787 /* Filter value is a -1 based byte index into a uleb128 buffer. */
789 n
= XNEW (struct ttypes_filter
);
791 n
->filter
= -(len
+ 1);
794 /* Generate a 0 terminated list of filter values. */
795 for (; list
; list
= TREE_CHAIN (list
))
797 if (targetm
.arm_eabi_unwinder
)
798 VEC_safe_push (tree
, gc
, cfun
->eh
->ehspec_data
.arm_eabi
,
802 /* Look up each type in the list and encode its filter
803 value as a uleb128. */
804 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
805 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
808 if (targetm
.arm_eabi_unwinder
)
809 VEC_safe_push (tree
, gc
, cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
811 VEC_safe_push (uchar
, gc
, cfun
->eh
->ehspec_data
.other
, 0);
817 /* Generate the action filter values to be used for CATCH and
818 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
819 we use lots of landing pads, and so every type or list can share
820 the same filter value, which saves table space. */
823 assign_filter_values (void)
826 htab_t ttypes
, ehspec
;
830 cfun
->eh
->ttype_data
= VEC_alloc (tree
, gc
, 16);
831 if (targetm
.arm_eabi_unwinder
)
832 cfun
->eh
->ehspec_data
.arm_eabi
= VEC_alloc (tree
, gc
, 64);
834 cfun
->eh
->ehspec_data
.other
= VEC_alloc (uchar
, gc
, 64);
836 ttypes
= htab_create (31, ttypes_filter_hash
, ttypes_filter_eq
, free
);
837 ehspec
= htab_create (31, ehspec_filter_hash
, ehspec_filter_eq
, free
);
839 for (i
= 1; VEC_iterate (eh_region
, cfun
->eh
->region_array
, i
, r
); ++i
)
847 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
849 /* Whatever type_list is (NULL or true list), we build a list
850 of filters for the region. */
851 c
->filter_list
= NULL_TREE
;
853 if (c
->type_list
!= NULL
)
855 /* Get a filter value for each of the types caught and store
856 them in the region's dedicated list. */
857 tree tp_node
= c
->type_list
;
859 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
861 int flt
= add_ttypes_entry (ttypes
, TREE_VALUE (tp_node
));
862 tree flt_node
= build_int_cst (integer_type_node
, flt
);
865 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
870 /* Get a filter value for the NULL list also since it
871 will need an action record anyway. */
872 int flt
= add_ttypes_entry (ttypes
, NULL
);
873 tree flt_node
= build_int_cst (integer_type_node
, flt
);
876 = tree_cons (NULL_TREE
, flt_node
, NULL
);
881 case ERT_ALLOWED_EXCEPTIONS
:
883 = add_ehspec_entry (ehspec
, ttypes
, r
->u
.allowed
.type_list
);
891 htab_delete (ttypes
);
892 htab_delete (ehspec
);
895 /* Emit SEQ into basic block just before INSN (that is assumed to be
896 first instruction of some existing BB and return the newly
899 emit_to_new_bb_before (rtx seq
, rtx insn
)
902 basic_block bb
, prev_bb
;
906 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
907 call), we don't want it to go into newly created landing pad or other EH
909 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
910 if (e
->flags
& EDGE_FALLTHRU
)
911 force_nonfallthru (e
);
914 last
= emit_insn_before (seq
, insn
);
915 if (BARRIER_P (last
))
916 last
= PREV_INSN (last
);
917 prev_bb
= BLOCK_FOR_INSN (insn
)->prev_bb
;
918 bb
= create_basic_block (seq
, last
, prev_bb
);
919 update_bb_for_insn (bb
);
920 bb
->flags
|= BB_SUPERBLOCK
;
924 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
925 at the rtl level. Emit the code required by the target at a landing
926 pad for the given region. */
929 expand_dw2_landing_pad_for_region (eh_region region
)
931 #ifdef HAVE_exception_receiver
932 if (HAVE_exception_receiver
)
933 emit_insn (gen_exception_receiver ());
936 #ifdef HAVE_nonlocal_goto_receiver
937 if (HAVE_nonlocal_goto_receiver
)
938 emit_insn (gen_nonlocal_goto_receiver ());
943 if (region
->exc_ptr_reg
)
944 emit_move_insn (region
->exc_ptr_reg
,
945 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
946 if (region
->filter_reg
)
947 emit_move_insn (region
->filter_reg
,
948 gen_rtx_REG (targetm
.eh_return_filter_mode (),
949 EH_RETURN_DATA_REGNO (1)));
952 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
955 dw2_build_landing_pads (void)
959 int e_flags
= EDGE_FALLTHRU
;
961 /* If we're going to partition blocks, we need to be able to add
962 new landing pads later, which means that we need to hold on to
963 the post-landing-pad block. Prevent it from being merged away.
964 We'll remove this bit after partitioning. */
965 if (flag_reorder_blocks_and_partition
)
966 e_flags
|= EDGE_PRESERVE
;
968 for (i
= 1; VEC_iterate (eh_landing_pad
, cfun
->eh
->lp_array
, i
, lp
); ++i
)
974 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
979 lp
->landing_pad
= gen_label_rtx ();
980 emit_label (lp
->landing_pad
);
981 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
983 expand_dw2_landing_pad_for_region (lp
->region
);
988 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
989 e
= make_edge (bb
, bb
->next_bb
, e_flags
);
990 e
->count
= bb
->count
;
991 e
->probability
= REG_BR_PROB_BASE
;
994 struct loop
*loop
= bb
->next_bb
->loop_father
;
995 /* If we created a pre-header block, add the new block to the
996 outer loop, otherwise to the loop itself. */
997 if (bb
->next_bb
== loop
->header
)
998 add_bb_to_loop (bb
, loop_outer (loop
));
1000 add_bb_to_loop (bb
, loop
);
1006 static VEC (int, heap
) *sjlj_lp_call_site_index
;
1008 /* Process all active landing pads. Assign each one a compact dispatch
1009 index, and a call-site index. */
1012 sjlj_assign_call_site_values (void)
1018 crtl
->eh
.action_record_data
= VEC_alloc (uchar
, gc
, 64);
1019 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
1023 for (i
= 1; VEC_iterate (eh_landing_pad
, cfun
->eh
->lp_array
, i
, lp
); ++i
)
1024 if (lp
&& lp
->post_landing_pad
)
1026 int action
, call_site
;
1028 /* First: build the action table. */
1029 action
= collect_one_action_chain (ar_hash
, lp
->region
);
1031 /* Next: assign call-site values. If dwarf2 terms, this would be
1032 the region number assigned by convert_to_eh_region_ranges, but
1033 handles no-action and must-not-throw differently. */
1034 /* Map must-not-throw to otherwise unused call-site index 0. */
1037 /* Map no-action to otherwise unused call-site index -1. */
1038 else if (action
== -1)
1040 /* Otherwise, look it up in the table. */
1042 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1043 VEC_replace (int, sjlj_lp_call_site_index
, i
, call_site
);
1048 htab_delete (ar_hash
);
1053 /* Emit code to record the current call-site index before every
1054 insn that can throw. */
1057 sjlj_mark_call_sites (void)
1059 int last_call_site
= -2;
1062 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1070 /* Reset value tracking at extended basic block boundaries. */
1072 last_call_site
= -2;
1074 if (! INSN_P (insn
))
1077 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1081 this_call_site
= VEC_index (int, sjlj_lp_call_site_index
, lp
->index
);
1084 /* Calls (and trapping insns) without notes are outside any
1085 exception handling region in this function. Mark them as
1087 this_call_site
= -1;
1091 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1095 if (this_call_site
!= -1)
1096 crtl
->uses_eh_lsda
= 1;
1098 if (this_call_site
== last_call_site
)
1101 /* Don't separate a call from it's argument loads. */
1104 before
= find_first_parameter_load (insn
, NULL_RTX
);
1107 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1108 sjlj_fc_call_site_ofs
);
1109 emit_move_insn (mem
, GEN_INT (this_call_site
));
1113 emit_insn_before (p
, before
);
1114 last_call_site
= this_call_site
;
1118 /* Construct the SjLj_Function_Context. */
1121 sjlj_emit_function_enter (rtx dispatch_label
)
1123 rtx fn_begin
, fc
, mem
, seq
;
1124 bool fn_begin_outside_block
;
1125 rtx personality
= get_personality_function (current_function_decl
);
1127 fc
= crtl
->eh
.sjlj_fc
;
1131 /* We're storing this libcall's address into memory instead of
1132 calling it directly. Thus, we must call assemble_external_libcall
1133 here, as we can not depend on emit_library_call to do it for us. */
1134 assemble_external_libcall (personality
);
1135 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1136 emit_move_insn (mem
, personality
);
1138 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1139 if (crtl
->uses_eh_lsda
)
1144 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1145 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1146 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1147 emit_move_insn (mem
, sym
);
1150 emit_move_insn (mem
, const0_rtx
);
1154 #ifdef DONT_USE_BUILTIN_SETJMP
1156 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1157 TYPE_MODE (integer_type_node
), 1,
1158 plus_constant (XEXP (fc
, 0),
1159 sjlj_fc_jbuf_ofs
), Pmode
);
1161 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1162 TYPE_MODE (integer_type_node
), 0,
1164 last
= get_last_insn ();
1165 if (JUMP_P (last
) && any_condjump_p (last
))
1167 gcc_assert (!find_reg_note (last
, REG_BR_PROB
, 0));
1168 add_reg_note (last
, REG_BR_PROB
, GEN_INT (REG_BR_PROB_BASE
/ 100));
1171 expand_builtin_setjmp_setup (plus_constant (XEXP (fc
, 0),
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
, t
;
1319 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1320 t
= build_int_cst (integer_type_node
, disp_index
);
1321 case_elt
= build_case_label (t
, NULL
, t_label
);
1322 gimple_switch_set_label (switch_stmt
, disp_index
, case_elt
);
1324 label
= label_rtx (t_label
);
1327 label
= gen_label_rtx ();
1329 if (disp_index
== 0)
1330 first_reachable_label
= label
;
1335 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1337 emit_move_insn (r
->filter_reg
, filter_reg
);
1339 seq2
= get_insns ();
1342 before
= label_rtx (lp
->post_landing_pad
);
1343 bb
= emit_to_new_bb_before (seq2
, before
);
1344 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1345 e
->count
= bb
->count
;
1346 e
->probability
= REG_BR_PROB_BASE
;
1350 gcc_assert (disp_index
== num_dispatch
);
1352 if (num_dispatch
> 1)
1354 expand_case (switch_stmt
);
1355 expand_builtin_trap ();
1361 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1362 if (num_dispatch
== 1)
1364 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1365 e
->count
= bb
->count
;
1366 e
->probability
= REG_BR_PROB_BASE
;
1371 sjlj_build_landing_pads (void)
1375 num_dispatch
= VEC_length (eh_landing_pad
, cfun
->eh
->lp_array
);
1376 if (num_dispatch
== 0)
1378 VEC_safe_grow (int, heap
, sjlj_lp_call_site_index
, num_dispatch
);
1380 num_dispatch
= sjlj_assign_call_site_values ();
1381 if (num_dispatch
> 0)
1383 rtx dispatch_label
= gen_label_rtx ();
1384 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1385 TYPE_MODE (sjlj_fc_type_node
),
1386 TYPE_ALIGN (sjlj_fc_type_node
));
1388 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1389 int_size_in_bytes (sjlj_fc_type_node
),
1392 sjlj_mark_call_sites ();
1393 sjlj_emit_function_enter (dispatch_label
);
1394 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1395 sjlj_emit_function_exit ();
1398 /* If we do not have any landing pads, we may still need to register a
1399 personality routine and (empty) LSDA to handle must-not-throw regions. */
1400 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
1402 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1403 TYPE_MODE (sjlj_fc_type_node
),
1404 TYPE_ALIGN (sjlj_fc_type_node
));
1406 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1407 int_size_in_bytes (sjlj_fc_type_node
),
1410 sjlj_mark_call_sites ();
1411 sjlj_emit_function_enter (NULL_RTX
);
1412 sjlj_emit_function_exit ();
1415 VEC_free (int, heap
, sjlj_lp_call_site_index
);
1418 /* After initial rtl generation, call back to finish generating
1419 exception support code. */
1422 finish_eh_generation (void)
1426 /* Construct the landing pads. */
1427 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1428 sjlj_build_landing_pads ();
1430 dw2_build_landing_pads ();
1431 break_superblocks ();
1433 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1434 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1435 || single_succ_edge (ENTRY_BLOCK_PTR
)->insns
.r
)
1436 commit_edge_insertions ();
1438 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1445 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1447 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1448 if (e
->flags
& EDGE_EH
)
1451 /* We should not have generated any new throwing insns during this
1452 pass, and we should not have lost any EH edges, so we only need
1453 to handle two cases here:
1454 (1) reachable handler and an existing edge to post-landing-pad,
1455 (2) no reachable handler and no edge. */
1456 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1459 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1461 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1462 e
->flags
|= (CALL_P (BB_END (bb
))
1463 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1469 /* This section handles removing dead code for flow. */
1472 remove_eh_landing_pad (eh_landing_pad lp
)
1476 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1480 if (lp
->post_landing_pad
)
1481 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1482 VEC_replace (eh_landing_pad
, cfun
->eh
->lp_array
, lp
->index
, NULL
);
1485 /* Splice REGION from the region tree. */
1488 remove_eh_handler (eh_region region
)
1490 eh_region
*pp
, *pp_start
, p
, outer
;
1493 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1495 if (lp
->post_landing_pad
)
1496 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1497 VEC_replace (eh_landing_pad
, cfun
->eh
->lp_array
, lp
->index
, NULL
);
1500 outer
= region
->outer
;
1502 pp_start
= &outer
->inner
;
1504 pp_start
= &cfun
->eh
->region_tree
;
1505 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1509 *pp
= p
= region
->inner
;
1518 *pp
= region
->next_peer
;
1520 VEC_replace (eh_region
, cfun
->eh
->region_array
, region
->index
, NULL
);
1523 /* Invokes CALLBACK for every exception handler landing pad label.
1524 Only used by reload hackery; should not be used by new code. */
1527 for_each_eh_label (void (*callback
) (rtx
))
1532 for (i
= 1; VEC_iterate (eh_landing_pad
, cfun
->eh
->lp_array
, i
, lp
); ++i
)
1536 rtx lab
= lp
->landing_pad
;
1537 if (lab
&& LABEL_P (lab
))
1543 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1546 At the gimple level, we use LP_NR
1547 > 0 : The statement transfers to landing pad LP_NR
1548 = 0 : The statement is outside any EH region
1549 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1551 At the rtl level, we use LP_NR
1552 > 0 : The insn transfers to landing pad LP_NR
1553 = 0 : The insn cannot throw
1554 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1555 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1556 missing note: The insn is outside any EH region.
1558 ??? This difference probably ought to be avoided. We could stand
1559 to record nothrow for arbitrary gimple statements, and so avoid
1560 some moderately complex lookups in stmt_could_throw_p. Perhaps
1561 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1562 no-nonlocal-goto property should be recorded elsewhere as a bit
1563 on the call_insn directly. Perhaps we should make more use of
1564 attaching the trees to call_insns (reachable via symbol_ref in
1565 direct call cases) and just pull the data out of the trees. */
1568 make_reg_eh_region_note (rtx insn
, int ecf_flags
, int lp_nr
)
1571 if (ecf_flags
& ECF_NOTHROW
)
1573 else if (lp_nr
!= 0)
1574 value
= GEN_INT (lp_nr
);
1577 add_reg_note (insn
, REG_EH_REGION
, value
);
1580 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1581 nor perform a non-local goto. Replace the region note if it
1585 make_reg_eh_region_note_nothrow_nononlocal (rtx insn
)
1587 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1588 rtx intmin
= GEN_INT (INT_MIN
);
1591 XEXP (note
, 0) = intmin
;
1593 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1596 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1600 insn_could_throw_p (const_rtx insn
)
1602 if (!flag_exceptions
)
1606 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1607 return may_trap_p (PATTERN (insn
));
1611 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1612 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1613 to look for a note, or the note itself. */
1616 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx first
, rtx last
)
1618 rtx insn
, note
= note_or_insn
;
1620 if (INSN_P (note_or_insn
))
1622 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1626 note
= XEXP (note
, 0);
1628 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1629 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1630 && insn_could_throw_p (insn
))
1631 add_reg_note (insn
, REG_EH_REGION
, note
);
1634 /* Likewise, but iterate backward. */
1637 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx last
, rtx first
)
1639 rtx insn
, note
= note_or_insn
;
1641 if (INSN_P (note_or_insn
))
1643 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1647 note
= XEXP (note
, 0);
1649 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1650 if (insn_could_throw_p (insn
))
1651 add_reg_note (insn
, REG_EH_REGION
, note
);
1655 /* Extract all EH information from INSN. Return true if the insn
1656 was marked NOTHROW. */
1659 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1660 eh_landing_pad
*plp
)
1662 eh_landing_pad lp
= NULL
;
1668 if (! INSN_P (insn
))
1671 if (NONJUMP_INSN_P (insn
)
1672 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1673 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1675 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1678 ret
= !insn_could_throw_p (insn
);
1682 lp_nr
= INTVAL (XEXP (note
, 0));
1683 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1690 r
= VEC_index (eh_region
, cfun
->eh
->region_array
, -lp_nr
);
1693 lp
= VEC_index (eh_landing_pad
, cfun
->eh
->lp_array
, lp_nr
);
1703 /* Return the landing pad to which INSN may go, or NULL if it does not
1704 have a reachable landing pad within this function. */
1707 get_eh_landing_pad_from_rtx (const_rtx insn
)
1712 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1716 /* Return the region to which INSN may go, or NULL if it does not
1717 have a reachable region within this function. */
1720 get_eh_region_from_rtx (const_rtx insn
)
1725 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1729 /* Return true if INSN throws and is caught by something in this function. */
1732 can_throw_internal (const_rtx insn
)
1734 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1737 /* Return true if INSN throws and escapes from the current function. */
1740 can_throw_external (const_rtx insn
)
1746 if (! INSN_P (insn
))
1749 if (NONJUMP_INSN_P (insn
)
1750 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1752 rtx seq
= PATTERN (insn
);
1753 int i
, n
= XVECLEN (seq
, 0);
1755 for (i
= 0; i
< n
; i
++)
1756 if (can_throw_external (XVECEXP (seq
, 0, i
)))
1762 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1764 /* If we can't throw, we obviously can't throw external. */
1768 /* If we have an internal landing pad, then we're not external. */
1772 /* If we're not within an EH region, then we are external. */
1776 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1777 which don't always have landing pads. */
1778 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1782 /* Return true if INSN cannot throw at all. */
1785 insn_nothrow_p (const_rtx insn
)
1790 if (! INSN_P (insn
))
1793 if (NONJUMP_INSN_P (insn
)
1794 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1796 rtx seq
= PATTERN (insn
);
1797 int i
, n
= XVECLEN (seq
, 0);
1799 for (i
= 0; i
< n
; i
++)
1800 if (!insn_nothrow_p (XVECEXP (seq
, 0, i
)))
1806 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1809 /* Return true if INSN can perform a non-local goto. */
1810 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1813 can_nonlocal_goto (const_rtx insn
)
1815 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1817 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1818 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1824 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1827 set_nothrow_function_flags (void)
1833 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1834 something that can throw an exception. We specifically exempt
1835 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1836 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1839 crtl
->all_throwers_are_sibcalls
= 1;
1841 /* If we don't know that this implementation of the function will
1842 actually be used, then we must not set TREE_NOTHROW, since
1843 callers must not assume that this function does not throw. */
1844 if (TREE_NOTHROW (current_function_decl
))
1847 if (! flag_exceptions
)
1850 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1851 if (can_throw_external (insn
))
1855 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1857 crtl
->all_throwers_are_sibcalls
= 0;
1862 for (insn
= crtl
->epilogue_delay_list
; insn
;
1863 insn
= XEXP (insn
, 1))
1864 if (can_throw_external (insn
))
1868 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1870 crtl
->all_throwers_are_sibcalls
= 0;
1875 && (cgraph_function_body_availability (cgraph_get_node
1876 (current_function_decl
))
1877 >= AVAIL_AVAILABLE
))
1879 struct cgraph_node
*node
= cgraph_get_node (current_function_decl
);
1880 struct cgraph_edge
*e
;
1881 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1882 e
->can_throw_external
= false;
1883 cgraph_set_nothrow_flag (node
, true);
1886 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
1887 current_function_name ());
1892 struct rtl_opt_pass pass_set_nothrow_function_flags
=
1896 "nothrow", /* name */
1898 set_nothrow_function_flags
, /* execute */
1901 0, /* static_pass_number */
1902 TV_NONE
, /* tv_id */
1903 0, /* properties_required */
1904 0, /* properties_provided */
1905 0, /* properties_destroyed */
1906 0, /* todo_flags_start */
1907 0 /* todo_flags_finish */
1912 /* Various hooks for unwind library. */
1914 /* Expand the EH support builtin functions:
1915 __builtin_eh_pointer and __builtin_eh_filter. */
1918 expand_builtin_eh_common (tree region_nr_t
)
1920 HOST_WIDE_INT region_nr
;
1923 gcc_assert (host_integerp (region_nr_t
, 0));
1924 region_nr
= tree_low_cst (region_nr_t
, 0);
1926 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, region_nr
);
1928 /* ??? We shouldn't have been able to delete a eh region without
1929 deleting all the code that depended on it. */
1930 gcc_assert (region
!= NULL
);
1935 /* Expand to the exc_ptr value from the given eh region. */
1938 expand_builtin_eh_pointer (tree exp
)
1941 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
1942 if (region
->exc_ptr_reg
== NULL
)
1943 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
1944 return region
->exc_ptr_reg
;
1947 /* Expand to the filter value from the given eh region. */
1950 expand_builtin_eh_filter (tree exp
)
1953 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
1954 if (region
->filter_reg
== NULL
)
1955 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
1956 return region
->filter_reg
;
1959 /* Copy the exc_ptr and filter values from one landing pad's registers
1960 to another. This is used to inline the resx statement. */
1963 expand_builtin_eh_copy_values (tree exp
)
1966 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
1968 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
1969 enum machine_mode fmode
= targetm
.eh_return_filter_mode ();
1971 if (dst
->exc_ptr_reg
== NULL
)
1972 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
1973 if (src
->exc_ptr_reg
== NULL
)
1974 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
1976 if (dst
->filter_reg
== NULL
)
1977 dst
->filter_reg
= gen_reg_rtx (fmode
);
1978 if (src
->filter_reg
== NULL
)
1979 src
->filter_reg
= gen_reg_rtx (fmode
);
1981 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
1982 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
1987 /* Do any necessary initialization to access arbitrary stack frames.
1988 On the SPARC, this means flushing the register windows. */
1991 expand_builtin_unwind_init (void)
1993 /* Set this so all the registers get saved in our frame; we need to be
1994 able to copy the saved values for any registers from frames we unwind. */
1995 crtl
->saves_all_registers
= 1;
1997 #ifdef SETUP_FRAME_ADDRESSES
1998 SETUP_FRAME_ADDRESSES ();
2002 /* Map a non-negative number to an eh return data register number; expands
2003 to -1 if no return data register is associated with the input number.
2004 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2007 expand_builtin_eh_return_data_regno (tree exp
)
2009 tree which
= CALL_EXPR_ARG (exp
, 0);
2010 unsigned HOST_WIDE_INT iwhich
;
2012 if (TREE_CODE (which
) != INTEGER_CST
)
2014 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2018 iwhich
= tree_low_cst (which
, 1);
2019 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2020 if (iwhich
== INVALID_REGNUM
)
2023 #ifdef DWARF_FRAME_REGNUM
2024 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2026 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2029 return GEN_INT (iwhich
);
2032 /* Given a value extracted from the return address register or stack slot,
2033 return the actual address encoded in that value. */
2036 expand_builtin_extract_return_addr (tree addr_tree
)
2038 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2040 if (GET_MODE (addr
) != Pmode
2041 && GET_MODE (addr
) != VOIDmode
)
2043 #ifdef POINTERS_EXTEND_UNSIGNED
2044 addr
= convert_memory_address (Pmode
, addr
);
2046 addr
= convert_to_mode (Pmode
, addr
, 0);
2050 /* First mask out any unwanted bits. */
2051 #ifdef MASK_RETURN_ADDR
2052 expand_and (Pmode
, addr
, MASK_RETURN_ADDR
, addr
);
2055 /* Then adjust to find the real return address. */
2056 #if defined (RETURN_ADDR_OFFSET)
2057 addr
= plus_constant (addr
, RETURN_ADDR_OFFSET
);
2063 /* Given an actual address in addr_tree, do any necessary encoding
2064 and return the value to be stored in the return address register or
2065 stack slot so the epilogue will return to that address. */
2068 expand_builtin_frob_return_addr (tree addr_tree
)
2070 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2072 addr
= convert_memory_address (Pmode
, addr
);
2074 #ifdef RETURN_ADDR_OFFSET
2075 addr
= force_reg (Pmode
, addr
);
2076 addr
= plus_constant (addr
, -RETURN_ADDR_OFFSET
);
2082 /* Set up the epilogue with the magic bits we'll need to return to the
2083 exception handler. */
2086 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2091 #ifdef EH_RETURN_STACKADJ_RTX
2092 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2093 VOIDmode
, EXPAND_NORMAL
);
2094 tmp
= convert_memory_address (Pmode
, tmp
);
2095 if (!crtl
->eh
.ehr_stackadj
)
2096 crtl
->eh
.ehr_stackadj
= copy_to_reg (tmp
);
2097 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2098 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2101 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2102 VOIDmode
, EXPAND_NORMAL
);
2103 tmp
= convert_memory_address (Pmode
, tmp
);
2104 if (!crtl
->eh
.ehr_handler
)
2105 crtl
->eh
.ehr_handler
= copy_to_reg (tmp
);
2106 else if (tmp
!= crtl
->eh
.ehr_handler
)
2107 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2109 if (!crtl
->eh
.ehr_label
)
2110 crtl
->eh
.ehr_label
= gen_label_rtx ();
2111 emit_jump (crtl
->eh
.ehr_label
);
2114 /* Expand __builtin_eh_return. This exit path from the function loads up
2115 the eh return data registers, adjusts the stack, and branches to a
2116 given PC other than the normal return address. */
2119 expand_eh_return (void)
2123 if (! crtl
->eh
.ehr_label
)
2126 crtl
->calls_eh_return
= 1;
2128 #ifdef EH_RETURN_STACKADJ_RTX
2129 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2132 around_label
= gen_label_rtx ();
2133 emit_jump (around_label
);
2135 emit_label (crtl
->eh
.ehr_label
);
2136 clobber_return_register ();
2138 #ifdef EH_RETURN_STACKADJ_RTX
2139 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2142 #ifdef HAVE_eh_return
2144 emit_insn (gen_eh_return (crtl
->eh
.ehr_handler
));
2148 #ifdef EH_RETURN_HANDLER_RTX
2149 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2151 error ("__builtin_eh_return not supported on this target");
2155 emit_label (around_label
);
2158 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2159 POINTERS_EXTEND_UNSIGNED and return it. */
2162 expand_builtin_extend_pointer (tree addr_tree
)
2164 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2167 #ifdef POINTERS_EXTEND_UNSIGNED
2168 extend
= POINTERS_EXTEND_UNSIGNED
;
2170 /* The previous EH code did an unsigned extend by default, so we do this also
2175 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2178 /* In the following functions, we represent entries in the action table
2179 as 1-based indices. Special cases are:
2181 0: null action record, non-null landing pad; implies cleanups
2182 -1: null action record, null landing pad; implies no action
2183 -2: no call-site entry; implies must_not_throw
2184 -3: we have yet to process outer regions
2186 Further, no special cases apply to the "next" field of the record.
2187 For next, 0 means end of list. */
2189 struct action_record
2197 action_record_eq (const void *pentry
, const void *pdata
)
2199 const struct action_record
*entry
= (const struct action_record
*) pentry
;
2200 const struct action_record
*data
= (const struct action_record
*) pdata
;
2201 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
2205 action_record_hash (const void *pentry
)
2207 const struct action_record
*entry
= (const struct action_record
*) pentry
;
2208 return entry
->next
* 1009 + entry
->filter
;
2212 add_action_record (htab_t ar_hash
, int filter
, int next
)
2214 struct action_record
**slot
, *new_ar
, tmp
;
2216 tmp
.filter
= filter
;
2218 slot
= (struct action_record
**) htab_find_slot (ar_hash
, &tmp
, INSERT
);
2220 if ((new_ar
= *slot
) == NULL
)
2222 new_ar
= XNEW (struct action_record
);
2223 new_ar
->offset
= VEC_length (uchar
, crtl
->eh
.action_record_data
) + 1;
2224 new_ar
->filter
= filter
;
2225 new_ar
->next
= next
;
2228 /* The filter value goes in untouched. The link to the next
2229 record is a "self-relative" byte offset, or zero to indicate
2230 that there is no next record. So convert the absolute 1 based
2231 indices we've been carrying around into a displacement. */
2233 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2235 next
-= VEC_length (uchar
, crtl
->eh
.action_record_data
) + 1;
2236 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2239 return new_ar
->offset
;
2243 collect_one_action_chain (htab_t ar_hash
, eh_region region
)
2247 /* If we've reached the top of the region chain, then we have
2248 no actions, and require no landing pad. */
2252 switch (region
->type
)
2257 /* A cleanup adds a zero filter to the beginning of the chain, but
2258 there are special cases to look out for. If there are *only*
2259 cleanups along a path, then it compresses to a zero action.
2260 Further, if there are multiple cleanups along a path, we only
2261 need to represent one of them, as that is enough to trigger
2262 entry to the landing pad at runtime. */
2263 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2266 for (r
= region
->outer
; r
; r
= r
->outer
)
2267 if (r
->type
== ERT_CLEANUP
)
2269 return add_action_record (ar_hash
, 0, next
);
2276 /* Process the associated catch regions in reverse order.
2277 If there's a catch-all handler, then we don't need to
2278 search outer regions. Use a magic -3 value to record
2279 that we haven't done the outer search. */
2281 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2283 if (c
->type_list
== NULL
)
2285 /* Retrieve the filter from the head of the filter list
2286 where we have stored it (see assign_filter_values). */
2287 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2288 next
= add_action_record (ar_hash
, filter
, 0);
2292 /* Once the outer search is done, trigger an action record for
2293 each filter we have. */
2298 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2300 /* If there is no next action, terminate the chain. */
2303 /* If all outer actions are cleanups or must_not_throw,
2304 we'll have no action record for it, since we had wanted
2305 to encode these states in the call-site record directly.
2306 Add a cleanup action to the chain to catch these. */
2308 next
= add_action_record (ar_hash
, 0, 0);
2311 flt_node
= c
->filter_list
;
2312 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2314 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2315 next
= add_action_record (ar_hash
, filter
, next
);
2322 case ERT_ALLOWED_EXCEPTIONS
:
2323 /* An exception specification adds its filter to the
2324 beginning of the chain. */
2325 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2327 /* If there is no next action, terminate the chain. */
2330 /* If all outer actions are cleanups or must_not_throw,
2331 we'll have no action record for it, since we had wanted
2332 to encode these states in the call-site record directly.
2333 Add a cleanup action to the chain to catch these. */
2335 next
= add_action_record (ar_hash
, 0, 0);
2337 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2339 case ERT_MUST_NOT_THROW
:
2340 /* A must-not-throw region with no inner handlers or cleanups
2341 requires no call-site entry. Note that this differs from
2342 the no handler or cleanup case in that we do require an lsda
2343 to be generated. Return a magic -2 value to record this. */
2351 add_call_site (rtx landing_pad
, int action
, int section
)
2353 call_site_record record
;
2355 record
= ggc_alloc_call_site_record_d ();
2356 record
->landing_pad
= landing_pad
;
2357 record
->action
= action
;
2359 VEC_safe_push (call_site_record
, gc
,
2360 crtl
->eh
.call_site_record
[section
], record
);
2362 return call_site_base
+ VEC_length (call_site_record
,
2363 crtl
->eh
.call_site_record
[section
]) - 1;
2366 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2367 The new note numbers will not refer to region numbers, but
2368 instead to call site entries. */
2371 convert_to_eh_region_ranges (void)
2373 rtx insn
, iter
, note
;
2375 int last_action
= -3;
2376 rtx last_action_insn
= NULL_RTX
;
2377 rtx last_landing_pad
= NULL_RTX
;
2378 rtx first_no_action_insn
= NULL_RTX
;
2381 rtx section_switch_note
= NULL_RTX
;
2382 rtx first_no_action_insn_before_switch
= NULL_RTX
;
2383 rtx last_no_action_insn_before_switch
= NULL_RTX
;
2384 int saved_call_site_base
= call_site_base
;
2386 crtl
->eh
.action_record_data
= VEC_alloc (uchar
, gc
, 64);
2388 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
2390 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2397 rtx this_landing_pad
;
2400 if (NONJUMP_INSN_P (insn
)
2401 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2402 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2404 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2408 this_action
= collect_one_action_chain (ar_hash
, region
);
2412 /* Existence of catch handlers, or must-not-throw regions
2413 implies that an lsda is needed (even if empty). */
2414 if (this_action
!= -1)
2415 crtl
->uses_eh_lsda
= 1;
2417 /* Delay creation of region notes for no-action regions
2418 until we're sure that an lsda will be required. */
2419 else if (last_action
== -3)
2421 first_no_action_insn
= iter
;
2425 if (this_action
>= 0)
2426 this_landing_pad
= lp
->landing_pad
;
2428 this_landing_pad
= NULL_RTX
;
2430 /* Differing actions or landing pads implies a change in call-site
2431 info, which implies some EH_REGION note should be emitted. */
2432 if (last_action
!= this_action
2433 || last_landing_pad
!= this_landing_pad
)
2435 /* If there is a queued no-action region in the other section
2436 with hot/cold partitioning, emit it now. */
2437 if (first_no_action_insn_before_switch
)
2439 gcc_assert (this_action
!= -1
2440 && last_action
== (first_no_action_insn
2442 call_site
= add_call_site (NULL_RTX
, 0, 0);
2443 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2444 first_no_action_insn_before_switch
);
2445 NOTE_EH_HANDLER (note
) = call_site
;
2446 note
= emit_note_after (NOTE_INSN_EH_REGION_END
,
2447 last_no_action_insn_before_switch
);
2448 NOTE_EH_HANDLER (note
) = call_site
;
2449 gcc_assert (last_action
!= -3
2450 || (last_action_insn
2451 == last_no_action_insn_before_switch
));
2452 first_no_action_insn_before_switch
= NULL_RTX
;
2453 last_no_action_insn_before_switch
= NULL_RTX
;
2456 /* If we'd not seen a previous action (-3) or the previous
2457 action was must-not-throw (-2), then we do not need an
2459 if (last_action
>= -1)
2461 /* If we delayed the creation of the begin, do it now. */
2462 if (first_no_action_insn
)
2464 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2465 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2466 first_no_action_insn
);
2467 NOTE_EH_HANDLER (note
) = call_site
;
2468 first_no_action_insn
= NULL_RTX
;
2471 note
= emit_note_after (NOTE_INSN_EH_REGION_END
,
2473 NOTE_EH_HANDLER (note
) = call_site
;
2476 /* If the new action is must-not-throw, then no region notes
2478 if (this_action
>= -1)
2480 call_site
= add_call_site (this_landing_pad
,
2481 this_action
< 0 ? 0 : this_action
,
2483 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2484 NOTE_EH_HANDLER (note
) = call_site
;
2487 last_action
= this_action
;
2488 last_landing_pad
= this_landing_pad
;
2490 last_action_insn
= iter
;
2492 else if (NOTE_P (iter
)
2493 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2495 gcc_assert (section_switch_note
== NULL_RTX
);
2496 gcc_assert (flag_reorder_blocks_and_partition
);
2497 section_switch_note
= iter
;
2498 if (first_no_action_insn
)
2500 first_no_action_insn_before_switch
= first_no_action_insn
;
2501 last_no_action_insn_before_switch
= last_action_insn
;
2502 first_no_action_insn
= NULL_RTX
;
2503 gcc_assert (last_action
== -1);
2506 /* Force closing of current EH region before section switch and
2507 opening a new one afterwards. */
2508 else if (last_action
!= -3)
2509 last_landing_pad
= pc_rtx
;
2510 call_site_base
+= VEC_length (call_site_record
,
2511 crtl
->eh
.call_site_record
[cur_sec
]);
2513 gcc_assert (crtl
->eh
.call_site_record
[cur_sec
] == NULL
);
2514 crtl
->eh
.call_site_record
[cur_sec
]
2515 = VEC_alloc (call_site_record
, gc
, 10);
2518 if (last_action
>= -1 && ! first_no_action_insn
)
2520 note
= emit_note_after (NOTE_INSN_EH_REGION_END
, last_action_insn
);
2521 NOTE_EH_HANDLER (note
) = call_site
;
2524 call_site_base
= saved_call_site_base
;
2526 htab_delete (ar_hash
);
2531 gate_convert_to_eh_region_ranges (void)
2533 /* Nothing to do for SJLJ exceptions or if no regions created. */
2534 if (cfun
->eh
->region_tree
== NULL
)
2536 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2541 struct rtl_opt_pass pass_convert_to_eh_region_ranges
=
2545 "eh_ranges", /* name */
2546 gate_convert_to_eh_region_ranges
, /* gate */
2547 convert_to_eh_region_ranges
, /* execute */
2550 0, /* static_pass_number */
2551 TV_NONE
, /* tv_id */
2552 0, /* properties_required */
2553 0, /* properties_provided */
2554 0, /* properties_destroyed */
2555 0, /* todo_flags_start */
2556 0 /* todo_flags_finish */
2561 push_uleb128 (VEC (uchar
, gc
) **data_area
, unsigned int value
)
2565 unsigned char byte
= value
& 0x7f;
2569 VEC_safe_push (uchar
, gc
, *data_area
, byte
);
2575 push_sleb128 (VEC (uchar
, gc
) **data_area
, int value
)
2582 byte
= value
& 0x7f;
2584 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2585 || (value
== -1 && (byte
& 0x40) != 0));
2588 VEC_safe_push (uchar
, gc
, *data_area
, byte
);
2594 #ifndef HAVE_AS_LEB128
2596 dw2_size_of_call_site_table (int section
)
2598 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
[section
]);
2599 int size
= n
* (4 + 4 + 4);
2602 for (i
= 0; i
< n
; ++i
)
2604 struct call_site_record_d
*cs
=
2605 VEC_index (call_site_record
, crtl
->eh
.call_site_record
[section
], i
);
2606 size
+= size_of_uleb128 (cs
->action
);
2613 sjlj_size_of_call_site_table (void)
2615 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
[0]);
2619 for (i
= 0; i
< n
; ++i
)
2621 struct call_site_record_d
*cs
=
2622 VEC_index (call_site_record
, crtl
->eh
.call_site_record
[0], i
);
2623 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2624 size
+= size_of_uleb128 (cs
->action
);
2632 dw2_output_call_site_table (int cs_format
, int section
)
2634 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
[section
]);
2639 begin
= current_function_func_begin_label
;
2640 else if (first_function_block_is_cold
)
2641 begin
= crtl
->subsections
.hot_section_label
;
2643 begin
= crtl
->subsections
.cold_section_label
;
2645 for (i
= 0; i
< n
; ++i
)
2647 struct call_site_record_d
*cs
=
2648 VEC_index (call_site_record
, crtl
->eh
.call_site_record
[section
], i
);
2649 char reg_start_lab
[32];
2650 char reg_end_lab
[32];
2651 char landing_pad_lab
[32];
2653 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2654 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2656 if (cs
->landing_pad
)
2657 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2658 CODE_LABEL_NUMBER (cs
->landing_pad
));
2660 /* ??? Perhaps use insn length scaling if the assembler supports
2661 generic arithmetic. */
2662 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2663 data4 if the function is small enough. */
2664 if (cs_format
== DW_EH_PE_uleb128
)
2666 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2667 "region %d start", i
);
2668 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2670 if (cs
->landing_pad
)
2671 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2674 dw2_asm_output_data_uleb128 (0, "landing pad");
2678 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2679 "region %d start", i
);
2680 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2681 if (cs
->landing_pad
)
2682 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2685 dw2_asm_output_data (4, 0, "landing pad");
2687 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2690 call_site_base
+= n
;
2694 sjlj_output_call_site_table (void)
2696 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
[0]);
2699 for (i
= 0; i
< n
; ++i
)
2701 struct call_site_record_d
*cs
=
2702 VEC_index (call_site_record
, crtl
->eh
.call_site_record
[0], i
);
2704 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2705 "region %d landing pad", i
);
2706 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2709 call_site_base
+= n
;
2712 /* Switch to the section that should be used for exception tables. */
2715 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2719 if (exception_section
)
2720 s
= exception_section
;
2723 /* Compute the section and cache it into exception_section,
2724 unless it depends on the function name. */
2725 if (targetm_common
.have_named_sections
)
2729 if (EH_TABLES_CAN_BE_READ_ONLY
)
2732 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2733 flags
= ((! flag_pic
2734 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2735 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2736 ? 0 : SECTION_WRITE
);
2739 flags
= SECTION_WRITE
;
2741 #ifdef HAVE_LD_EH_GC_SECTIONS
2742 if (flag_function_sections
)
2744 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2745 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2746 s
= get_section (section_name
, flags
, NULL
);
2747 free (section_name
);
2752 = s
= get_section (".gcc_except_table", flags
, NULL
);
2756 = s
= flag_pic
? data_section
: readonly_data_section
;
2759 switch_to_section (s
);
2763 /* Output a reference from an exception table to the type_info object TYPE.
2764 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2768 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2771 bool is_public
= true;
2773 if (type
== NULL_TREE
)
2777 struct varpool_node
*node
;
2779 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2780 runtime types so TYPE should already be a runtime type
2781 reference. When pass_ipa_free_lang data is made a default
2782 pass, we can then remove the call to lookup_type_for_runtime
2785 type
= lookup_type_for_runtime (type
);
2787 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2789 /* Let cgraph know that the rtti decl is used. Not all of the
2790 paths below go through assemble_integer, which would take
2791 care of this for us. */
2793 if (TREE_CODE (type
) == ADDR_EXPR
)
2795 type
= TREE_OPERAND (type
, 0);
2796 if (TREE_CODE (type
) == VAR_DECL
)
2798 node
= varpool_node (type
);
2800 varpool_mark_needed_node (node
);
2801 is_public
= TREE_PUBLIC (type
);
2805 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2808 /* Allow the target to override the type table entry format. */
2809 if (targetm
.asm_out
.ttype (value
))
2812 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2813 assemble_integer (value
, tt_format_size
,
2814 tt_format_size
* BITS_PER_UNIT
, 1);
2816 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2820 output_one_function_exception_table (int section
)
2822 int tt_format
, cs_format
, lp_format
, i
;
2823 #ifdef HAVE_AS_LEB128
2824 char ttype_label
[32];
2825 char cs_after_size_label
[32];
2826 char cs_end_label
[32];
2831 int tt_format_size
= 0;
2833 have_tt_data
= (VEC_length (tree
, cfun
->eh
->ttype_data
)
2834 || (targetm
.arm_eabi_unwinder
2835 ? VEC_length (tree
, cfun
->eh
->ehspec_data
.arm_eabi
)
2836 : VEC_length (uchar
, cfun
->eh
->ehspec_data
.other
)));
2838 /* Indicate the format of the @TType entries. */
2840 tt_format
= DW_EH_PE_omit
;
2843 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2844 #ifdef HAVE_AS_LEB128
2845 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2846 section
? "LLSDATTC" : "LLSDATT",
2847 current_function_funcdef_no
);
2849 tt_format_size
= size_of_encoded_value (tt_format
);
2851 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2854 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2855 current_function_funcdef_no
);
2857 /* The LSDA header. */
2859 /* Indicate the format of the landing pad start pointer. An omitted
2860 field implies @LPStart == @Start. */
2861 /* Currently we always put @LPStart == @Start. This field would
2862 be most useful in moving the landing pads completely out of
2863 line to another section, but it could also be used to minimize
2864 the size of uleb128 landing pad offsets. */
2865 lp_format
= DW_EH_PE_omit
;
2866 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
2867 eh_data_format_name (lp_format
));
2869 /* @LPStart pointer would go here. */
2871 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
2872 eh_data_format_name (tt_format
));
2874 #ifndef HAVE_AS_LEB128
2875 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2876 call_site_len
= sjlj_size_of_call_site_table ();
2878 call_site_len
= dw2_size_of_call_site_table (section
);
2881 /* A pc-relative 4-byte displacement to the @TType data. */
2884 #ifdef HAVE_AS_LEB128
2885 char ttype_after_disp_label
[32];
2886 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
2887 section
? "LLSDATTDC" : "LLSDATTD",
2888 current_function_funcdef_no
);
2889 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
2890 "@TType base offset");
2891 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
2893 /* Ug. Alignment queers things. */
2894 unsigned int before_disp
, after_disp
, last_disp
, disp
;
2896 before_disp
= 1 + 1;
2897 after_disp
= (1 + size_of_uleb128 (call_site_len
)
2899 + VEC_length (uchar
, crtl
->eh
.action_record_data
)
2900 + (VEC_length (tree
, cfun
->eh
->ttype_data
)
2906 unsigned int disp_size
, pad
;
2909 disp_size
= size_of_uleb128 (disp
);
2910 pad
= before_disp
+ disp_size
+ after_disp
;
2911 if (pad
% tt_format_size
)
2912 pad
= tt_format_size
- (pad
% tt_format_size
);
2915 disp
= after_disp
+ pad
;
2917 while (disp
!= last_disp
);
2919 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
2923 /* Indicate the format of the call-site offsets. */
2924 #ifdef HAVE_AS_LEB128
2925 cs_format
= DW_EH_PE_uleb128
;
2927 cs_format
= DW_EH_PE_udata4
;
2929 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
2930 eh_data_format_name (cs_format
));
2932 #ifdef HAVE_AS_LEB128
2933 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
2934 section
? "LLSDACSBC" : "LLSDACSB",
2935 current_function_funcdef_no
);
2936 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
2937 section
? "LLSDACSEC" : "LLSDACSE",
2938 current_function_funcdef_no
);
2939 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
2940 "Call-site table length");
2941 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
2942 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2943 sjlj_output_call_site_table ();
2945 dw2_output_call_site_table (cs_format
, section
);
2946 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
2948 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
2949 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2950 sjlj_output_call_site_table ();
2952 dw2_output_call_site_table (cs_format
, section
);
2955 /* ??? Decode and interpret the data for flag_debug_asm. */
2958 FOR_EACH_VEC_ELT (uchar
, crtl
->eh
.action_record_data
, i
, uc
)
2959 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
2963 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2965 i
= VEC_length (tree
, cfun
->eh
->ttype_data
);
2968 tree type
= VEC_index (tree
, cfun
->eh
->ttype_data
, i
);
2969 output_ttype (type
, tt_format
, tt_format_size
);
2972 #ifdef HAVE_AS_LEB128
2974 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
2977 /* ??? Decode and interpret the data for flag_debug_asm. */
2978 if (targetm
.arm_eabi_unwinder
)
2982 VEC_iterate (tree
, cfun
->eh
->ehspec_data
.arm_eabi
, i
, type
); ++i
)
2983 output_ttype (type
, tt_format
, tt_format_size
);
2989 VEC_iterate (uchar
, cfun
->eh
->ehspec_data
.other
, i
, uc
); ++i
)
2990 dw2_asm_output_data (1, uc
,
2991 i
? NULL
: "Exception specification table");
2996 output_function_exception_table (const char *fnname
)
2998 rtx personality
= get_personality_function (current_function_decl
);
3000 /* Not all functions need anything. */
3001 if (! crtl
->uses_eh_lsda
)
3006 assemble_external_libcall (personality
);
3008 if (targetm
.asm_out
.emit_except_personality
)
3009 targetm
.asm_out
.emit_except_personality (personality
);
3012 switch_to_exception_section (fnname
);
3014 /* If the target wants a label to begin the table, emit it here. */
3015 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3017 output_one_function_exception_table (0);
3018 if (crtl
->eh
.call_site_record
[1] != NULL
)
3019 output_one_function_exception_table (1);
3021 switch_to_section (current_function_section ());
3025 set_eh_throw_stmt_table (struct function
*fun
, struct htab
*table
)
3027 fun
->eh
->throw_stmt_table
= table
;
3031 get_eh_throw_stmt_table (struct function
*fun
)
3033 return fun
->eh
->throw_stmt_table
;
3036 /* Determine if the function needs an EH personality function. */
3038 enum eh_personality_kind
3039 function_needs_eh_personality (struct function
*fn
)
3041 enum eh_personality_kind kind
= eh_personality_none
;
3044 FOR_ALL_EH_REGION_FN (i
, fn
)
3049 /* Can do with any personality including the generic C one. */
3050 kind
= eh_personality_any
;
3054 case ERT_ALLOWED_EXCEPTIONS
:
3055 /* Always needs a EH personality function. The generic C
3056 personality doesn't handle these even for empty type lists. */
3057 return eh_personality_lang
;
3059 case ERT_MUST_NOT_THROW
:
3060 /* Always needs a EH personality function. The language may specify
3061 what abort routine that must be used, e.g. std::terminate. */
3062 return eh_personality_lang
;
3069 /* Dump EH information to OUT. */
3072 dump_eh_tree (FILE * out
, struct function
*fun
)
3076 static const char *const type_name
[] = {
3077 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3080 i
= fun
->eh
->region_tree
;
3084 fprintf (out
, "Eh tree:\n");
3087 fprintf (out
, " %*s %i %s", depth
* 2, "",
3088 i
->index
, type_name
[(int) i
->type
]);
3090 if (i
->landing_pads
)
3094 fprintf (out
, " land:");
3095 if (current_ir_type () == IR_GIMPLE
)
3097 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3099 fprintf (out
, "{%i,", lp
->index
);
3100 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3108 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3110 fprintf (out
, "{%i,", lp
->index
);
3111 if (lp
->landing_pad
)
3112 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3113 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3115 fprintf (out
, "(nil),");
3116 if (lp
->post_landing_pad
)
3118 rtx lab
= label_rtx (lp
->post_landing_pad
);
3119 fprintf (out
, "%i%s}", INSN_UID (lab
),
3120 NOTE_P (lab
) ? "(del)" : "");
3123 fprintf (out
, "(nil)}");
3133 case ERT_MUST_NOT_THROW
:
3139 fprintf (out
, " catch:");
3140 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3145 fprintf (out
, "lab:");
3146 print_generic_expr (out
, c
->label
, 0);
3149 print_generic_expr (out
, c
->type_list
, 0);
3157 case ERT_ALLOWED_EXCEPTIONS
:
3158 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3159 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3164 /* If there are sub-regions, process them. */
3166 i
= i
->inner
, depth
++;
3167 /* If there are peers, process them. */
3168 else if (i
->next_peer
)
3170 /* Otherwise, step back up the tree to the next peer. */
3180 while (i
->next_peer
== NULL
);
3186 /* Dump the EH tree for FN on stderr. */
3189 debug_eh_tree (struct function
*fn
)
3191 dump_eh_tree (stderr
, fn
);
3194 /* Verify invariants on EH datastructures. */
3197 verify_eh_tree (struct function
*fun
)
3200 int nvisited_lp
, nvisited_r
;
3201 int count_lp
, count_r
, depth
, i
;
3205 if (!fun
->eh
->region_tree
)
3209 for (i
= 1; VEC_iterate (eh_region
, fun
->eh
->region_array
, i
, r
); ++i
)
3216 error ("region_array is corrupted for region %i", r
->index
);
3222 for (i
= 1; VEC_iterate (eh_landing_pad
, fun
->eh
->lp_array
, i
, lp
); ++i
)
3229 error ("lp_array is corrupted for lp %i", lp
->index
);
3234 depth
= nvisited_lp
= nvisited_r
= 0;
3236 r
= fun
->eh
->region_tree
;
3239 if (VEC_index (eh_region
, fun
->eh
->region_array
, r
->index
) != r
)
3241 error ("region_array is corrupted for region %i", r
->index
);
3244 if (r
->outer
!= outer
)
3246 error ("outer block of region %i is wrong", r
->index
);
3251 error ("negative nesting depth of region %i", r
->index
);
3256 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3258 if (VEC_index (eh_landing_pad
, fun
->eh
->lp_array
, lp
->index
) != lp
)
3260 error ("lp_array is corrupted for lp %i", lp
->index
);
3263 if (lp
->region
!= r
)
3265 error ("region of lp %i is wrong", lp
->index
);
3272 outer
= r
, r
= r
->inner
, depth
++;
3273 else if (r
->next_peer
)
3285 while (r
->next_peer
== NULL
);
3292 error ("tree list ends on depth %i", depth
);
3295 if (count_r
!= nvisited_r
)
3297 error ("region_array does not match region_tree");
3300 if (count_lp
!= nvisited_lp
)
3302 error ("lp_array does not match region_tree");
3308 dump_eh_tree (stderr
, fun
);
3309 internal_error ("verify_eh_tree failed");
3313 #include "gt-except.h"