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
);
977 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
979 #ifdef HAVE_exception_receiver
980 if (HAVE_exception_receiver
)
981 emit_insn (gen_exception_receiver ());
984 #ifdef HAVE_nonlocal_goto_receiver
985 if (HAVE_nonlocal_goto_receiver
)
986 emit_insn (gen_nonlocal_goto_receiver ());
992 if (region
->exc_ptr_reg
)
993 emit_move_insn (region
->exc_ptr_reg
,
994 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
995 if (region
->filter_reg
)
996 emit_move_insn (region
->filter_reg
,
997 gen_rtx_REG (targetm
.eh_return_filter_mode (),
998 EH_RETURN_DATA_REGNO (1)));
1003 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
1004 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1005 e
->count
= bb
->count
;
1006 e
->probability
= REG_BR_PROB_BASE
;
1011 static VEC (int, heap
) *sjlj_lp_call_site_index
;
1013 /* Process all active landing pads. Assign each one a compact dispatch
1014 index, and a call-site index. */
1017 sjlj_assign_call_site_values (void)
1023 crtl
->eh
.action_record_data
= VEC_alloc (uchar
, gc
, 64);
1024 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
1028 for (i
= 1; VEC_iterate (eh_landing_pad
, cfun
->eh
->lp_array
, i
, lp
); ++i
)
1029 if (lp
&& lp
->post_landing_pad
)
1031 int action
, call_site
;
1033 /* First: build the action table. */
1034 action
= collect_one_action_chain (ar_hash
, lp
->region
);
1036 crtl
->uses_eh_lsda
= 1;
1038 /* Next: assign call-site values. If dwarf2 terms, this would be
1039 the region number assigned by convert_to_eh_region_ranges, but
1040 handles no-action and must-not-throw differently. */
1041 /* Map must-not-throw to otherwise unused call-site index 0. */
1044 /* Map no-action to otherwise unused call-site index -1. */
1045 else if (action
== -1)
1047 /* Otherwise, look it up in the table. */
1049 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1050 VEC_replace (int, sjlj_lp_call_site_index
, i
, call_site
);
1055 htab_delete (ar_hash
);
1060 /* Emit code to record the current call-site index before every
1061 insn that can throw. */
1064 sjlj_mark_call_sites (void)
1066 int last_call_site
= -2;
1069 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1077 /* Reset value tracking at extended basic block boundaries. */
1079 last_call_site
= -2;
1081 if (! INSN_P (insn
))
1084 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1088 this_call_site
= VEC_index (int, sjlj_lp_call_site_index
, lp
->index
);
1091 /* Calls (and trapping insns) without notes are outside any
1092 exception handling region in this function. Mark them as
1094 this_call_site
= -1;
1098 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1102 if (this_call_site
== last_call_site
)
1105 /* Don't separate a call from it's argument loads. */
1108 before
= find_first_parameter_load (insn
, NULL_RTX
);
1111 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1112 sjlj_fc_call_site_ofs
);
1113 emit_move_insn (mem
, GEN_INT (this_call_site
));
1117 emit_insn_before (p
, before
);
1118 last_call_site
= this_call_site
;
1122 /* Construct the SjLj_Function_Context. */
1125 sjlj_emit_function_enter (rtx dispatch_label
)
1127 rtx fn_begin
, fc
, mem
, seq
;
1128 bool fn_begin_outside_block
;
1129 rtx personality
= get_personality_function (current_function_decl
);
1131 fc
= crtl
->eh
.sjlj_fc
;
1135 /* We're storing this libcall's address into memory instead of
1136 calling it directly. Thus, we must call assemble_external_libcall
1137 here, as we can not depend on emit_library_call to do it for us. */
1138 assemble_external_libcall (personality
);
1139 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1140 emit_move_insn (mem
, personality
);
1142 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1143 if (crtl
->uses_eh_lsda
)
1148 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1149 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1150 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1151 emit_move_insn (mem
, sym
);
1154 emit_move_insn (mem
, const0_rtx
);
1156 #ifdef DONT_USE_BUILTIN_SETJMP
1159 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1160 TYPE_MODE (integer_type_node
), 1,
1161 plus_constant (XEXP (fc
, 0),
1162 sjlj_fc_jbuf_ofs
), Pmode
);
1164 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1165 TYPE_MODE (integer_type_node
), 0, dispatch_label
);
1166 last
= get_last_insn ();
1167 if (JUMP_P (last
) && any_condjump_p (last
))
1169 gcc_assert (!find_reg_note (last
, REG_BR_PROB
, 0));
1170 add_reg_note (last
, REG_BR_PROB
, GEN_INT (REG_BR_PROB_BASE
/ 100));
1174 expand_builtin_setjmp_setup (plus_constant (XEXP (fc
, 0), sjlj_fc_jbuf_ofs
),
1178 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1179 1, XEXP (fc
, 0), Pmode
);
1184 /* ??? Instead of doing this at the beginning of the function,
1185 do this in a block that is at loop level 0 and dominates all
1186 can_throw_internal instructions. */
1188 fn_begin_outside_block
= true;
1189 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1190 if (NOTE_P (fn_begin
))
1192 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1194 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1195 fn_begin_outside_block
= false;
1198 if (fn_begin_outside_block
)
1199 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR
));
1201 emit_insn_after (seq
, fn_begin
);
1204 /* Call back from expand_function_end to know where we should put
1205 the call to unwind_sjlj_unregister_libfunc if needed. */
1208 sjlj_emit_function_exit_after (rtx after
)
1210 crtl
->eh
.sjlj_exit_after
= after
;
1214 sjlj_emit_function_exit (void)
1220 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1221 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1226 /* ??? Really this can be done in any block at loop level 0 that
1227 post-dominates all can_throw_internal instructions. This is
1228 the last possible moment. */
1230 insn
= crtl
->eh
.sjlj_exit_after
;
1232 insn
= NEXT_INSN (insn
);
1234 emit_insn_after (seq
, insn
);
1238 sjlj_emit_dispatch_table (rtx dispatch_label
, int num_dispatch
)
1240 enum machine_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1241 enum machine_mode filter_mode
= targetm
.eh_return_filter_mode ();
1243 rtx mem
, seq
, fc
, before
, exc_ptr_reg
, filter_reg
;
1244 rtx first_reachable_label
;
1251 fc
= crtl
->eh
.sjlj_fc
;
1255 emit_label (dispatch_label
);
1257 #ifndef DONT_USE_BUILTIN_SETJMP
1258 expand_builtin_setjmp_receiver (dispatch_label
);
1260 /* The caller of expand_builtin_setjmp_receiver is responsible for
1261 making sure that the label doesn't vanish. The only other caller
1262 is the expander for __builtin_setjmp_receiver, which places this
1263 label on the nonlocal_goto_label list. Since we're modeling these
1264 CFG edges more exactly, we can use the forced_labels list instead. */
1265 LABEL_PRESERVE_P (dispatch_label
) = 1;
1267 = gen_rtx_EXPR_LIST (VOIDmode
, dispatch_label
, forced_labels
);
1270 /* Load up exc_ptr and filter values from the function context. */
1271 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1272 if (unwind_word_mode
!= ptr_mode
)
1274 #ifdef POINTERS_EXTEND_UNSIGNED
1275 mem
= convert_memory_address (ptr_mode
, mem
);
1277 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1280 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1282 mem
= adjust_address (fc
, unwind_word_mode
,
1283 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1284 if (unwind_word_mode
!= filter_mode
)
1285 mem
= convert_to_mode (filter_mode
, mem
, 0);
1286 filter_reg
= force_reg (filter_mode
, mem
);
1288 /* Jump to one of the directly reachable regions. */
1291 first_reachable_label
= NULL
;
1293 /* If there's exactly one call site in the function, don't bother
1294 generating a switch statement. */
1296 if (num_dispatch
> 1)
1300 mem
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1301 sjlj_fc_call_site_ofs
);
1302 disp
= make_tree (integer_type_node
, mem
);
1304 switch_stmt
= gimple_build_switch_nlabels (num_dispatch
, disp
, NULL
);
1307 for (i
= 1; VEC_iterate (eh_landing_pad
, cfun
->eh
->lp_array
, i
, lp
); ++i
)
1308 if (lp
&& lp
->post_landing_pad
)
1314 lp
->landing_pad
= dispatch_label
;
1316 if (num_dispatch
> 1)
1318 tree t_label
, case_elt
;
1320 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1321 case_elt
= build3 (CASE_LABEL_EXPR
, void_type_node
,
1322 build_int_cst (NULL
, disp_index
),
1324 gimple_switch_set_label (switch_stmt
, disp_index
, case_elt
);
1326 label
= label_rtx (t_label
);
1329 label
= gen_label_rtx ();
1331 if (disp_index
== 0)
1332 first_reachable_label
= label
;
1337 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1339 emit_move_insn (r
->filter_reg
, filter_reg
);
1341 seq2
= get_insns ();
1344 before
= label_rtx (lp
->post_landing_pad
);
1345 bb
= emit_to_new_bb_before (seq2
, before
);
1346 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1347 e
->count
= bb
->count
;
1348 e
->probability
= REG_BR_PROB_BASE
;
1352 gcc_assert (disp_index
== num_dispatch
);
1354 if (num_dispatch
> 1)
1356 expand_case (switch_stmt
);
1357 expand_builtin_trap ();
1363 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1364 if (num_dispatch
== 1)
1366 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1367 e
->count
= bb
->count
;
1368 e
->probability
= REG_BR_PROB_BASE
;
1373 sjlj_build_landing_pads (void)
1377 num_dispatch
= VEC_length (eh_landing_pad
, cfun
->eh
->lp_array
);
1378 if (num_dispatch
== 0)
1380 VEC_safe_grow (int, heap
, sjlj_lp_call_site_index
, num_dispatch
);
1382 num_dispatch
= sjlj_assign_call_site_values ();
1383 if (num_dispatch
> 0)
1385 rtx dispatch_label
= gen_label_rtx ();
1386 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1387 TYPE_MODE (sjlj_fc_type_node
),
1388 TYPE_ALIGN (sjlj_fc_type_node
));
1390 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1391 int_size_in_bytes (sjlj_fc_type_node
),
1394 sjlj_mark_call_sites ();
1395 sjlj_emit_function_enter (dispatch_label
);
1396 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1397 sjlj_emit_function_exit ();
1400 VEC_free (int, heap
, sjlj_lp_call_site_index
);
1403 /* After initial rtl generation, call back to finish generating
1404 exception support code. */
1407 finish_eh_generation (void)
1411 /* Construct the landing pads. */
1412 if (USING_SJLJ_EXCEPTIONS
)
1413 sjlj_build_landing_pads ();
1415 dw2_build_landing_pads ();
1416 break_superblocks ();
1418 if (USING_SJLJ_EXCEPTIONS
1419 /* Kludge for Alpha/Tru64 (see alpha_gp_save_rtx). */
1420 || single_succ_edge (ENTRY_BLOCK_PTR
)->insns
.r
)
1421 commit_edge_insertions ();
1423 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1430 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1432 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1433 if (e
->flags
& EDGE_EH
)
1436 /* We should not have generated any new throwing insns during this
1437 pass, and we should not have lost any EH edges, so we only need
1438 to handle two cases here:
1439 (1) reachable handler and an existing edge to post-landing-pad,
1440 (2) no reachable handler and no edge. */
1441 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1444 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1446 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1447 e
->flags
|= (CALL_P (BB_END (bb
))
1448 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1455 gate_handle_eh (void)
1457 /* Nothing to do if no regions created. */
1458 return cfun
->eh
->region_tree
!= NULL
;
1461 /* Complete generation of exception handling code. */
1463 rest_of_handle_eh (void)
1465 finish_eh_generation ();
1466 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
1470 struct rtl_opt_pass pass_rtl_eh
=
1474 "rtl eh", /* name */
1475 gate_handle_eh
, /* gate */
1476 rest_of_handle_eh
, /* execute */
1479 0, /* static_pass_number */
1480 TV_JUMP
, /* tv_id */
1481 0, /* properties_required */
1482 0, /* properties_provided */
1483 0, /* properties_destroyed */
1484 0, /* todo_flags_start */
1485 TODO_dump_func
/* todo_flags_finish */
1489 /* This section handles removing dead code for flow. */
1492 remove_eh_landing_pad (eh_landing_pad lp
)
1496 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1500 if (lp
->post_landing_pad
)
1501 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1502 VEC_replace (eh_landing_pad
, cfun
->eh
->lp_array
, lp
->index
, NULL
);
1505 /* Splice REGION from the region tree. */
1508 remove_eh_handler (eh_region region
)
1510 eh_region
*pp
, *pp_start
, p
, outer
;
1513 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1515 if (lp
->post_landing_pad
)
1516 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1517 VEC_replace (eh_landing_pad
, cfun
->eh
->lp_array
, lp
->index
, NULL
);
1520 outer
= region
->outer
;
1522 pp_start
= &outer
->inner
;
1524 pp_start
= &cfun
->eh
->region_tree
;
1525 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1529 *pp
= p
= region
->inner
;
1538 *pp
= region
->next_peer
;
1540 VEC_replace (eh_region
, cfun
->eh
->region_array
, region
->index
, NULL
);
1543 /* Invokes CALLBACK for every exception handler landing pad label.
1544 Only used by reload hackery; should not be used by new code. */
1547 for_each_eh_label (void (*callback
) (rtx
))
1552 for (i
= 1; VEC_iterate (eh_landing_pad
, cfun
->eh
->lp_array
, i
, lp
); ++i
)
1556 rtx lab
= lp
->landing_pad
;
1557 if (lab
&& LABEL_P (lab
))
1563 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1566 At the gimple level, we use LP_NR
1567 > 0 : The statement transfers to landing pad LP_NR
1568 = 0 : The statement is outside any EH region
1569 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1571 At the rtl level, we use LP_NR
1572 > 0 : The insn transfers to landing pad LP_NR
1573 = 0 : The insn cannot throw
1574 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1575 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1576 missing note: The insn is outside any EH region.
1578 ??? This difference probably ought to be avoided. We could stand
1579 to record nothrow for arbitrary gimple statements, and so avoid
1580 some moderately complex lookups in stmt_could_throw_p. Perhaps
1581 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1582 no-nonlocal-goto property should be recorded elsewhere as a bit
1583 on the call_insn directly. Perhaps we should make more use of
1584 attaching the trees to call_insns (reachable via symbol_ref in
1585 direct call cases) and just pull the data out of the trees. */
1588 make_reg_eh_region_note (rtx insn
, int ecf_flags
, int lp_nr
)
1591 if (ecf_flags
& ECF_NOTHROW
)
1593 else if (lp_nr
!= 0)
1594 value
= GEN_INT (lp_nr
);
1597 add_reg_note (insn
, REG_EH_REGION
, value
);
1600 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1601 nor perform a non-local goto. Replace the region note if it
1605 make_reg_eh_region_note_nothrow_nononlocal (rtx insn
)
1607 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1608 rtx intmin
= GEN_INT (INT_MIN
);
1611 XEXP (note
, 0) = intmin
;
1613 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1616 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1620 insn_could_throw_p (const_rtx insn
)
1622 if (!flag_exceptions
)
1626 if (INSN_P (insn
) && flag_non_call_exceptions
)
1627 return may_trap_p (PATTERN (insn
));
1631 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1632 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1633 to look for a note, or the note itself. */
1636 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx first
, rtx last
)
1638 rtx insn
, note
= note_or_insn
;
1640 if (INSN_P (note_or_insn
))
1642 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1646 note
= XEXP (note
, 0);
1648 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1649 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1650 && insn_could_throw_p (insn
))
1651 add_reg_note (insn
, REG_EH_REGION
, note
);
1654 /* Likewise, but iterate backward. */
1657 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx last
, rtx first
)
1659 rtx insn
, note
= note_or_insn
;
1661 if (INSN_P (note_or_insn
))
1663 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1667 note
= XEXP (note
, 0);
1669 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1670 if (insn_could_throw_p (insn
))
1671 add_reg_note (insn
, REG_EH_REGION
, note
);
1675 /* Extract all EH information from INSN. Return true if the insn
1676 was marked NOTHROW. */
1679 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1680 eh_landing_pad
*plp
)
1682 eh_landing_pad lp
= NULL
;
1688 if (! INSN_P (insn
))
1691 if (NONJUMP_INSN_P (insn
)
1692 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1693 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1695 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1698 ret
= !insn_could_throw_p (insn
);
1702 lp_nr
= INTVAL (XEXP (note
, 0));
1703 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1710 r
= VEC_index (eh_region
, cfun
->eh
->region_array
, -lp_nr
);
1713 lp
= VEC_index (eh_landing_pad
, cfun
->eh
->lp_array
, lp_nr
);
1723 /* Return the landing pad to which INSN may go, or NULL if it does not
1724 have a reachable landing pad within this function. */
1727 get_eh_landing_pad_from_rtx (const_rtx insn
)
1732 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1736 /* Return the region to which INSN may go, or NULL if it does not
1737 have a reachable region within this function. */
1740 get_eh_region_from_rtx (const_rtx insn
)
1745 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1749 /* Return true if INSN throws and is caught by something in this function. */
1752 can_throw_internal (const_rtx insn
)
1754 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1757 /* Return true if INSN throws and escapes from the current function. */
1760 can_throw_external (const_rtx insn
)
1766 if (! INSN_P (insn
))
1769 if (NONJUMP_INSN_P (insn
)
1770 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1772 rtx seq
= PATTERN (insn
);
1773 int i
, n
= XVECLEN (seq
, 0);
1775 for (i
= 0; i
< n
; i
++)
1776 if (can_throw_external (XVECEXP (seq
, 0, i
)))
1782 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1784 /* If we can't throw, we obviously can't throw external. */
1788 /* If we have an internal landing pad, then we're not external. */
1792 /* If we're not within an EH region, then we are external. */
1796 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1797 which don't always have landing pads. */
1798 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1802 /* Return true if INSN cannot throw at all. */
1805 insn_nothrow_p (const_rtx insn
)
1810 if (! INSN_P (insn
))
1813 if (NONJUMP_INSN_P (insn
)
1814 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1816 rtx seq
= PATTERN (insn
);
1817 int i
, n
= XVECLEN (seq
, 0);
1819 for (i
= 0; i
< n
; i
++)
1820 if (!insn_nothrow_p (XVECEXP (seq
, 0, i
)))
1826 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1829 /* Return true if INSN can perform a non-local goto. */
1830 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1833 can_nonlocal_goto (const_rtx insn
)
1835 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1837 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1838 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1844 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1847 set_nothrow_function_flags (void)
1853 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1854 something that can throw an exception. We specifically exempt
1855 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1856 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1859 crtl
->all_throwers_are_sibcalls
= 1;
1861 /* If we don't know that this implementation of the function will
1862 actually be used, then we must not set TREE_NOTHROW, since
1863 callers must not assume that this function does not throw. */
1864 if (TREE_NOTHROW (current_function_decl
))
1867 if (! flag_exceptions
)
1870 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1871 if (can_throw_external (insn
))
1875 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1877 crtl
->all_throwers_are_sibcalls
= 0;
1882 for (insn
= crtl
->epilogue_delay_list
; insn
;
1883 insn
= XEXP (insn
, 1))
1884 if (can_throw_external (insn
))
1888 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1890 crtl
->all_throwers_are_sibcalls
= 0;
1895 && (cgraph_function_body_availability (cgraph_node
1896 (current_function_decl
))
1897 >= AVAIL_AVAILABLE
))
1899 struct cgraph_node
*node
= cgraph_node (current_function_decl
);
1900 struct cgraph_edge
*e
;
1901 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1902 e
->can_throw_external
= false;
1903 cgraph_set_nothrow_flag (node
, true);
1906 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
1907 current_function_name ());
1912 struct rtl_opt_pass pass_set_nothrow_function_flags
=
1916 "nothrow", /* name */
1918 set_nothrow_function_flags
, /* execute */
1921 0, /* static_pass_number */
1922 TV_NONE
, /* tv_id */
1923 0, /* properties_required */
1924 0, /* properties_provided */
1925 0, /* properties_destroyed */
1926 0, /* todo_flags_start */
1927 TODO_dump_func
, /* todo_flags_finish */
1932 /* Various hooks for unwind library. */
1934 /* Expand the EH support builtin functions:
1935 __builtin_eh_pointer and __builtin_eh_filter. */
1938 expand_builtin_eh_common (tree region_nr_t
)
1940 HOST_WIDE_INT region_nr
;
1943 gcc_assert (host_integerp (region_nr_t
, 0));
1944 region_nr
= tree_low_cst (region_nr_t
, 0);
1946 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, region_nr
);
1948 /* ??? We shouldn't have been able to delete a eh region without
1949 deleting all the code that depended on it. */
1950 gcc_assert (region
!= NULL
);
1955 /* Expand to the exc_ptr value from the given eh region. */
1958 expand_builtin_eh_pointer (tree exp
)
1961 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
1962 if (region
->exc_ptr_reg
== NULL
)
1963 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
1964 return region
->exc_ptr_reg
;
1967 /* Expand to the filter value from the given eh region. */
1970 expand_builtin_eh_filter (tree exp
)
1973 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
1974 if (region
->filter_reg
== NULL
)
1975 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
1976 return region
->filter_reg
;
1979 /* Copy the exc_ptr and filter values from one landing pad's registers
1980 to another. This is used to inline the resx statement. */
1983 expand_builtin_eh_copy_values (tree exp
)
1986 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
1988 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
1989 enum machine_mode fmode
= targetm
.eh_return_filter_mode ();
1991 if (dst
->exc_ptr_reg
== NULL
)
1992 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
1993 if (src
->exc_ptr_reg
== NULL
)
1994 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
1996 if (dst
->filter_reg
== NULL
)
1997 dst
->filter_reg
= gen_reg_rtx (fmode
);
1998 if (src
->filter_reg
== NULL
)
1999 src
->filter_reg
= gen_reg_rtx (fmode
);
2001 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2002 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2007 /* Do any necessary initialization to access arbitrary stack frames.
2008 On the SPARC, this means flushing the register windows. */
2011 expand_builtin_unwind_init (void)
2013 /* Set this so all the registers get saved in our frame; we need to be
2014 able to copy the saved values for any registers from frames we unwind. */
2015 crtl
->saves_all_registers
= 1;
2017 #ifdef SETUP_FRAME_ADDRESSES
2018 SETUP_FRAME_ADDRESSES ();
2022 /* Map a non-negative number to an eh return data register number; expands
2023 to -1 if no return data register is associated with the input number.
2024 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2027 expand_builtin_eh_return_data_regno (tree exp
)
2029 tree which
= CALL_EXPR_ARG (exp
, 0);
2030 unsigned HOST_WIDE_INT iwhich
;
2032 if (TREE_CODE (which
) != INTEGER_CST
)
2034 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2038 iwhich
= tree_low_cst (which
, 1);
2039 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2040 if (iwhich
== INVALID_REGNUM
)
2043 #ifdef DWARF_FRAME_REGNUM
2044 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2046 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2049 return GEN_INT (iwhich
);
2052 /* Given a value extracted from the return address register or stack slot,
2053 return the actual address encoded in that value. */
2056 expand_builtin_extract_return_addr (tree addr_tree
)
2058 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2060 if (GET_MODE (addr
) != Pmode
2061 && GET_MODE (addr
) != VOIDmode
)
2063 #ifdef POINTERS_EXTEND_UNSIGNED
2064 addr
= convert_memory_address (Pmode
, addr
);
2066 addr
= convert_to_mode (Pmode
, addr
, 0);
2070 /* First mask out any unwanted bits. */
2071 #ifdef MASK_RETURN_ADDR
2072 expand_and (Pmode
, addr
, MASK_RETURN_ADDR
, addr
);
2075 /* Then adjust to find the real return address. */
2076 #if defined (RETURN_ADDR_OFFSET)
2077 addr
= plus_constant (addr
, RETURN_ADDR_OFFSET
);
2083 /* Given an actual address in addr_tree, do any necessary encoding
2084 and return the value to be stored in the return address register or
2085 stack slot so the epilogue will return to that address. */
2088 expand_builtin_frob_return_addr (tree addr_tree
)
2090 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2092 addr
= convert_memory_address (Pmode
, addr
);
2094 #ifdef RETURN_ADDR_OFFSET
2095 addr
= force_reg (Pmode
, addr
);
2096 addr
= plus_constant (addr
, -RETURN_ADDR_OFFSET
);
2102 /* Set up the epilogue with the magic bits we'll need to return to the
2103 exception handler. */
2106 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2111 #ifdef EH_RETURN_STACKADJ_RTX
2112 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2113 VOIDmode
, EXPAND_NORMAL
);
2114 tmp
= convert_memory_address (Pmode
, tmp
);
2115 if (!crtl
->eh
.ehr_stackadj
)
2116 crtl
->eh
.ehr_stackadj
= copy_to_reg (tmp
);
2117 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2118 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2121 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2122 VOIDmode
, EXPAND_NORMAL
);
2123 tmp
= convert_memory_address (Pmode
, tmp
);
2124 if (!crtl
->eh
.ehr_handler
)
2125 crtl
->eh
.ehr_handler
= copy_to_reg (tmp
);
2126 else if (tmp
!= crtl
->eh
.ehr_handler
)
2127 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2129 if (!crtl
->eh
.ehr_label
)
2130 crtl
->eh
.ehr_label
= gen_label_rtx ();
2131 emit_jump (crtl
->eh
.ehr_label
);
2134 /* Expand __builtin_eh_return. This exit path from the function loads up
2135 the eh return data registers, adjusts the stack, and branches to a
2136 given PC other than the normal return address. */
2139 expand_eh_return (void)
2143 if (! crtl
->eh
.ehr_label
)
2146 crtl
->calls_eh_return
= 1;
2148 #ifdef EH_RETURN_STACKADJ_RTX
2149 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2152 around_label
= gen_label_rtx ();
2153 emit_jump (around_label
);
2155 emit_label (crtl
->eh
.ehr_label
);
2156 clobber_return_register ();
2158 #ifdef EH_RETURN_STACKADJ_RTX
2159 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2162 #ifdef HAVE_eh_return
2164 emit_insn (gen_eh_return (crtl
->eh
.ehr_handler
));
2168 #ifdef EH_RETURN_HANDLER_RTX
2169 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2171 error ("__builtin_eh_return not supported on this target");
2175 emit_label (around_label
);
2178 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2179 POINTERS_EXTEND_UNSIGNED and return it. */
2182 expand_builtin_extend_pointer (tree addr_tree
)
2184 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2187 #ifdef POINTERS_EXTEND_UNSIGNED
2188 extend
= POINTERS_EXTEND_UNSIGNED
;
2190 /* The previous EH code did an unsigned extend by default, so we do this also
2195 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2198 /* In the following functions, we represent entries in the action table
2199 as 1-based indices. Special cases are:
2201 0: null action record, non-null landing pad; implies cleanups
2202 -1: null action record, null landing pad; implies no action
2203 -2: no call-site entry; implies must_not_throw
2204 -3: we have yet to process outer regions
2206 Further, no special cases apply to the "next" field of the record.
2207 For next, 0 means end of list. */
2209 struct action_record
2217 action_record_eq (const void *pentry
, const void *pdata
)
2219 const struct action_record
*entry
= (const struct action_record
*) pentry
;
2220 const struct action_record
*data
= (const struct action_record
*) pdata
;
2221 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
2225 action_record_hash (const void *pentry
)
2227 const struct action_record
*entry
= (const struct action_record
*) pentry
;
2228 return entry
->next
* 1009 + entry
->filter
;
2232 add_action_record (htab_t ar_hash
, int filter
, int next
)
2234 struct action_record
**slot
, *new_ar
, tmp
;
2236 tmp
.filter
= filter
;
2238 slot
= (struct action_record
**) htab_find_slot (ar_hash
, &tmp
, INSERT
);
2240 if ((new_ar
= *slot
) == NULL
)
2242 new_ar
= XNEW (struct action_record
);
2243 new_ar
->offset
= VEC_length (uchar
, crtl
->eh
.action_record_data
) + 1;
2244 new_ar
->filter
= filter
;
2245 new_ar
->next
= next
;
2248 /* The filter value goes in untouched. The link to the next
2249 record is a "self-relative" byte offset, or zero to indicate
2250 that there is no next record. So convert the absolute 1 based
2251 indices we've been carrying around into a displacement. */
2253 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2255 next
-= VEC_length (uchar
, crtl
->eh
.action_record_data
) + 1;
2256 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2259 return new_ar
->offset
;
2263 collect_one_action_chain (htab_t ar_hash
, eh_region region
)
2267 /* If we've reached the top of the region chain, then we have
2268 no actions, and require no landing pad. */
2272 switch (region
->type
)
2277 /* A cleanup adds a zero filter to the beginning of the chain, but
2278 there are special cases to look out for. If there are *only*
2279 cleanups along a path, then it compresses to a zero action.
2280 Further, if there are multiple cleanups along a path, we only
2281 need to represent one of them, as that is enough to trigger
2282 entry to the landing pad at runtime. */
2283 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2286 for (r
= region
->outer
; r
; r
= r
->outer
)
2287 if (r
->type
== ERT_CLEANUP
)
2289 return add_action_record (ar_hash
, 0, next
);
2296 /* Process the associated catch regions in reverse order.
2297 If there's a catch-all handler, then we don't need to
2298 search outer regions. Use a magic -3 value to record
2299 that we haven't done the outer search. */
2301 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2303 if (c
->type_list
== NULL
)
2305 /* Retrieve the filter from the head of the filter list
2306 where we have stored it (see assign_filter_values). */
2307 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2308 next
= add_action_record (ar_hash
, filter
, 0);
2312 /* Once the outer search is done, trigger an action record for
2313 each filter we have. */
2318 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2320 /* If there is no next action, terminate the chain. */
2323 /* If all outer actions are cleanups or must_not_throw,
2324 we'll have no action record for it, since we had wanted
2325 to encode these states in the call-site record directly.
2326 Add a cleanup action to the chain to catch these. */
2328 next
= add_action_record (ar_hash
, 0, 0);
2331 flt_node
= c
->filter_list
;
2332 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2334 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2335 next
= add_action_record (ar_hash
, filter
, next
);
2342 case ERT_ALLOWED_EXCEPTIONS
:
2343 /* An exception specification adds its filter to the
2344 beginning of the chain. */
2345 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2347 /* If there is no next action, terminate the chain. */
2350 /* If all outer actions are cleanups or must_not_throw,
2351 we'll have no action record for it, since we had wanted
2352 to encode these states in the call-site record directly.
2353 Add a cleanup action to the chain to catch these. */
2355 next
= add_action_record (ar_hash
, 0, 0);
2357 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2359 case ERT_MUST_NOT_THROW
:
2360 /* A must-not-throw region with no inner handlers or cleanups
2361 requires no call-site entry. Note that this differs from
2362 the no handler or cleanup case in that we do require an lsda
2363 to be generated. Return a magic -2 value to record this. */
2371 add_call_site (rtx landing_pad
, int action
, int section
)
2373 call_site_record record
;
2375 record
= GGC_NEW (struct call_site_record_d
);
2376 record
->landing_pad
= landing_pad
;
2377 record
->action
= action
;
2379 VEC_safe_push (call_site_record
, gc
,
2380 crtl
->eh
.call_site_record
[section
], record
);
2382 return call_site_base
+ VEC_length (call_site_record
,
2383 crtl
->eh
.call_site_record
[section
]) - 1;
2386 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2387 The new note numbers will not refer to region numbers, but
2388 instead to call site entries. */
2391 convert_to_eh_region_ranges (void)
2393 rtx insn
, iter
, note
;
2395 int last_action
= -3;
2396 rtx last_action_insn
= NULL_RTX
;
2397 rtx last_landing_pad
= NULL_RTX
;
2398 rtx first_no_action_insn
= NULL_RTX
;
2401 rtx section_switch_note
= NULL_RTX
;
2402 rtx first_no_action_insn_before_switch
= NULL_RTX
;
2403 rtx last_no_action_insn_before_switch
= NULL_RTX
;
2404 rtx
*pad_map
= NULL
;
2405 sbitmap pad_loc
= NULL
;
2406 int min_labelno
= 0, max_labelno
= 0;
2407 int saved_call_site_base
= call_site_base
;
2409 crtl
->eh
.action_record_data
= VEC_alloc (uchar
, gc
, 64);
2411 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
2413 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2420 rtx this_landing_pad
;
2423 if (NONJUMP_INSN_P (insn
)
2424 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2425 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2427 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2431 this_action
= collect_one_action_chain (ar_hash
, region
);
2435 /* Existence of catch handlers, or must-not-throw regions
2436 implies that an lsda is needed (even if empty). */
2437 if (this_action
!= -1)
2438 crtl
->uses_eh_lsda
= 1;
2440 /* Delay creation of region notes for no-action regions
2441 until we're sure that an lsda will be required. */
2442 else if (last_action
== -3)
2444 first_no_action_insn
= iter
;
2448 if (this_action
>= 0)
2449 this_landing_pad
= lp
->landing_pad
;
2451 this_landing_pad
= NULL_RTX
;
2453 /* Differing actions or landing pads implies a change in call-site
2454 info, which implies some EH_REGION note should be emitted. */
2455 if (last_action
!= this_action
2456 || last_landing_pad
!= this_landing_pad
)
2458 /* If we'd not seen a previous action (-3) or the previous
2459 action was must-not-throw (-2), then we do not need an
2461 if (last_action
>= -1)
2463 /* If we delayed the creation of the begin, do it now. */
2464 if (first_no_action_insn_before_switch
)
2466 call_site
= add_call_site (NULL_RTX
, 0, 0);
2468 = emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2469 first_no_action_insn_before_switch
);
2470 NOTE_EH_HANDLER (note
) = call_site
;
2471 if (first_no_action_insn
)
2474 = emit_note_after (NOTE_INSN_EH_REGION_END
,
2475 last_no_action_insn_before_switch
);
2476 NOTE_EH_HANDLER (note
) = call_site
;
2479 gcc_assert (last_action_insn
2480 == last_no_action_insn_before_switch
);
2482 if (first_no_action_insn
)
2484 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2485 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2486 first_no_action_insn
);
2487 NOTE_EH_HANDLER (note
) = call_site
;
2488 first_no_action_insn
= NULL_RTX
;
2491 note
= emit_note_after (NOTE_INSN_EH_REGION_END
,
2493 NOTE_EH_HANDLER (note
) = call_site
;
2496 /* If the new action is must-not-throw, then no region notes
2498 if (this_action
>= -1)
2500 call_site
= add_call_site (this_landing_pad
,
2501 this_action
< 0 ? 0 : this_action
,
2503 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2504 NOTE_EH_HANDLER (note
) = call_site
;
2507 last_action
= this_action
;
2508 last_landing_pad
= this_landing_pad
;
2510 last_action_insn
= iter
;
2512 else if (NOTE_P (iter
)
2513 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2515 gcc_assert (section_switch_note
== NULL_RTX
);
2516 gcc_assert (flag_reorder_blocks_and_partition
);
2517 section_switch_note
= iter
;
2518 if (first_no_action_insn
)
2520 first_no_action_insn_before_switch
= first_no_action_insn
;
2521 last_no_action_insn_before_switch
= last_action_insn
;
2522 first_no_action_insn
= NULL_RTX
;
2523 gcc_assert (last_action
== -1);
2526 /* Force closing of current EH region before section switch and
2527 opening a new one afterwards. */
2528 else if (last_action
!= -3)
2529 last_landing_pad
= pc_rtx
;
2530 call_site_base
+= VEC_length (call_site_record
,
2531 crtl
->eh
.call_site_record
[cur_sec
]);
2533 gcc_assert (crtl
->eh
.call_site_record
[cur_sec
] == NULL
);
2534 crtl
->eh
.call_site_record
[cur_sec
]
2535 = VEC_alloc (call_site_record
, gc
, 10);
2536 max_labelno
= max_label_num ();
2537 min_labelno
= get_first_label_num ();
2538 pad_map
= XCNEWVEC (rtx
, max_labelno
- min_labelno
+ 1);
2539 pad_loc
= sbitmap_alloc (max_labelno
- min_labelno
+ 1);
2541 else if (LABEL_P (iter
) && pad_map
)
2542 SET_BIT (pad_loc
, CODE_LABEL_NUMBER (iter
) - min_labelno
);
2544 if (last_action
>= -1 && ! first_no_action_insn
)
2546 note
= emit_note_after (NOTE_INSN_EH_REGION_END
, last_action_insn
);
2547 NOTE_EH_HANDLER (note
) = call_site
;
2550 call_site_base
= saved_call_site_base
;
2554 /* When doing hot/cold partitioning, ensure landing pads are
2555 always in the same section as the EH region, .gcc_except_table
2556 can't express it otherwise. */
2557 for (cur_sec
= 0; cur_sec
< 2; cur_sec
++)
2560 int n
= VEC_length (call_site_record
,
2561 crtl
->eh
.call_site_record
[cur_sec
]);
2562 basic_block prev_bb
= NULL
, padbb
;
2564 for (i
= 0; i
< n
; ++i
)
2566 struct call_site_record_d
*cs
=
2567 VEC_index (call_site_record
,
2568 crtl
->eh
.call_site_record
[cur_sec
], i
);
2571 if (cs
->landing_pad
== NULL_RTX
)
2573 idx
= CODE_LABEL_NUMBER (cs
->landing_pad
) - min_labelno
;
2574 /* If the landing pad is in the correct section, nothing
2576 if (TEST_BIT (pad_loc
, idx
) ^ (cur_sec
== 0))
2578 /* Otherwise, if we haven't seen this pad yet, we need to
2579 add a new label and jump to the correct section. */
2580 if (pad_map
[idx
] == NULL_RTX
)
2582 pad_map
[idx
] = gen_label_rtx ();
2583 if (prev_bb
== NULL
)
2584 for (iter
= section_switch_note
;
2585 iter
; iter
= PREV_INSN (iter
))
2586 if (NOTE_INSN_BASIC_BLOCK_P (iter
))
2588 prev_bb
= NOTE_BASIC_BLOCK (iter
);
2593 note
= emit_label_before (pad_map
[idx
],
2594 section_switch_note
);
2595 jump
= emit_jump_insn_before (gen_jump (cs
->landing_pad
),
2596 section_switch_note
);
2600 jump
= emit_jump_insn_after (gen_jump (cs
->landing_pad
),
2601 section_switch_note
);
2602 note
= emit_label_after (pad_map
[idx
],
2603 section_switch_note
);
2605 JUMP_LABEL (jump
) = cs
->landing_pad
;
2606 add_reg_note (jump
, REG_CROSSING_JUMP
, NULL_RTX
);
2607 iter
= NEXT_INSN (cs
->landing_pad
);
2608 if (iter
&& NOTE_INSN_BASIC_BLOCK_P (iter
))
2609 padbb
= NOTE_BASIC_BLOCK (iter
);
2612 if (padbb
&& prev_bb
2613 && BB_PARTITION (padbb
) != BB_UNPARTITIONED
)
2617 = BB_PARTITION (padbb
) == BB_COLD_PARTITION
2618 ? BB_HOT_PARTITION
: BB_COLD_PARTITION
;
2622 bb
= create_basic_block (note
, jump
, prev_bb
);
2623 make_single_succ_edge (bb
, padbb
, EDGE_CROSSING
);
2624 BB_SET_PARTITION (bb
, part
);
2625 for (ei
= ei_start (padbb
->preds
);
2626 (e
= ei_safe_edge (ei
)); )
2628 if ((e
->flags
& (EDGE_EH
|EDGE_CROSSING
))
2629 == (EDGE_EH
|EDGE_CROSSING
))
2631 redirect_edge_succ (e
, bb
);
2632 e
->flags
&= ~EDGE_CROSSING
;
2641 cs
->landing_pad
= pad_map
[idx
];
2645 sbitmap_free (pad_loc
);
2646 XDELETEVEC (pad_map
);
2649 htab_delete (ar_hash
);
2654 gate_convert_to_eh_region_ranges (void)
2656 /* Nothing to do for SJLJ exceptions or if no regions created. */
2657 return !(USING_SJLJ_EXCEPTIONS
|| cfun
->eh
->region_tree
== NULL
);
2660 struct rtl_opt_pass pass_convert_to_eh_region_ranges
=
2664 "eh_ranges", /* name */
2665 gate_convert_to_eh_region_ranges
, /* gate */
2666 convert_to_eh_region_ranges
, /* execute */
2669 0, /* static_pass_number */
2670 TV_NONE
, /* tv_id */
2671 0, /* properties_required */
2672 0, /* properties_provided */
2673 0, /* properties_destroyed */
2674 0, /* todo_flags_start */
2675 TODO_dump_func
, /* todo_flags_finish */
2680 push_uleb128 (VEC (uchar
, gc
) **data_area
, unsigned int value
)
2684 unsigned char byte
= value
& 0x7f;
2688 VEC_safe_push (uchar
, gc
, *data_area
, byte
);
2694 push_sleb128 (VEC (uchar
, gc
) **data_area
, int value
)
2701 byte
= value
& 0x7f;
2703 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2704 || (value
== -1 && (byte
& 0x40) != 0));
2707 VEC_safe_push (uchar
, gc
, *data_area
, byte
);
2713 #ifndef HAVE_AS_LEB128
2715 dw2_size_of_call_site_table (int section
)
2717 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
[section
]);
2718 int size
= n
* (4 + 4 + 4);
2721 for (i
= 0; i
< n
; ++i
)
2723 struct call_site_record_d
*cs
=
2724 VEC_index (call_site_record
, crtl
->eh
.call_site_record
[section
], i
);
2725 size
+= size_of_uleb128 (cs
->action
);
2732 sjlj_size_of_call_site_table (void)
2734 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
[0]);
2738 for (i
= 0; i
< n
; ++i
)
2740 struct call_site_record_d
*cs
=
2741 VEC_index (call_site_record
, crtl
->eh
.call_site_record
[0], i
);
2742 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2743 size
+= size_of_uleb128 (cs
->action
);
2751 dw2_output_call_site_table (int cs_format
, int section
)
2753 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
[section
]);
2758 begin
= current_function_func_begin_label
;
2759 else if (first_function_block_is_cold
)
2760 begin
= crtl
->subsections
.hot_section_label
;
2762 begin
= crtl
->subsections
.cold_section_label
;
2764 for (i
= 0; i
< n
; ++i
)
2766 struct call_site_record_d
*cs
=
2767 VEC_index (call_site_record
, crtl
->eh
.call_site_record
[section
], i
);
2768 char reg_start_lab
[32];
2769 char reg_end_lab
[32];
2770 char landing_pad_lab
[32];
2772 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2773 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2775 if (cs
->landing_pad
)
2776 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2777 CODE_LABEL_NUMBER (cs
->landing_pad
));
2779 /* ??? Perhaps use insn length scaling if the assembler supports
2780 generic arithmetic. */
2781 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2782 data4 if the function is small enough. */
2783 if (cs_format
== DW_EH_PE_uleb128
)
2785 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2786 "region %d start", i
);
2787 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2789 if (cs
->landing_pad
)
2790 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2793 dw2_asm_output_data_uleb128 (0, "landing pad");
2797 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2798 "region %d start", i
);
2799 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2800 if (cs
->landing_pad
)
2801 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2804 dw2_asm_output_data (4, 0, "landing pad");
2806 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2809 call_site_base
+= n
;
2813 sjlj_output_call_site_table (void)
2815 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
[0]);
2818 for (i
= 0; i
< n
; ++i
)
2820 struct call_site_record_d
*cs
=
2821 VEC_index (call_site_record
, crtl
->eh
.call_site_record
[0], i
);
2823 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2824 "region %d landing pad", i
);
2825 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2828 call_site_base
+= n
;
2831 #ifndef TARGET_UNWIND_INFO
2832 /* Switch to the section that should be used for exception tables. */
2835 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2839 if (exception_section
)
2840 s
= exception_section
;
2843 /* Compute the section and cache it into exception_section,
2844 unless it depends on the function name. */
2845 if (targetm
.have_named_sections
)
2849 if (EH_TABLES_CAN_BE_READ_ONLY
)
2852 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2853 flags
= ((! flag_pic
2854 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2855 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2856 ? 0 : SECTION_WRITE
);
2859 flags
= SECTION_WRITE
;
2861 #ifdef HAVE_LD_EH_GC_SECTIONS
2862 if (flag_function_sections
)
2864 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2865 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2866 s
= get_section (section_name
, flags
, NULL
);
2867 free (section_name
);
2872 = s
= get_section (".gcc_except_table", flags
, NULL
);
2876 = s
= flag_pic
? data_section
: readonly_data_section
;
2879 switch_to_section (s
);
2884 /* Output a reference from an exception table to the type_info object TYPE.
2885 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2889 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2892 bool is_public
= true;
2894 if (type
== NULL_TREE
)
2898 struct varpool_node
*node
;
2900 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2901 runtime types so TYPE should already be a runtime type
2902 reference. When pass_ipa_free_lang data is made a default
2903 pass, we can then remove the call to lookup_type_for_runtime
2906 type
= lookup_type_for_runtime (type
);
2908 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2910 /* Let cgraph know that the rtti decl is used. Not all of the
2911 paths below go through assemble_integer, which would take
2912 care of this for us. */
2914 if (TREE_CODE (type
) == ADDR_EXPR
)
2916 type
= TREE_OPERAND (type
, 0);
2917 if (TREE_CODE (type
) == VAR_DECL
)
2919 node
= varpool_node (type
);
2921 varpool_mark_needed_node (node
);
2922 is_public
= TREE_PUBLIC (type
);
2926 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2929 /* Allow the target to override the type table entry format. */
2930 if (targetm
.asm_out
.ttype (value
))
2933 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2934 assemble_integer (value
, tt_format_size
,
2935 tt_format_size
* BITS_PER_UNIT
, 1);
2937 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2941 output_one_function_exception_table (const char * ARG_UNUSED (fnname
),
2942 int section
, rtx
ARG_UNUSED (personality
))
2944 int tt_format
, cs_format
, lp_format
, i
;
2945 #ifdef HAVE_AS_LEB128
2946 char ttype_label
[32];
2947 char cs_after_size_label
[32];
2948 char cs_end_label
[32];
2953 int tt_format_size
= 0;
2955 #ifdef TARGET_UNWIND_INFO
2956 /* TODO: Move this into target file. */
2957 fputs ("\t.personality\t", asm_out_file
);
2958 output_addr_const (asm_out_file
, personality
);
2959 fputs ("\n\t.handlerdata\n", asm_out_file
);
2960 /* Note that varasm still thinks we're in the function's code section.
2961 The ".endp" directive that will immediately follow will take us back. */
2963 switch_to_exception_section (fnname
);
2966 /* If the target wants a label to begin the table, emit it here. */
2967 targetm
.asm_out
.except_table_label (asm_out_file
);
2969 have_tt_data
= (VEC_length (tree
, cfun
->eh
->ttype_data
)
2970 || (targetm
.arm_eabi_unwinder
2971 ? VEC_length (tree
, cfun
->eh
->ehspec_data
.arm_eabi
)
2972 : VEC_length (uchar
, cfun
->eh
->ehspec_data
.other
)));
2974 /* Indicate the format of the @TType entries. */
2976 tt_format
= DW_EH_PE_omit
;
2979 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2980 #ifdef HAVE_AS_LEB128
2981 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2982 section
? "LLSDATTC" : "LLSDATT",
2983 current_function_funcdef_no
);
2985 tt_format_size
= size_of_encoded_value (tt_format
);
2987 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2990 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2991 current_function_funcdef_no
);
2993 /* The LSDA header. */
2995 /* Indicate the format of the landing pad start pointer. An omitted
2996 field implies @LPStart == @Start. */
2997 /* Currently we always put @LPStart == @Start. This field would
2998 be most useful in moving the landing pads completely out of
2999 line to another section, but it could also be used to minimize
3000 the size of uleb128 landing pad offsets. */
3001 lp_format
= DW_EH_PE_omit
;
3002 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
3003 eh_data_format_name (lp_format
));
3005 /* @LPStart pointer would go here. */
3007 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
3008 eh_data_format_name (tt_format
));
3010 #ifndef HAVE_AS_LEB128
3011 if (USING_SJLJ_EXCEPTIONS
)
3012 call_site_len
= sjlj_size_of_call_site_table ();
3014 call_site_len
= dw2_size_of_call_site_table (section
);
3017 /* A pc-relative 4-byte displacement to the @TType data. */
3020 #ifdef HAVE_AS_LEB128
3021 char ttype_after_disp_label
[32];
3022 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
3023 section
? "LLSDATTDC" : "LLSDATTD",
3024 current_function_funcdef_no
);
3025 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3026 "@TType base offset");
3027 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3029 /* Ug. Alignment queers things. */
3030 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3032 before_disp
= 1 + 1;
3033 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3035 + VEC_length (uchar
, crtl
->eh
.action_record_data
)
3036 + (VEC_length (tree
, cfun
->eh
->ttype_data
)
3042 unsigned int disp_size
, pad
;
3045 disp_size
= size_of_uleb128 (disp
);
3046 pad
= before_disp
+ disp_size
+ after_disp
;
3047 if (pad
% tt_format_size
)
3048 pad
= tt_format_size
- (pad
% tt_format_size
);
3051 disp
= after_disp
+ pad
;
3053 while (disp
!= last_disp
);
3055 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3059 /* Indicate the format of the call-site offsets. */
3060 #ifdef HAVE_AS_LEB128
3061 cs_format
= DW_EH_PE_uleb128
;
3063 cs_format
= DW_EH_PE_udata4
;
3065 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3066 eh_data_format_name (cs_format
));
3068 #ifdef HAVE_AS_LEB128
3069 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3070 section
? "LLSDACSBC" : "LLSDACSB",
3071 current_function_funcdef_no
);
3072 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3073 section
? "LLSDACSEC" : "LLSDACSE",
3074 current_function_funcdef_no
);
3075 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3076 "Call-site table length");
3077 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3078 if (USING_SJLJ_EXCEPTIONS
)
3079 sjlj_output_call_site_table ();
3081 dw2_output_call_site_table (cs_format
, section
);
3082 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3084 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3085 if (USING_SJLJ_EXCEPTIONS
)
3086 sjlj_output_call_site_table ();
3088 dw2_output_call_site_table (cs_format
, section
);
3091 /* ??? Decode and interpret the data for flag_debug_asm. */
3094 for (i
= 0; VEC_iterate (uchar
, crtl
->eh
.action_record_data
, i
, uc
); ++i
)
3095 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3099 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3101 i
= VEC_length (tree
, cfun
->eh
->ttype_data
);
3104 tree type
= VEC_index (tree
, cfun
->eh
->ttype_data
, i
);
3105 output_ttype (type
, tt_format
, tt_format_size
);
3108 #ifdef HAVE_AS_LEB128
3110 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3113 /* ??? Decode and interpret the data for flag_debug_asm. */
3114 if (targetm
.arm_eabi_unwinder
)
3118 VEC_iterate (tree
, cfun
->eh
->ehspec_data
.arm_eabi
, i
, type
); ++i
)
3119 output_ttype (type
, tt_format
, tt_format_size
);
3125 VEC_iterate (uchar
, cfun
->eh
->ehspec_data
.other
, i
, uc
); ++i
)
3126 dw2_asm_output_data (1, uc
,
3127 i
? NULL
: "Exception specification table");
3132 output_function_exception_table (const char * ARG_UNUSED (fnname
))
3134 rtx personality
= get_personality_function (current_function_decl
);
3136 /* Not all functions need anything. */
3137 if (! crtl
->uses_eh_lsda
)
3141 assemble_external_libcall (personality
);
3143 output_one_function_exception_table (fnname
, 0, personality
);
3144 if (crtl
->eh
.call_site_record
[1] != NULL
)
3145 output_one_function_exception_table (fnname
, 1, personality
);
3147 switch_to_section (current_function_section ());
3151 set_eh_throw_stmt_table (struct function
*fun
, struct htab
*table
)
3153 fun
->eh
->throw_stmt_table
= table
;
3157 get_eh_throw_stmt_table (struct function
*fun
)
3159 return fun
->eh
->throw_stmt_table
;
3162 /* Determine if the function needs an EH personality function. */
3164 enum eh_personality_kind
3165 function_needs_eh_personality (struct function
*fn
)
3167 enum eh_personality_kind kind
= eh_personality_none
;
3170 FOR_ALL_EH_REGION_FN (i
, fn
)
3175 /* Can do with any personality including the generic C one. */
3176 kind
= eh_personality_any
;
3180 case ERT_ALLOWED_EXCEPTIONS
:
3181 /* Always needs a EH personality function. The generic C
3182 personality doesn't handle these even for empty type lists. */
3183 return eh_personality_lang
;
3185 case ERT_MUST_NOT_THROW
:
3186 /* Always needs a EH personality function. The language may specify
3187 what abort routine that must be used, e.g. std::terminate. */
3188 return eh_personality_lang
;
3195 /* Dump EH information to OUT. */
3198 dump_eh_tree (FILE * out
, struct function
*fun
)
3202 static const char *const type_name
[] = {
3203 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3206 i
= fun
->eh
->region_tree
;
3210 fprintf (out
, "Eh tree:\n");
3213 fprintf (out
, " %*s %i %s", depth
* 2, "",
3214 i
->index
, type_name
[(int) i
->type
]);
3216 if (i
->landing_pads
)
3220 fprintf (out
, " land:");
3221 if (current_ir_type () == IR_GIMPLE
)
3223 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3225 fprintf (out
, "{%i,", lp
->index
);
3226 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3234 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
);
3236 fprintf (out
, "{%i,", lp
->index
);
3237 if (lp
->landing_pad
)
3238 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3239 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3241 fprintf (out
, "(nil),");
3242 if (lp
->post_landing_pad
)
3244 rtx lab
= label_rtx (lp
->post_landing_pad
);
3245 fprintf (out
, "%i%s}", INSN_UID (lab
),
3246 NOTE_P (lab
) ? "(del)" : "");
3249 fprintf (out
, "(nil)}");
3259 case ERT_MUST_NOT_THROW
:
3265 fprintf (out
, " catch:");
3266 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3271 fprintf (out
, "lab:");
3272 print_generic_expr (out
, c
->label
, 0);
3275 print_generic_expr (out
, c
->type_list
, 0);
3283 case ERT_ALLOWED_EXCEPTIONS
:
3284 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3285 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3290 /* If there are sub-regions, process them. */
3292 i
= i
->inner
, depth
++;
3293 /* If there are peers, process them. */
3294 else if (i
->next_peer
)
3296 /* Otherwise, step back up the tree to the next peer. */
3306 while (i
->next_peer
== NULL
);
3312 /* Dump the EH tree for FN on stderr. */
3315 debug_eh_tree (struct function
*fn
)
3317 dump_eh_tree (stderr
, fn
);
3320 /* Verify invariants on EH datastructures. */
3323 verify_eh_tree (struct function
*fun
)
3326 int nvisited_lp
, nvisited_r
;
3327 int count_lp
, count_r
, depth
, i
;
3331 if (!fun
->eh
->region_tree
)
3335 for (i
= 1; VEC_iterate (eh_region
, fun
->eh
->region_array
, i
, r
); ++i
)
3342 error ("region_array is corrupted for region %i", r
->index
);
3348 for (i
= 1; VEC_iterate (eh_landing_pad
, fun
->eh
->lp_array
, i
, lp
); ++i
)
3355 error ("lp_array is corrupted for lp %i", lp
->index
);
3360 depth
= nvisited_lp
= nvisited_r
= 0;
3362 r
= fun
->eh
->region_tree
;
3365 if (VEC_index (eh_region
, fun
->eh
->region_array
, r
->index
) != r
)
3367 error ("region_array is corrupted for region %i", r
->index
);
3370 if (r
->outer
!= outer
)
3372 error ("outer block of region %i is wrong", r
->index
);
3377 error ("negative nesting depth of region %i", r
->index
);
3382 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3384 if (VEC_index (eh_landing_pad
, fun
->eh
->lp_array
, lp
->index
) != lp
)
3386 error ("lp_array is corrupted for lp %i", lp
->index
);
3389 if (lp
->region
!= r
)
3391 error ("region of lp %i is wrong", lp
->index
);
3398 outer
= r
, r
= r
->inner
, depth
++;
3399 else if (r
->next_peer
)
3411 while (r
->next_peer
== NULL
);
3418 error ("tree list ends on depth %i", depth
);
3421 if (count_r
!= nvisited_r
)
3423 error ("region_array does not match region_tree");
3426 if (count_lp
!= nvisited_lp
)
3428 error ("lp_array does not match region_tree");
3434 dump_eh_tree (stderr
, fun
);
3435 internal_error ("verify_eh_tree failed");
3439 #include "gt-except.h"