1 /* Implements exception handling.
2 Copyright (C) 1989-2014 Free Software Foundation, Inc.
3 Contributed by Mike Stump <mrs@cygnus.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* An exception is an event that can be "thrown" from within a
23 function. This event can then be "caught" by the callers of
26 The representation of exceptions changes several times during
27 the compilation process:
29 In the beginning, in the front end, we have the GENERIC trees
30 TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
31 CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
33 During initial gimplification (gimplify.c) these are lowered
34 to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
35 The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
36 into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
39 During pass_lower_eh (tree-eh.c) we record the nested structure
40 of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
41 We expand the eh_protect_cleanup_actions langhook into MUST_NOT_THROW
42 regions at this time. We can then flatten the statements within
43 the TRY nodes to straight-line code. Statements that had been within
44 TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,
45 so that we may remember what action is supposed to be taken if
46 a given statement does throw. During this lowering process,
47 we create an EH_LANDING_PAD node for each EH_REGION that has
48 some code within the function that needs to be executed if a
49 throw does happen. We also create RESX statements that are
50 used to transfer control from an inner EH_REGION to an outer
51 EH_REGION. We also create EH_DISPATCH statements as placeholders
52 for a runtime type comparison that should be made in order to
53 select the action to perform among different CATCH and EH_FILTER
56 During pass_lower_eh_dispatch (tree-eh.c), which is run after
57 all inlining is complete, we are able to run assign_filter_values,
58 which allows us to map the set of types manipulated by all of the
59 CATCH and EH_FILTER regions to a set of integers. This set of integers
60 will be how the exception runtime communicates with the code generated
61 within the function. We then expand the GIMPLE_EH_DISPATCH statements
62 to a switch or conditional branches that use the argument provided by
63 the runtime (__builtin_eh_filter) and the set of integers we computed
64 in assign_filter_values.
66 During pass_lower_resx (tree-eh.c), which is run near the end
67 of optimization, we expand RESX statements. If the eh region
68 that is outer to the RESX statement is a MUST_NOT_THROW, then
69 the RESX expands to some form of abort statement. If the eh
70 region that is outer to the RESX statement is within the current
71 function, then the RESX expands to a bookkeeping call
72 (__builtin_eh_copy_values) and a goto. Otherwise, the next
73 handler for the exception must be within a function somewhere
74 up the call chain, so we call back into the exception runtime
75 (__builtin_unwind_resume).
77 During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
78 that create an rtl to eh_region mapping that corresponds to the
79 gimple to eh_region mapping that had been recorded in the
82 Then, via finish_eh_generation, we generate the real landing pads
83 to which the runtime will actually transfer control. These new
84 landing pads perform whatever bookkeeping is needed by the target
85 backend in order to resume execution within the current function.
86 Each of these new landing pads falls through into the post_landing_pad
87 label which had been used within the CFG up to this point. All
88 exception edges within the CFG are redirected to the new landing pads.
89 If the target uses setjmp to implement exceptions, the various extra
90 calls into the runtime to register and unregister the current stack
91 frame are emitted at this time.
93 During pass_convert_to_eh_region_ranges (except.c), we transform
94 the REG_EH_REGION notes attached to individual insns into
95 non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG
96 and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the
97 same associated action within the exception region tree, meaning
98 that (1) the exception is caught by the same landing pad within the
99 current function, (2) the exception is blocked by the runtime with
100 a MUST_NOT_THROW region, or (3) the exception is not handled at all
101 within the current function.
103 Finally, during assembly generation, we call
104 output_function_exception_table (except.c) to emit the tables with
105 which the exception runtime can determine if a given stack frame
106 handles a given exception, and if so what filter value to provide
107 to the function when the non-local control transfer is effected.
108 If the target uses dwarf2 unwinding to implement exceptions, then
109 output_call_frame_info (dwarf2out.c) emits the required unwind data. */
114 #include "coretypes.h"
118 #include "stringpool.h"
119 #include "stor-layout.h"
121 #include "function.h"
123 #include "libfuncs.h"
124 #include "insn-config.h"
126 #include "hard-reg-set.h"
128 #include "dwarf2asm.h"
129 #include "dwarf2out.h"
132 #include "hash-table.h"
136 #include "common/common-target.h"
137 #include "langhooks.h"
139 #include "diagnostic.h"
140 #include "tree-pretty-print.h"
141 #include "tree-pass.h"
143 #include "builtins.h"
145 /* Provide defaults for stuff that may not be defined when using
147 #ifndef EH_RETURN_DATA_REGNO
148 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
151 static GTY(()) int call_site_base
;
153 struct tree_hash_traits
: default_hashmap_traits
155 static hashval_t
hash (tree t
) { return TREE_HASH (t
); }
158 static GTY (()) hash_map
<tree
, tree
, tree_hash_traits
> *type_to_runtime_map
;
160 /* Describe the SjLj_Function_Context structure. */
161 static GTY(()) tree sjlj_fc_type_node
;
162 static int sjlj_fc_call_site_ofs
;
163 static int sjlj_fc_data_ofs
;
164 static int sjlj_fc_personality_ofs
;
165 static int sjlj_fc_lsda_ofs
;
166 static int sjlj_fc_jbuf_ofs
;
169 struct GTY(()) call_site_record_d
175 /* In the following structure and associated functions,
176 we represent entries in the action table as 1-based indices.
179 0: null action record, non-null landing pad; implies cleanups
180 -1: null action record, null landing pad; implies no action
181 -2: no call-site entry; implies must_not_throw
182 -3: we have yet to process outer regions
184 Further, no special cases apply to the "next" field of the record.
185 For next, 0 means end of list. */
194 /* Hashtable helpers. */
196 struct action_record_hasher
: typed_free_remove
<action_record
>
198 typedef action_record value_type
;
199 typedef action_record compare_type
;
200 static inline hashval_t
hash (const value_type
*);
201 static inline bool equal (const value_type
*, const compare_type
*);
205 action_record_hasher::hash (const value_type
*entry
)
207 return entry
->next
* 1009 + entry
->filter
;
211 action_record_hasher::equal (const value_type
*entry
, const compare_type
*data
)
213 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
216 typedef hash_table
<action_record_hasher
> action_hash_type
;
218 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
221 static void dw2_build_landing_pads (void);
223 static int collect_one_action_chain (action_hash_type
*, eh_region
);
224 static int add_call_site (rtx
, int, int);
226 static void push_uleb128 (vec
<uchar
, va_gc
> **, unsigned int);
227 static void push_sleb128 (vec
<uchar
, va_gc
> **, int);
228 #ifndef HAVE_AS_LEB128
229 static int dw2_size_of_call_site_table (int);
230 static int sjlj_size_of_call_site_table (void);
232 static void dw2_output_call_site_table (int, int);
233 static void sjlj_output_call_site_table (void);
239 if (! flag_exceptions
)
243 = hash_map
<tree
, tree
, tree_hash_traits
>::create_ggc (31);
245 /* Create the SjLj_Function_Context structure. This should match
246 the definition in unwind-sjlj.c. */
247 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
249 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
251 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
253 f_prev
= build_decl (BUILTINS_LOCATION
,
254 FIELD_DECL
, get_identifier ("__prev"),
255 build_pointer_type (sjlj_fc_type_node
));
256 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
258 f_cs
= build_decl (BUILTINS_LOCATION
,
259 FIELD_DECL
, get_identifier ("__call_site"),
261 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
263 tmp
= build_index_type (size_int (4 - 1));
264 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
265 (targetm
.unwind_word_mode (), 1),
267 f_data
= build_decl (BUILTINS_LOCATION
,
268 FIELD_DECL
, get_identifier ("__data"), tmp
);
269 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
271 f_per
= build_decl (BUILTINS_LOCATION
,
272 FIELD_DECL
, get_identifier ("__personality"),
274 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
276 f_lsda
= build_decl (BUILTINS_LOCATION
,
277 FIELD_DECL
, get_identifier ("__lsda"),
279 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
281 #ifdef DONT_USE_BUILTIN_SETJMP
283 tmp
= size_int (JMP_BUF_SIZE
- 1);
285 /* Should be large enough for most systems, if it is not,
286 JMP_BUF_SIZE should be defined with the proper value. It will
287 also tend to be larger than necessary for most systems, a more
288 optimal port will define JMP_BUF_SIZE. */
289 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
292 /* Compute a minimally sized jump buffer. We need room to store at
293 least 3 pointers - stack pointer, frame pointer and return address.
294 Plus for some targets we need room for an extra pointer - in the
295 case of MIPS this is the global pointer. This makes a total of four
296 pointers, but to be safe we actually allocate room for 5.
298 If pointers are smaller than words then we allocate enough room for
299 5 words, just in case the backend needs this much room. For more
300 discussion on this issue see:
301 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
302 if (POINTER_SIZE
> BITS_PER_WORD
)
303 tmp
= size_int (5 - 1);
305 tmp
= size_int ((5 * BITS_PER_WORD
/ POINTER_SIZE
) - 1);
308 tmp
= build_index_type (tmp
);
309 tmp
= build_array_type (ptr_type_node
, tmp
);
310 f_jbuf
= build_decl (BUILTINS_LOCATION
,
311 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
312 #ifdef DONT_USE_BUILTIN_SETJMP
313 /* We don't know what the alignment requirements of the
314 runtime's jmp_buf has. Overestimate. */
315 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
316 DECL_USER_ALIGN (f_jbuf
) = 1;
318 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
320 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
321 TREE_CHAIN (f_prev
) = f_cs
;
322 TREE_CHAIN (f_cs
) = f_data
;
323 TREE_CHAIN (f_data
) = f_per
;
324 TREE_CHAIN (f_per
) = f_lsda
;
325 TREE_CHAIN (f_lsda
) = f_jbuf
;
327 layout_type (sjlj_fc_type_node
);
329 /* Cache the interesting field offsets so that we have
330 easy access from rtl. */
331 sjlj_fc_call_site_ofs
332 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs
))
333 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs
)) / BITS_PER_UNIT
);
335 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data
))
336 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data
)) / BITS_PER_UNIT
);
337 sjlj_fc_personality_ofs
338 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per
))
339 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per
)) / BITS_PER_UNIT
);
341 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda
))
342 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda
)) / BITS_PER_UNIT
);
344 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf
))
345 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf
)) / BITS_PER_UNIT
);
350 init_eh_for_function (void)
352 cfun
->eh
= ggc_cleared_alloc
<eh_status
> ();
354 /* Make sure zero'th entries are used. */
355 vec_safe_push (cfun
->eh
->region_array
, (eh_region
)0);
356 vec_safe_push (cfun
->eh
->lp_array
, (eh_landing_pad
)0);
359 /* Routines to generate the exception tree somewhat directly.
360 These are used from tree-eh.c when processing exception related
361 nodes during tree optimization. */
364 gen_eh_region (enum eh_region_type type
, eh_region outer
)
368 /* Insert a new blank region as a leaf in the tree. */
369 new_eh
= ggc_cleared_alloc
<eh_region_d
> ();
371 new_eh
->outer
= outer
;
374 new_eh
->next_peer
= outer
->inner
;
375 outer
->inner
= new_eh
;
379 new_eh
->next_peer
= cfun
->eh
->region_tree
;
380 cfun
->eh
->region_tree
= new_eh
;
383 new_eh
->index
= vec_safe_length (cfun
->eh
->region_array
);
384 vec_safe_push (cfun
->eh
->region_array
, new_eh
);
386 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
387 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
388 new_eh
->use_cxa_end_cleanup
= true;
394 gen_eh_region_cleanup (eh_region outer
)
396 return gen_eh_region (ERT_CLEANUP
, outer
);
400 gen_eh_region_try (eh_region outer
)
402 return gen_eh_region (ERT_TRY
, outer
);
406 gen_eh_region_catch (eh_region t
, tree type_or_list
)
409 tree type_list
, type_node
;
411 gcc_assert (t
->type
== ERT_TRY
);
413 /* Ensure to always end up with a type list to normalize further
414 processing, then register each type against the runtime types map. */
415 type_list
= type_or_list
;
418 if (TREE_CODE (type_or_list
) != TREE_LIST
)
419 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
421 type_node
= type_list
;
422 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
423 add_type_for_runtime (TREE_VALUE (type_node
));
426 c
= ggc_cleared_alloc
<eh_catch_d
> ();
427 c
->type_list
= type_list
;
428 l
= t
->u
.eh_try
.last_catch
;
433 t
->u
.eh_try
.first_catch
= c
;
434 t
->u
.eh_try
.last_catch
= c
;
440 gen_eh_region_allowed (eh_region outer
, tree allowed
)
442 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
443 region
->u
.allowed
.type_list
= allowed
;
445 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
446 add_type_for_runtime (TREE_VALUE (allowed
));
452 gen_eh_region_must_not_throw (eh_region outer
)
454 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
458 gen_eh_landing_pad (eh_region region
)
460 eh_landing_pad lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
462 lp
->next_lp
= region
->landing_pads
;
464 lp
->index
= vec_safe_length (cfun
->eh
->lp_array
);
465 region
->landing_pads
= lp
;
467 vec_safe_push (cfun
->eh
->lp_array
, lp
);
473 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
475 return (*ifun
->eh
->region_array
)[i
];
479 get_eh_region_from_number (int i
)
481 return get_eh_region_from_number_fn (cfun
, i
);
485 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
487 return (*ifun
->eh
->lp_array
)[i
];
491 get_eh_landing_pad_from_number (int i
)
493 return get_eh_landing_pad_from_number_fn (cfun
, i
);
497 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
500 return (*ifun
->eh
->region_array
)[-i
];
506 lp
= (*ifun
->eh
->lp_array
)[i
];
512 get_eh_region_from_lp_number (int i
)
514 return get_eh_region_from_lp_number_fn (cfun
, i
);
517 /* Returns true if the current function has exception handling regions. */
520 current_function_has_exception_handlers (void)
522 return cfun
->eh
->region_tree
!= NULL
;
525 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
526 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
528 struct duplicate_eh_regions_data
530 duplicate_eh_regions_map label_map
;
531 void *label_map_data
;
532 hash_map
<void *, void *> *eh_map
;
536 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
537 eh_region old_r
, eh_region outer
)
539 eh_landing_pad old_lp
, new_lp
;
542 new_r
= gen_eh_region (old_r
->type
, outer
);
543 gcc_assert (!data
->eh_map
->put (old_r
, new_r
));
553 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
555 /* We should be doing all our region duplication before and
556 during inlining, which is before filter lists are created. */
557 gcc_assert (oc
->filter_list
== NULL
);
558 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
559 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
564 case ERT_ALLOWED_EXCEPTIONS
:
565 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
566 if (old_r
->u
.allowed
.label
)
567 new_r
->u
.allowed
.label
568 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
570 new_r
->u
.allowed
.label
= NULL_TREE
;
573 case ERT_MUST_NOT_THROW
:
574 new_r
->u
.must_not_throw
.failure_loc
=
575 LOCATION_LOCUS (old_r
->u
.must_not_throw
.failure_loc
);
576 new_r
->u
.must_not_throw
.failure_decl
=
577 old_r
->u
.must_not_throw
.failure_decl
;
581 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
583 /* Don't bother copying unused landing pads. */
584 if (old_lp
->post_landing_pad
== NULL
)
587 new_lp
= gen_eh_landing_pad (new_r
);
588 gcc_assert (!data
->eh_map
->put (old_lp
, new_lp
));
590 new_lp
->post_landing_pad
591 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
592 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
595 /* Make sure to preserve the original use of __cxa_end_cleanup. */
596 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
598 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
599 duplicate_eh_regions_1 (data
, old_r
, new_r
);
602 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
603 the current function and root the tree below OUTER_REGION.
604 The special case of COPY_REGION of NULL means all regions.
605 Remap labels using MAP/MAP_DATA callback. Return a pointer map
606 that allows the caller to remap uses of both EH regions and
609 hash_map
<void *, void *> *
610 duplicate_eh_regions (struct function
*ifun
,
611 eh_region copy_region
, int outer_lp
,
612 duplicate_eh_regions_map map
, void *map_data
)
614 struct duplicate_eh_regions_data data
;
615 eh_region outer_region
;
617 #ifdef ENABLE_CHECKING
618 verify_eh_tree (ifun
);
621 data
.label_map
= map
;
622 data
.label_map_data
= map_data
;
623 data
.eh_map
= new hash_map
<void *, void *>;
625 outer_region
= get_eh_region_from_lp_number (outer_lp
);
627 /* Copy all the regions in the subtree. */
629 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
633 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
634 duplicate_eh_regions_1 (&data
, r
, outer_region
);
637 #ifdef ENABLE_CHECKING
638 verify_eh_tree (cfun
);
644 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
647 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
652 gcc_assert (ifun
->eh
->region_array
);
653 gcc_assert (ifun
->eh
->region_tree
);
655 b_outer
= sbitmap_alloc (ifun
->eh
->region_array
->length ());
656 bitmap_clear (b_outer
);
660 bitmap_set_bit (b_outer
, region_b
->index
);
661 region_b
= region_b
->outer
;
667 if (bitmap_bit_p (b_outer
, region_a
->index
))
669 region_a
= region_a
->outer
;
673 sbitmap_free (b_outer
);
678 add_type_for_runtime (tree type
)
680 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
681 if (TREE_CODE (type
) == NOP_EXPR
)
684 bool existed
= false;
685 tree
*slot
= &type_to_runtime_map
->get_or_insert (type
, &existed
);
687 *slot
= lang_hooks
.eh_runtime_type (type
);
691 lookup_type_for_runtime (tree type
)
693 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
694 if (TREE_CODE (type
) == NOP_EXPR
)
697 /* We should have always inserted the data earlier. */
698 return *type_to_runtime_map
->get (type
);
702 /* Represent an entry in @TTypes for either catch actions
703 or exception filter actions. */
704 struct ttypes_filter
{
709 /* Helper for ttypes_filter hashing. */
711 struct ttypes_filter_hasher
: typed_free_remove
<ttypes_filter
>
713 typedef ttypes_filter value_type
;
714 typedef tree_node compare_type
;
715 static inline hashval_t
hash (const value_type
*);
716 static inline bool equal (const value_type
*, const compare_type
*);
719 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
720 (a tree) for a @TTypes type node we are thinking about adding. */
723 ttypes_filter_hasher::equal (const value_type
*entry
, const compare_type
*data
)
725 return entry
->t
== data
;
729 ttypes_filter_hasher::hash (const value_type
*entry
)
731 return TREE_HASH (entry
->t
);
734 typedef hash_table
<ttypes_filter_hasher
> ttypes_hash_type
;
737 /* Helper for ehspec hashing. */
739 struct ehspec_hasher
: typed_free_remove
<ttypes_filter
>
741 typedef ttypes_filter value_type
;
742 typedef ttypes_filter compare_type
;
743 static inline hashval_t
hash (const value_type
*);
744 static inline bool equal (const value_type
*, const compare_type
*);
747 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
748 exception specification list we are thinking about adding. */
749 /* ??? Currently we use the type lists in the order given. Someone
750 should put these in some canonical order. */
753 ehspec_hasher::equal (const value_type
*entry
, const compare_type
*data
)
755 return type_list_equal (entry
->t
, data
->t
);
758 /* Hash function for exception specification lists. */
761 ehspec_hasher::hash (const value_type
*entry
)
766 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
767 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
771 typedef hash_table
<ehspec_hasher
> ehspec_hash_type
;
774 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
775 to speed up the search. Return the filter value to be used. */
778 add_ttypes_entry (ttypes_hash_type
*ttypes_hash
, tree type
)
780 struct ttypes_filter
**slot
, *n
;
782 slot
= ttypes_hash
->find_slot_with_hash (type
, (hashval_t
) TREE_HASH (type
),
785 if ((n
= *slot
) == NULL
)
787 /* Filter value is a 1 based table index. */
789 n
= XNEW (struct ttypes_filter
);
791 n
->filter
= vec_safe_length (cfun
->eh
->ttype_data
) + 1;
794 vec_safe_push (cfun
->eh
->ttype_data
, type
);
800 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
801 to speed up the search. Return the filter value to be used. */
804 add_ehspec_entry (ehspec_hash_type
*ehspec_hash
, ttypes_hash_type
*ttypes_hash
,
807 struct ttypes_filter
**slot
, *n
;
808 struct ttypes_filter dummy
;
811 slot
= ehspec_hash
->find_slot (&dummy
, INSERT
);
813 if ((n
= *slot
) == NULL
)
817 if (targetm
.arm_eabi_unwinder
)
818 len
= vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
);
820 len
= vec_safe_length (cfun
->eh
->ehspec_data
.other
);
822 /* Filter value is a -1 based byte index into a uleb128 buffer. */
824 n
= XNEW (struct ttypes_filter
);
826 n
->filter
= -(len
+ 1);
829 /* Generate a 0 terminated list of filter values. */
830 for (; list
; list
= TREE_CHAIN (list
))
832 if (targetm
.arm_eabi_unwinder
)
833 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, TREE_VALUE (list
));
836 /* Look up each type in the list and encode its filter
837 value as a uleb128. */
838 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
839 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
842 if (targetm
.arm_eabi_unwinder
)
843 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
845 vec_safe_push (cfun
->eh
->ehspec_data
.other
, (uchar
)0);
851 /* Generate the action filter values to be used for CATCH and
852 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
853 we use lots of landing pads, and so every type or list can share
854 the same filter value, which saves table space. */
857 assign_filter_values (void)
863 vec_alloc (cfun
->eh
->ttype_data
, 16);
864 if (targetm
.arm_eabi_unwinder
)
865 vec_alloc (cfun
->eh
->ehspec_data
.arm_eabi
, 64);
867 vec_alloc (cfun
->eh
->ehspec_data
.other
, 64);
869 ehspec_hash_type
ehspec (31);
870 ttypes_hash_type
ttypes (31);
872 for (i
= 1; vec_safe_iterate (cfun
->eh
->region_array
, i
, &r
); ++i
)
880 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
882 /* Whatever type_list is (NULL or true list), we build a list
883 of filters for the region. */
884 c
->filter_list
= NULL_TREE
;
886 if (c
->type_list
!= NULL
)
888 /* Get a filter value for each of the types caught and store
889 them in the region's dedicated list. */
890 tree tp_node
= c
->type_list
;
892 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
895 = add_ttypes_entry (&ttypes
, TREE_VALUE (tp_node
));
896 tree flt_node
= build_int_cst (integer_type_node
, flt
);
899 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
904 /* Get a filter value for the NULL list also since it
905 will need an action record anyway. */
906 int flt
= add_ttypes_entry (&ttypes
, NULL
);
907 tree flt_node
= build_int_cst (integer_type_node
, flt
);
910 = tree_cons (NULL_TREE
, flt_node
, NULL
);
915 case ERT_ALLOWED_EXCEPTIONS
:
917 = add_ehspec_entry (&ehspec
, &ttypes
, r
->u
.allowed
.type_list
);
926 /* Emit SEQ into basic block just before INSN (that is assumed to be
927 first instruction of some existing BB and return the newly
930 emit_to_new_bb_before (rtx_insn
*seq
, rtx insn
)
937 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
938 call), we don't want it to go into newly created landing pad or other EH
940 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
941 if (e
->flags
& EDGE_FALLTHRU
)
942 force_nonfallthru (e
);
945 last
= emit_insn_before (seq
, insn
);
946 if (BARRIER_P (last
))
947 last
= PREV_INSN (last
);
948 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
949 update_bb_for_insn (bb
);
950 bb
->flags
|= BB_SUPERBLOCK
;
954 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
955 at the rtl level. Emit the code required by the target at a landing
956 pad for the given region. */
959 expand_dw2_landing_pad_for_region (eh_region region
)
961 #ifdef HAVE_exception_receiver
962 if (HAVE_exception_receiver
)
963 emit_insn (gen_exception_receiver ());
966 #ifdef HAVE_nonlocal_goto_receiver
967 if (HAVE_nonlocal_goto_receiver
)
968 emit_insn (gen_nonlocal_goto_receiver ());
973 if (region
->exc_ptr_reg
)
974 emit_move_insn (region
->exc_ptr_reg
,
975 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
976 if (region
->filter_reg
)
977 emit_move_insn (region
->filter_reg
,
978 gen_rtx_REG (targetm
.eh_return_filter_mode (),
979 EH_RETURN_DATA_REGNO (1)));
982 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
985 dw2_build_landing_pads (void)
989 int e_flags
= EDGE_FALLTHRU
;
991 /* If we're going to partition blocks, we need to be able to add
992 new landing pads later, which means that we need to hold on to
993 the post-landing-pad block. Prevent it from being merged away.
994 We'll remove this bit after partitioning. */
995 if (flag_reorder_blocks_and_partition
)
996 e_flags
|= EDGE_PRESERVE
;
998 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1004 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
1009 lp
->landing_pad
= gen_label_rtx ();
1010 emit_label (lp
->landing_pad
);
1011 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
1013 expand_dw2_landing_pad_for_region (lp
->region
);
1018 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
1019 e
= make_edge (bb
, bb
->next_bb
, e_flags
);
1020 e
->count
= bb
->count
;
1021 e
->probability
= REG_BR_PROB_BASE
;
1024 struct loop
*loop
= bb
->next_bb
->loop_father
;
1025 /* If we created a pre-header block, add the new block to the
1026 outer loop, otherwise to the loop itself. */
1027 if (bb
->next_bb
== loop
->header
)
1028 add_bb_to_loop (bb
, loop_outer (loop
));
1030 add_bb_to_loop (bb
, loop
);
1036 static vec
<int> sjlj_lp_call_site_index
;
1038 /* Process all active landing pads. Assign each one a compact dispatch
1039 index, and a call-site index. */
1042 sjlj_assign_call_site_values (void)
1044 action_hash_type
ar_hash (31);
1048 vec_alloc (crtl
->eh
.action_record_data
, 64);
1052 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1053 if (lp
&& lp
->post_landing_pad
)
1055 int action
, call_site
;
1057 /* First: build the action table. */
1058 action
= collect_one_action_chain (&ar_hash
, lp
->region
);
1060 /* Next: assign call-site values. If dwarf2 terms, this would be
1061 the region number assigned by convert_to_eh_region_ranges, but
1062 handles no-action and must-not-throw differently. */
1063 /* Map must-not-throw to otherwise unused call-site index 0. */
1066 /* Map no-action to otherwise unused call-site index -1. */
1067 else if (action
== -1)
1069 /* Otherwise, look it up in the table. */
1071 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1072 sjlj_lp_call_site_index
[i
] = call_site
;
1080 /* Emit code to record the current call-site index before every
1081 insn that can throw. */
1084 sjlj_mark_call_sites (void)
1086 int last_call_site
= -2;
1090 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1096 rtx_insn
*before
, *p
;
1098 /* Reset value tracking at extended basic block boundaries. */
1100 last_call_site
= -2;
1102 if (! INSN_P (insn
))
1105 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1109 this_call_site
= sjlj_lp_call_site_index
[lp
->index
];
1112 /* Calls (and trapping insns) without notes are outside any
1113 exception handling region in this function. Mark them as
1115 this_call_site
= -1;
1119 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1123 if (this_call_site
!= -1)
1124 crtl
->uses_eh_lsda
= 1;
1126 if (this_call_site
== last_call_site
)
1129 /* Don't separate a call from it's argument loads. */
1132 before
= find_first_parameter_load (insn
, NULL
);
1135 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1136 sjlj_fc_call_site_ofs
);
1137 emit_move_insn (mem
, gen_int_mode (this_call_site
, GET_MODE (mem
)));
1141 emit_insn_before (p
, before
);
1142 last_call_site
= this_call_site
;
1146 /* Construct the SjLj_Function_Context. */
1149 sjlj_emit_function_enter (rtx_code_label
*dispatch_label
)
1151 rtx_insn
*fn_begin
, *seq
;
1153 bool fn_begin_outside_block
;
1154 rtx personality
= get_personality_function (current_function_decl
);
1156 fc
= crtl
->eh
.sjlj_fc
;
1160 /* We're storing this libcall's address into memory instead of
1161 calling it directly. Thus, we must call assemble_external_libcall
1162 here, as we can not depend on emit_library_call to do it for us. */
1163 assemble_external_libcall (personality
);
1164 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1165 emit_move_insn (mem
, personality
);
1167 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1168 if (crtl
->uses_eh_lsda
)
1173 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1174 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1175 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1176 emit_move_insn (mem
, sym
);
1179 emit_move_insn (mem
, const0_rtx
);
1183 #ifdef DONT_USE_BUILTIN_SETJMP
1185 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1186 TYPE_MODE (integer_type_node
), 1,
1187 plus_constant (Pmode
, XEXP (fc
, 0),
1188 sjlj_fc_jbuf_ofs
), Pmode
);
1190 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1191 TYPE_MODE (integer_type_node
), 0,
1192 dispatch_label
, REG_BR_PROB_BASE
/ 100);
1194 expand_builtin_setjmp_setup (plus_constant (Pmode
, XEXP (fc
, 0),
1200 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1201 1, XEXP (fc
, 0), Pmode
);
1206 /* ??? Instead of doing this at the beginning of the function,
1207 do this in a block that is at loop level 0 and dominates all
1208 can_throw_internal instructions. */
1210 fn_begin_outside_block
= true;
1211 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1212 if (NOTE_P (fn_begin
))
1214 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1216 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1217 fn_begin_outside_block
= false;
1220 if (fn_begin_outside_block
)
1221 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1223 emit_insn_after (seq
, fn_begin
);
1226 /* Call back from expand_function_end to know where we should put
1227 the call to unwind_sjlj_unregister_libfunc if needed. */
1230 sjlj_emit_function_exit_after (rtx_insn
*after
)
1232 crtl
->eh
.sjlj_exit_after
= after
;
1236 sjlj_emit_function_exit (void)
1238 rtx_insn
*seq
, *insn
;
1242 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1243 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1248 /* ??? Really this can be done in any block at loop level 0 that
1249 post-dominates all can_throw_internal instructions. This is
1250 the last possible moment. */
1252 insn
= crtl
->eh
.sjlj_exit_after
;
1254 insn
= NEXT_INSN (insn
);
1256 emit_insn_after (seq
, insn
);
1260 sjlj_emit_dispatch_table (rtx_code_label
*dispatch_label
, int num_dispatch
)
1262 enum machine_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1263 enum machine_mode filter_mode
= targetm
.eh_return_filter_mode ();
1265 rtx mem
, fc
, before
, exc_ptr_reg
, filter_reg
;
1267 rtx first_reachable_label
;
1272 vec
<tree
> dispatch_labels
= vNULL
;
1274 fc
= crtl
->eh
.sjlj_fc
;
1278 emit_label (dispatch_label
);
1280 #ifndef DONT_USE_BUILTIN_SETJMP
1281 expand_builtin_setjmp_receiver (dispatch_label
);
1283 /* The caller of expand_builtin_setjmp_receiver is responsible for
1284 making sure that the label doesn't vanish. The only other caller
1285 is the expander for __builtin_setjmp_receiver, which places this
1286 label on the nonlocal_goto_label list. Since we're modeling these
1287 CFG edges more exactly, we can use the forced_labels list instead. */
1288 LABEL_PRESERVE_P (dispatch_label
) = 1;
1290 = gen_rtx_INSN_LIST (VOIDmode
, dispatch_label
, forced_labels
);
1293 /* Load up exc_ptr and filter values from the function context. */
1294 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1295 if (unwind_word_mode
!= ptr_mode
)
1297 #ifdef POINTERS_EXTEND_UNSIGNED
1298 mem
= convert_memory_address (ptr_mode
, mem
);
1300 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1303 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1305 mem
= adjust_address (fc
, unwind_word_mode
,
1306 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1307 if (unwind_word_mode
!= filter_mode
)
1308 mem
= convert_to_mode (filter_mode
, mem
, 0);
1309 filter_reg
= force_reg (filter_mode
, mem
);
1311 /* Jump to one of the directly reachable regions. */
1314 first_reachable_label
= NULL
;
1316 /* If there's exactly one call site in the function, don't bother
1317 generating a switch statement. */
1318 if (num_dispatch
> 1)
1319 dispatch_labels
.create (num_dispatch
);
1321 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1322 if (lp
&& lp
->post_landing_pad
)
1329 lp
->landing_pad
= dispatch_label
;
1331 if (num_dispatch
> 1)
1333 tree t_label
, case_elt
, t
;
1335 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1336 t
= build_int_cst (integer_type_node
, disp_index
);
1337 case_elt
= build_case_label (t
, NULL
, t_label
);
1338 dispatch_labels
.quick_push (case_elt
);
1339 label
= label_rtx (t_label
);
1342 label
= gen_label_rtx ();
1344 if (disp_index
== 0)
1345 first_reachable_label
= label
;
1350 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1352 emit_move_insn (r
->filter_reg
, filter_reg
);
1354 seq2
= get_insns ();
1357 before
= label_rtx (lp
->post_landing_pad
);
1358 bb
= emit_to_new_bb_before (seq2
, before
);
1359 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1360 e
->count
= bb
->count
;
1361 e
->probability
= REG_BR_PROB_BASE
;
1364 struct loop
*loop
= bb
->next_bb
->loop_father
;
1365 /* If we created a pre-header block, add the new block to the
1366 outer loop, otherwise to the loop itself. */
1367 if (bb
->next_bb
== loop
->header
)
1368 add_bb_to_loop (bb
, loop_outer (loop
));
1370 add_bb_to_loop (bb
, loop
);
1371 /* ??? For multiple dispatches we will end up with edges
1372 from the loop tree root into this loop, making it a
1373 multiple-entry loop. Discard all affected loops. */
1374 if (num_dispatch
> 1)
1376 for (loop
= bb
->loop_father
;
1377 loop_outer (loop
); loop
= loop_outer (loop
))
1379 loop
->header
= NULL
;
1387 gcc_assert (disp_index
== num_dispatch
);
1389 if (num_dispatch
> 1)
1391 rtx disp
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1392 sjlj_fc_call_site_ofs
);
1393 expand_sjlj_dispatch_table (disp
, dispatch_labels
);
1399 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1400 if (num_dispatch
== 1)
1402 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1403 e
->count
= bb
->count
;
1404 e
->probability
= REG_BR_PROB_BASE
;
1407 struct loop
*loop
= bb
->next_bb
->loop_father
;
1408 /* If we created a pre-header block, add the new block to the
1409 outer loop, otherwise to the loop itself. */
1410 if (bb
->next_bb
== loop
->header
)
1411 add_bb_to_loop (bb
, loop_outer (loop
));
1413 add_bb_to_loop (bb
, loop
);
1418 /* We are not wiring up edges here, but as the dispatcher call
1419 is at function begin simply associate the block with the
1420 outermost (non-)loop. */
1422 add_bb_to_loop (bb
, current_loops
->tree_root
);
1427 sjlj_build_landing_pads (void)
1431 num_dispatch
= vec_safe_length (cfun
->eh
->lp_array
);
1432 if (num_dispatch
== 0)
1434 sjlj_lp_call_site_index
.safe_grow_cleared (num_dispatch
);
1436 num_dispatch
= sjlj_assign_call_site_values ();
1437 if (num_dispatch
> 0)
1439 rtx_code_label
*dispatch_label
= gen_label_rtx ();
1440 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1441 TYPE_MODE (sjlj_fc_type_node
),
1442 TYPE_ALIGN (sjlj_fc_type_node
));
1444 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1445 int_size_in_bytes (sjlj_fc_type_node
),
1448 sjlj_mark_call_sites ();
1449 sjlj_emit_function_enter (dispatch_label
);
1450 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1451 sjlj_emit_function_exit ();
1454 /* If we do not have any landing pads, we may still need to register a
1455 personality routine and (empty) LSDA to handle must-not-throw regions. */
1456 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
1458 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1459 TYPE_MODE (sjlj_fc_type_node
),
1460 TYPE_ALIGN (sjlj_fc_type_node
));
1462 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1463 int_size_in_bytes (sjlj_fc_type_node
),
1466 sjlj_mark_call_sites ();
1467 sjlj_emit_function_enter (NULL
);
1468 sjlj_emit_function_exit ();
1471 sjlj_lp_call_site_index
.release ();
1474 /* After initial rtl generation, call back to finish generating
1475 exception support code. */
1478 finish_eh_generation (void)
1482 /* Construct the landing pads. */
1483 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1484 sjlj_build_landing_pads ();
1486 dw2_build_landing_pads ();
1487 break_superblocks ();
1489 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1490 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1491 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->insns
.r
)
1492 commit_edge_insertions ();
1494 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1495 FOR_EACH_BB_FN (bb
, cfun
)
1501 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1503 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1504 if (e
->flags
& EDGE_EH
)
1507 /* We should not have generated any new throwing insns during this
1508 pass, and we should not have lost any EH edges, so we only need
1509 to handle two cases here:
1510 (1) reachable handler and an existing edge to post-landing-pad,
1511 (2) no reachable handler and no edge. */
1512 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1515 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1517 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1518 e
->flags
|= (CALL_P (BB_END (bb
))
1519 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1525 /* This section handles removing dead code for flow. */
1528 remove_eh_landing_pad (eh_landing_pad lp
)
1532 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1536 if (lp
->post_landing_pad
)
1537 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1538 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1541 /* Splice the EH region at PP from the region tree. */
1544 remove_eh_handler_splicer (eh_region
*pp
)
1546 eh_region region
= *pp
;
1549 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1551 if (lp
->post_landing_pad
)
1552 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1553 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1559 outer
= region
->outer
;
1561 *pp
= p
= region
->inner
;
1570 *pp
= region
->next_peer
;
1572 (*cfun
->eh
->region_array
)[region
->index
] = NULL
;
1575 /* Splice a single EH region REGION from the region tree.
1577 To unlink REGION, we need to find the pointer to it with a relatively
1578 expensive search in REGION's outer region. If you are going to
1579 remove a number of handlers, using remove_unreachable_eh_regions may
1580 be a better option. */
1583 remove_eh_handler (eh_region region
)
1585 eh_region
*pp
, *pp_start
, p
, outer
;
1587 outer
= region
->outer
;
1589 pp_start
= &outer
->inner
;
1591 pp_start
= &cfun
->eh
->region_tree
;
1592 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1595 remove_eh_handler_splicer (pp
);
1598 /* Worker for remove_unreachable_eh_regions.
1599 PP is a pointer to the region to start a region tree depth-first
1600 search from. R_REACHABLE is the set of regions that have to be
1604 remove_unreachable_eh_regions_worker (eh_region
*pp
, sbitmap r_reachable
)
1608 eh_region region
= *pp
;
1609 remove_unreachable_eh_regions_worker (®ion
->inner
, r_reachable
);
1610 if (!bitmap_bit_p (r_reachable
, region
->index
))
1611 remove_eh_handler_splicer (pp
);
1613 pp
= ®ion
->next_peer
;
1617 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1618 Do this by traversing the EH tree top-down and splice out regions that
1619 are not marked. By removing regions from the leaves, we avoid costly
1620 searches in the region tree. */
1623 remove_unreachable_eh_regions (sbitmap r_reachable
)
1625 remove_unreachable_eh_regions_worker (&cfun
->eh
->region_tree
, r_reachable
);
1628 /* Invokes CALLBACK for every exception handler landing pad label.
1629 Only used by reload hackery; should not be used by new code. */
1632 for_each_eh_label (void (*callback
) (rtx
))
1637 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1641 rtx lab
= lp
->landing_pad
;
1642 if (lab
&& LABEL_P (lab
))
1648 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1651 At the gimple level, we use LP_NR
1652 > 0 : The statement transfers to landing pad LP_NR
1653 = 0 : The statement is outside any EH region
1654 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1656 At the rtl level, we use LP_NR
1657 > 0 : The insn transfers to landing pad LP_NR
1658 = 0 : The insn cannot throw
1659 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1660 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1661 missing note: The insn is outside any EH region.
1663 ??? This difference probably ought to be avoided. We could stand
1664 to record nothrow for arbitrary gimple statements, and so avoid
1665 some moderately complex lookups in stmt_could_throw_p. Perhaps
1666 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1667 no-nonlocal-goto property should be recorded elsewhere as a bit
1668 on the call_insn directly. Perhaps we should make more use of
1669 attaching the trees to call_insns (reachable via symbol_ref in
1670 direct call cases) and just pull the data out of the trees. */
1673 make_reg_eh_region_note (rtx insn
, int ecf_flags
, int lp_nr
)
1676 if (ecf_flags
& ECF_NOTHROW
)
1678 else if (lp_nr
!= 0)
1679 value
= GEN_INT (lp_nr
);
1682 add_reg_note (insn
, REG_EH_REGION
, value
);
1685 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1686 nor perform a non-local goto. Replace the region note if it
1690 make_reg_eh_region_note_nothrow_nononlocal (rtx insn
)
1692 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1693 rtx intmin
= GEN_INT (INT_MIN
);
1696 XEXP (note
, 0) = intmin
;
1698 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1701 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1705 insn_could_throw_p (const_rtx insn
)
1707 if (!flag_exceptions
)
1711 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1712 return may_trap_p (PATTERN (insn
));
1716 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1717 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1718 to look for a note, or the note itself. */
1721 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx_insn
*first
, rtx last
)
1724 rtx note
= note_or_insn
;
1726 if (INSN_P (note_or_insn
))
1728 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1732 note
= XEXP (note
, 0);
1734 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1735 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1736 && insn_could_throw_p (insn
))
1737 add_reg_note (insn
, REG_EH_REGION
, note
);
1740 /* Likewise, but iterate backward. */
1743 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx_insn
*last
, rtx first
)
1746 rtx note
= note_or_insn
;
1748 if (INSN_P (note_or_insn
))
1750 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1754 note
= XEXP (note
, 0);
1756 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1757 if (insn_could_throw_p (insn
))
1758 add_reg_note (insn
, REG_EH_REGION
, note
);
1762 /* Extract all EH information from INSN. Return true if the insn
1763 was marked NOTHROW. */
1766 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1767 eh_landing_pad
*plp
)
1769 eh_landing_pad lp
= NULL
;
1775 if (! INSN_P (insn
))
1778 if (NONJUMP_INSN_P (insn
)
1779 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1780 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1782 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1785 ret
= !insn_could_throw_p (insn
);
1789 lp_nr
= INTVAL (XEXP (note
, 0));
1790 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1797 r
= (*cfun
->eh
->region_array
)[-lp_nr
];
1800 lp
= (*cfun
->eh
->lp_array
)[lp_nr
];
1810 /* Return the landing pad to which INSN may go, or NULL if it does not
1811 have a reachable landing pad within this function. */
1814 get_eh_landing_pad_from_rtx (const_rtx insn
)
1819 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1823 /* Return the region to which INSN may go, or NULL if it does not
1824 have a reachable region within this function. */
1827 get_eh_region_from_rtx (const_rtx insn
)
1832 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1836 /* Return true if INSN throws and is caught by something in this function. */
1839 can_throw_internal (const_rtx insn
)
1841 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1844 /* Return true if INSN throws and escapes from the current function. */
1847 can_throw_external (const_rtx insn
)
1853 if (! INSN_P (insn
))
1856 if (NONJUMP_INSN_P (insn
)
1857 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1859 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1860 int i
, n
= seq
->len ();
1862 for (i
= 0; i
< n
; i
++)
1863 if (can_throw_external (seq
->element (i
)))
1869 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1871 /* If we can't throw, we obviously can't throw external. */
1875 /* If we have an internal landing pad, then we're not external. */
1879 /* If we're not within an EH region, then we are external. */
1883 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1884 which don't always have landing pads. */
1885 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1889 /* Return true if INSN cannot throw at all. */
1892 insn_nothrow_p (const_rtx insn
)
1897 if (! INSN_P (insn
))
1900 if (NONJUMP_INSN_P (insn
)
1901 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1903 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1904 int i
, n
= seq
->len ();
1906 for (i
= 0; i
< n
; i
++)
1907 if (!insn_nothrow_p (seq
->element (i
)))
1913 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1916 /* Return true if INSN can perform a non-local goto. */
1917 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1920 can_nonlocal_goto (const_rtx insn
)
1922 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1924 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1925 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1931 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1934 set_nothrow_function_flags (void)
1940 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1941 something that can throw an exception. We specifically exempt
1942 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1943 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1946 crtl
->all_throwers_are_sibcalls
= 1;
1948 /* If we don't know that this implementation of the function will
1949 actually be used, then we must not set TREE_NOTHROW, since
1950 callers must not assume that this function does not throw. */
1951 if (TREE_NOTHROW (current_function_decl
))
1954 if (! flag_exceptions
)
1957 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1958 if (can_throw_external (insn
))
1962 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1964 crtl
->all_throwers_are_sibcalls
= 0;
1970 && (cgraph_node::get (current_function_decl
)->get_availability ()
1971 >= AVAIL_AVAILABLE
))
1973 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1974 struct cgraph_edge
*e
;
1975 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1976 e
->can_throw_external
= false;
1977 node
->set_nothrow_flag (true);
1980 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
1981 current_function_name ());
1988 const pass_data pass_data_set_nothrow_function_flags
=
1990 RTL_PASS
, /* type */
1991 "nothrow", /* name */
1992 OPTGROUP_NONE
, /* optinfo_flags */
1993 TV_NONE
, /* tv_id */
1994 0, /* properties_required */
1995 0, /* properties_provided */
1996 0, /* properties_destroyed */
1997 0, /* todo_flags_start */
1998 0, /* todo_flags_finish */
2001 class pass_set_nothrow_function_flags
: public rtl_opt_pass
2004 pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2005 : rtl_opt_pass (pass_data_set_nothrow_function_flags
, ctxt
)
2008 /* opt_pass methods: */
2009 virtual unsigned int execute (function
*)
2011 return set_nothrow_function_flags ();
2014 }; // class pass_set_nothrow_function_flags
2019 make_pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2021 return new pass_set_nothrow_function_flags (ctxt
);
2025 /* Various hooks for unwind library. */
2027 /* Expand the EH support builtin functions:
2028 __builtin_eh_pointer and __builtin_eh_filter. */
2031 expand_builtin_eh_common (tree region_nr_t
)
2033 HOST_WIDE_INT region_nr
;
2036 gcc_assert (tree_fits_shwi_p (region_nr_t
));
2037 region_nr
= tree_to_shwi (region_nr_t
);
2039 region
= (*cfun
->eh
->region_array
)[region_nr
];
2041 /* ??? We shouldn't have been able to delete a eh region without
2042 deleting all the code that depended on it. */
2043 gcc_assert (region
!= NULL
);
2048 /* Expand to the exc_ptr value from the given eh region. */
2051 expand_builtin_eh_pointer (tree exp
)
2054 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2055 if (region
->exc_ptr_reg
== NULL
)
2056 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2057 return region
->exc_ptr_reg
;
2060 /* Expand to the filter value from the given eh region. */
2063 expand_builtin_eh_filter (tree exp
)
2066 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2067 if (region
->filter_reg
== NULL
)
2068 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
2069 return region
->filter_reg
;
2072 /* Copy the exc_ptr and filter values from one landing pad's registers
2073 to another. This is used to inline the resx statement. */
2076 expand_builtin_eh_copy_values (tree exp
)
2079 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2081 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
2082 enum machine_mode fmode
= targetm
.eh_return_filter_mode ();
2084 if (dst
->exc_ptr_reg
== NULL
)
2085 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2086 if (src
->exc_ptr_reg
== NULL
)
2087 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2089 if (dst
->filter_reg
== NULL
)
2090 dst
->filter_reg
= gen_reg_rtx (fmode
);
2091 if (src
->filter_reg
== NULL
)
2092 src
->filter_reg
= gen_reg_rtx (fmode
);
2094 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2095 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2100 /* Do any necessary initialization to access arbitrary stack frames.
2101 On the SPARC, this means flushing the register windows. */
2104 expand_builtin_unwind_init (void)
2106 /* Set this so all the registers get saved in our frame; we need to be
2107 able to copy the saved values for any registers from frames we unwind. */
2108 crtl
->saves_all_registers
= 1;
2110 #ifdef SETUP_FRAME_ADDRESSES
2111 SETUP_FRAME_ADDRESSES ();
2115 /* Map a non-negative number to an eh return data register number; expands
2116 to -1 if no return data register is associated with the input number.
2117 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2120 expand_builtin_eh_return_data_regno (tree exp
)
2122 tree which
= CALL_EXPR_ARG (exp
, 0);
2123 unsigned HOST_WIDE_INT iwhich
;
2125 if (TREE_CODE (which
) != INTEGER_CST
)
2127 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2131 iwhich
= tree_to_uhwi (which
);
2132 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2133 if (iwhich
== INVALID_REGNUM
)
2136 #ifdef DWARF_FRAME_REGNUM
2137 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2139 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2142 return GEN_INT (iwhich
);
2145 /* Given a value extracted from the return address register or stack slot,
2146 return the actual address encoded in that value. */
2149 expand_builtin_extract_return_addr (tree addr_tree
)
2151 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2153 if (GET_MODE (addr
) != Pmode
2154 && GET_MODE (addr
) != VOIDmode
)
2156 #ifdef POINTERS_EXTEND_UNSIGNED
2157 addr
= convert_memory_address (Pmode
, addr
);
2159 addr
= convert_to_mode (Pmode
, addr
, 0);
2163 /* First mask out any unwanted bits. */
2164 #ifdef MASK_RETURN_ADDR
2165 expand_and (Pmode
, addr
, MASK_RETURN_ADDR
, addr
);
2168 /* Then adjust to find the real return address. */
2169 #if defined (RETURN_ADDR_OFFSET)
2170 addr
= plus_constant (Pmode
, addr
, RETURN_ADDR_OFFSET
);
2176 /* Given an actual address in addr_tree, do any necessary encoding
2177 and return the value to be stored in the return address register or
2178 stack slot so the epilogue will return to that address. */
2181 expand_builtin_frob_return_addr (tree addr_tree
)
2183 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2185 addr
= convert_memory_address (Pmode
, addr
);
2187 #ifdef RETURN_ADDR_OFFSET
2188 addr
= force_reg (Pmode
, addr
);
2189 addr
= plus_constant (Pmode
, addr
, -RETURN_ADDR_OFFSET
);
2195 /* Set up the epilogue with the magic bits we'll need to return to the
2196 exception handler. */
2199 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2204 #ifdef EH_RETURN_STACKADJ_RTX
2205 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2206 VOIDmode
, EXPAND_NORMAL
);
2207 tmp
= convert_memory_address (Pmode
, tmp
);
2208 if (!crtl
->eh
.ehr_stackadj
)
2209 crtl
->eh
.ehr_stackadj
= copy_to_reg (tmp
);
2210 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2211 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2214 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2215 VOIDmode
, EXPAND_NORMAL
);
2216 tmp
= convert_memory_address (Pmode
, tmp
);
2217 if (!crtl
->eh
.ehr_handler
)
2218 crtl
->eh
.ehr_handler
= copy_to_reg (tmp
);
2219 else if (tmp
!= crtl
->eh
.ehr_handler
)
2220 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2222 if (!crtl
->eh
.ehr_label
)
2223 crtl
->eh
.ehr_label
= gen_label_rtx ();
2224 emit_jump (crtl
->eh
.ehr_label
);
2227 /* Expand __builtin_eh_return. This exit path from the function loads up
2228 the eh return data registers, adjusts the stack, and branches to a
2229 given PC other than the normal return address. */
2232 expand_eh_return (void)
2234 rtx_code_label
*around_label
;
2236 if (! crtl
->eh
.ehr_label
)
2239 crtl
->calls_eh_return
= 1;
2241 #ifdef EH_RETURN_STACKADJ_RTX
2242 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2245 around_label
= gen_label_rtx ();
2246 emit_jump (around_label
);
2248 emit_label (crtl
->eh
.ehr_label
);
2249 clobber_return_register ();
2251 #ifdef EH_RETURN_STACKADJ_RTX
2252 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2255 #ifdef HAVE_eh_return
2257 emit_insn (gen_eh_return (crtl
->eh
.ehr_handler
));
2261 #ifdef EH_RETURN_HANDLER_RTX
2262 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2264 error ("__builtin_eh_return not supported on this target");
2268 emit_label (around_label
);
2271 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2272 POINTERS_EXTEND_UNSIGNED and return it. */
2275 expand_builtin_extend_pointer (tree addr_tree
)
2277 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2280 #ifdef POINTERS_EXTEND_UNSIGNED
2281 extend
= POINTERS_EXTEND_UNSIGNED
;
2283 /* The previous EH code did an unsigned extend by default, so we do this also
2288 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2292 add_action_record (action_hash_type
*ar_hash
, int filter
, int next
)
2294 struct action_record
**slot
, *new_ar
, tmp
;
2296 tmp
.filter
= filter
;
2298 slot
= ar_hash
->find_slot (&tmp
, INSERT
);
2300 if ((new_ar
= *slot
) == NULL
)
2302 new_ar
= XNEW (struct action_record
);
2303 new_ar
->offset
= crtl
->eh
.action_record_data
->length () + 1;
2304 new_ar
->filter
= filter
;
2305 new_ar
->next
= next
;
2308 /* The filter value goes in untouched. The link to the next
2309 record is a "self-relative" byte offset, or zero to indicate
2310 that there is no next record. So convert the absolute 1 based
2311 indices we've been carrying around into a displacement. */
2313 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2315 next
-= crtl
->eh
.action_record_data
->length () + 1;
2316 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2319 return new_ar
->offset
;
2323 collect_one_action_chain (action_hash_type
*ar_hash
, eh_region region
)
2327 /* If we've reached the top of the region chain, then we have
2328 no actions, and require no landing pad. */
2332 switch (region
->type
)
2337 /* A cleanup adds a zero filter to the beginning of the chain, but
2338 there are special cases to look out for. If there are *only*
2339 cleanups along a path, then it compresses to a zero action.
2340 Further, if there are multiple cleanups along a path, we only
2341 need to represent one of them, as that is enough to trigger
2342 entry to the landing pad at runtime. */
2343 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2346 for (r
= region
->outer
; r
; r
= r
->outer
)
2347 if (r
->type
== ERT_CLEANUP
)
2349 return add_action_record (ar_hash
, 0, next
);
2356 /* Process the associated catch regions in reverse order.
2357 If there's a catch-all handler, then we don't need to
2358 search outer regions. Use a magic -3 value to record
2359 that we haven't done the outer search. */
2361 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2363 if (c
->type_list
== NULL
)
2365 /* Retrieve the filter from the head of the filter list
2366 where we have stored it (see assign_filter_values). */
2367 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2368 next
= add_action_record (ar_hash
, filter
, 0);
2372 /* Once the outer search is done, trigger an action record for
2373 each filter we have. */
2378 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2380 /* If there is no next action, terminate the chain. */
2383 /* If all outer actions are cleanups or must_not_throw,
2384 we'll have no action record for it, since we had wanted
2385 to encode these states in the call-site record directly.
2386 Add a cleanup action to the chain to catch these. */
2388 next
= add_action_record (ar_hash
, 0, 0);
2391 flt_node
= c
->filter_list
;
2392 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2394 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2395 next
= add_action_record (ar_hash
, filter
, next
);
2402 case ERT_ALLOWED_EXCEPTIONS
:
2403 /* An exception specification adds its filter to the
2404 beginning of the chain. */
2405 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2407 /* If there is no next action, terminate the chain. */
2410 /* If all outer actions are cleanups or must_not_throw,
2411 we'll have no action record for it, since we had wanted
2412 to encode these states in the call-site record directly.
2413 Add a cleanup action to the chain to catch these. */
2415 next
= add_action_record (ar_hash
, 0, 0);
2417 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2419 case ERT_MUST_NOT_THROW
:
2420 /* A must-not-throw region with no inner handlers or cleanups
2421 requires no call-site entry. Note that this differs from
2422 the no handler or cleanup case in that we do require an lsda
2423 to be generated. Return a magic -2 value to record this. */
2431 add_call_site (rtx landing_pad
, int action
, int section
)
2433 call_site_record record
;
2435 record
= ggc_alloc
<call_site_record_d
> ();
2436 record
->landing_pad
= landing_pad
;
2437 record
->action
= action
;
2439 vec_safe_push (crtl
->eh
.call_site_record_v
[section
], record
);
2441 return call_site_base
+ crtl
->eh
.call_site_record_v
[section
]->length () - 1;
2445 emit_note_eh_region_end (rtx_insn
*insn
)
2447 rtx_insn
*next
= NEXT_INSN (insn
);
2449 /* Make sure we do not split a call and its corresponding
2450 CALL_ARG_LOCATION note. */
2451 if (next
&& NOTE_P (next
)
2452 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
2455 return emit_note_after (NOTE_INSN_EH_REGION_END
, insn
);
2458 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2459 The new note numbers will not refer to region numbers, but
2460 instead to call site entries. */
2463 convert_to_eh_region_ranges (void)
2468 action_hash_type
ar_hash (31);
2469 int last_action
= -3;
2470 rtx_insn
*last_action_insn
= NULL
;
2471 rtx last_landing_pad
= NULL_RTX
;
2472 rtx_insn
*first_no_action_insn
= NULL
;
2475 rtx section_switch_note
= NULL_RTX
;
2476 rtx_insn
*first_no_action_insn_before_switch
= NULL
;
2477 rtx_insn
*last_no_action_insn_before_switch
= NULL
;
2478 int saved_call_site_base
= call_site_base
;
2480 vec_alloc (crtl
->eh
.action_record_data
, 64);
2482 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2489 rtx this_landing_pad
;
2492 if (NONJUMP_INSN_P (insn
)
2493 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2494 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2496 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2500 this_action
= collect_one_action_chain (&ar_hash
, region
);
2504 /* Existence of catch handlers, or must-not-throw regions
2505 implies that an lsda is needed (even if empty). */
2506 if (this_action
!= -1)
2507 crtl
->uses_eh_lsda
= 1;
2509 /* Delay creation of region notes for no-action regions
2510 until we're sure that an lsda will be required. */
2511 else if (last_action
== -3)
2513 first_no_action_insn
= iter
;
2517 if (this_action
>= 0)
2518 this_landing_pad
= lp
->landing_pad
;
2520 this_landing_pad
= NULL_RTX
;
2522 /* Differing actions or landing pads implies a change in call-site
2523 info, which implies some EH_REGION note should be emitted. */
2524 if (last_action
!= this_action
2525 || last_landing_pad
!= this_landing_pad
)
2527 /* If there is a queued no-action region in the other section
2528 with hot/cold partitioning, emit it now. */
2529 if (first_no_action_insn_before_switch
)
2531 gcc_assert (this_action
!= -1
2532 && last_action
== (first_no_action_insn
2534 call_site
= add_call_site (NULL_RTX
, 0, 0);
2535 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2536 first_no_action_insn_before_switch
);
2537 NOTE_EH_HANDLER (note
) = call_site
;
2539 = emit_note_eh_region_end (last_no_action_insn_before_switch
);
2540 NOTE_EH_HANDLER (note
) = call_site
;
2541 gcc_assert (last_action
!= -3
2542 || (last_action_insn
2543 == last_no_action_insn_before_switch
));
2544 first_no_action_insn_before_switch
= NULL
;
2545 last_no_action_insn_before_switch
= NULL
;
2548 /* If we'd not seen a previous action (-3) or the previous
2549 action was must-not-throw (-2), then we do not need an
2551 if (last_action
>= -1)
2553 /* If we delayed the creation of the begin, do it now. */
2554 if (first_no_action_insn
)
2556 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2557 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2558 first_no_action_insn
);
2559 NOTE_EH_HANDLER (note
) = call_site
;
2560 first_no_action_insn
= NULL
;
2563 note
= emit_note_eh_region_end (last_action_insn
);
2564 NOTE_EH_HANDLER (note
) = call_site
;
2567 /* If the new action is must-not-throw, then no region notes
2569 if (this_action
>= -1)
2571 call_site
= add_call_site (this_landing_pad
,
2572 this_action
< 0 ? 0 : this_action
,
2574 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2575 NOTE_EH_HANDLER (note
) = call_site
;
2578 last_action
= this_action
;
2579 last_landing_pad
= this_landing_pad
;
2581 last_action_insn
= iter
;
2583 else if (NOTE_P (iter
)
2584 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2586 gcc_assert (section_switch_note
== NULL_RTX
);
2587 gcc_assert (flag_reorder_blocks_and_partition
);
2588 section_switch_note
= iter
;
2589 if (first_no_action_insn
)
2591 first_no_action_insn_before_switch
= first_no_action_insn
;
2592 last_no_action_insn_before_switch
= last_action_insn
;
2593 first_no_action_insn
= NULL
;
2594 gcc_assert (last_action
== -1);
2597 /* Force closing of current EH region before section switch and
2598 opening a new one afterwards. */
2599 else if (last_action
!= -3)
2600 last_landing_pad
= pc_rtx
;
2601 if (crtl
->eh
.call_site_record_v
[cur_sec
])
2602 call_site_base
+= crtl
->eh
.call_site_record_v
[cur_sec
]->length ();
2604 gcc_assert (crtl
->eh
.call_site_record_v
[cur_sec
] == NULL
);
2605 vec_alloc (crtl
->eh
.call_site_record_v
[cur_sec
], 10);
2608 if (last_action
>= -1 && ! first_no_action_insn
)
2610 note
= emit_note_eh_region_end (last_action_insn
);
2611 NOTE_EH_HANDLER (note
) = call_site
;
2614 call_site_base
= saved_call_site_base
;
2621 const pass_data pass_data_convert_to_eh_region_ranges
=
2623 RTL_PASS
, /* type */
2624 "eh_ranges", /* name */
2625 OPTGROUP_NONE
, /* optinfo_flags */
2626 TV_NONE
, /* tv_id */
2627 0, /* properties_required */
2628 0, /* properties_provided */
2629 0, /* properties_destroyed */
2630 0, /* todo_flags_start */
2631 0, /* todo_flags_finish */
2634 class pass_convert_to_eh_region_ranges
: public rtl_opt_pass
2637 pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2638 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges
, ctxt
)
2641 /* opt_pass methods: */
2642 virtual bool gate (function
*);
2643 virtual unsigned int execute (function
*)
2645 return convert_to_eh_region_ranges ();
2648 }; // class pass_convert_to_eh_region_ranges
2651 pass_convert_to_eh_region_ranges::gate (function
*)
2653 /* Nothing to do for SJLJ exceptions or if no regions created. */
2654 if (cfun
->eh
->region_tree
== NULL
)
2656 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2664 make_pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2666 return new pass_convert_to_eh_region_ranges (ctxt
);
2670 push_uleb128 (vec
<uchar
, va_gc
> **data_area
, unsigned int value
)
2674 unsigned char byte
= value
& 0x7f;
2678 vec_safe_push (*data_area
, byte
);
2684 push_sleb128 (vec
<uchar
, va_gc
> **data_area
, int value
)
2691 byte
= value
& 0x7f;
2693 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2694 || (value
== -1 && (byte
& 0x40) != 0));
2697 vec_safe_push (*data_area
, byte
);
2703 #ifndef HAVE_AS_LEB128
2705 dw2_size_of_call_site_table (int section
)
2707 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2708 int size
= n
* (4 + 4 + 4);
2711 for (i
= 0; i
< n
; ++i
)
2713 struct call_site_record_d
*cs
=
2714 (*crtl
->eh
.call_site_record_v
[section
])[i
];
2715 size
+= size_of_uleb128 (cs
->action
);
2722 sjlj_size_of_call_site_table (void)
2724 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2728 for (i
= 0; i
< n
; ++i
)
2730 struct call_site_record_d
*cs
=
2731 (*crtl
->eh
.call_site_record_v
[0])[i
];
2732 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2733 size
+= size_of_uleb128 (cs
->action
);
2741 dw2_output_call_site_table (int cs_format
, int section
)
2743 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2748 begin
= current_function_func_begin_label
;
2749 else if (first_function_block_is_cold
)
2750 begin
= crtl
->subsections
.hot_section_label
;
2752 begin
= crtl
->subsections
.cold_section_label
;
2754 for (i
= 0; i
< n
; ++i
)
2756 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[section
])[i
];
2757 char reg_start_lab
[32];
2758 char reg_end_lab
[32];
2759 char landing_pad_lab
[32];
2761 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2762 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2764 if (cs
->landing_pad
)
2765 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2766 CODE_LABEL_NUMBER (cs
->landing_pad
));
2768 /* ??? Perhaps use insn length scaling if the assembler supports
2769 generic arithmetic. */
2770 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2771 data4 if the function is small enough. */
2772 if (cs_format
== DW_EH_PE_uleb128
)
2774 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2775 "region %d start", i
);
2776 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2778 if (cs
->landing_pad
)
2779 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2782 dw2_asm_output_data_uleb128 (0, "landing pad");
2786 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2787 "region %d start", i
);
2788 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2789 if (cs
->landing_pad
)
2790 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2793 dw2_asm_output_data (4, 0, "landing pad");
2795 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2798 call_site_base
+= n
;
2802 sjlj_output_call_site_table (void)
2804 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2807 for (i
= 0; i
< n
; ++i
)
2809 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[0])[i
];
2811 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2812 "region %d landing pad", i
);
2813 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2816 call_site_base
+= n
;
2819 /* Switch to the section that should be used for exception tables. */
2822 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2826 if (exception_section
)
2827 s
= exception_section
;
2830 /* Compute the section and cache it into exception_section,
2831 unless it depends on the function name. */
2832 if (targetm_common
.have_named_sections
)
2836 if (EH_TABLES_CAN_BE_READ_ONLY
)
2839 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2840 flags
= ((! flag_pic
2841 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2842 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2843 ? 0 : SECTION_WRITE
);
2846 flags
= SECTION_WRITE
;
2848 #ifdef HAVE_LD_EH_GC_SECTIONS
2849 if (flag_function_sections
2850 || (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
))
2852 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2853 /* The EH table must match the code section, so only mark
2854 it linkonce if we have COMDAT groups to tie them together. */
2855 if (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
)
2856 flags
|= SECTION_LINKONCE
;
2857 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2858 s
= get_section (section_name
, flags
, current_function_decl
);
2859 free (section_name
);
2864 = s
= get_section (".gcc_except_table", flags
, NULL
);
2868 = s
= flag_pic
? data_section
: readonly_data_section
;
2871 switch_to_section (s
);
2875 /* Output a reference from an exception table to the type_info object TYPE.
2876 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2880 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2883 bool is_public
= true;
2885 if (type
== NULL_TREE
)
2889 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2890 runtime types so TYPE should already be a runtime type
2891 reference. When pass_ipa_free_lang data is made a default
2892 pass, we can then remove the call to lookup_type_for_runtime
2895 type
= lookup_type_for_runtime (type
);
2897 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2899 /* Let cgraph know that the rtti decl is used. Not all of the
2900 paths below go through assemble_integer, which would take
2901 care of this for us. */
2903 if (TREE_CODE (type
) == ADDR_EXPR
)
2905 type
= TREE_OPERAND (type
, 0);
2906 if (TREE_CODE (type
) == VAR_DECL
)
2907 is_public
= TREE_PUBLIC (type
);
2910 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2913 /* Allow the target to override the type table entry format. */
2914 if (targetm
.asm_out
.ttype (value
))
2917 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2918 assemble_integer (value
, tt_format_size
,
2919 tt_format_size
* BITS_PER_UNIT
, 1);
2921 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2925 output_one_function_exception_table (int section
)
2927 int tt_format
, cs_format
, lp_format
, i
;
2928 #ifdef HAVE_AS_LEB128
2929 char ttype_label
[32];
2930 char cs_after_size_label
[32];
2931 char cs_end_label
[32];
2936 int tt_format_size
= 0;
2938 have_tt_data
= (vec_safe_length (cfun
->eh
->ttype_data
)
2939 || (targetm
.arm_eabi_unwinder
2940 ? vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
)
2941 : vec_safe_length (cfun
->eh
->ehspec_data
.other
)));
2943 /* Indicate the format of the @TType entries. */
2945 tt_format
= DW_EH_PE_omit
;
2948 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2949 #ifdef HAVE_AS_LEB128
2950 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2951 section
? "LLSDATTC" : "LLSDATT",
2952 current_function_funcdef_no
);
2954 tt_format_size
= size_of_encoded_value (tt_format
);
2956 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2959 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2960 current_function_funcdef_no
);
2962 /* The LSDA header. */
2964 /* Indicate the format of the landing pad start pointer. An omitted
2965 field implies @LPStart == @Start. */
2966 /* Currently we always put @LPStart == @Start. This field would
2967 be most useful in moving the landing pads completely out of
2968 line to another section, but it could also be used to minimize
2969 the size of uleb128 landing pad offsets. */
2970 lp_format
= DW_EH_PE_omit
;
2971 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
2972 eh_data_format_name (lp_format
));
2974 /* @LPStart pointer would go here. */
2976 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
2977 eh_data_format_name (tt_format
));
2979 #ifndef HAVE_AS_LEB128
2980 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2981 call_site_len
= sjlj_size_of_call_site_table ();
2983 call_site_len
= dw2_size_of_call_site_table (section
);
2986 /* A pc-relative 4-byte displacement to the @TType data. */
2989 #ifdef HAVE_AS_LEB128
2990 char ttype_after_disp_label
[32];
2991 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
2992 section
? "LLSDATTDC" : "LLSDATTD",
2993 current_function_funcdef_no
);
2994 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
2995 "@TType base offset");
2996 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
2998 /* Ug. Alignment queers things. */
2999 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3001 before_disp
= 1 + 1;
3002 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3004 + vec_safe_length (crtl
->eh
.action_record_data
)
3005 + (vec_safe_length (cfun
->eh
->ttype_data
)
3011 unsigned int disp_size
, pad
;
3014 disp_size
= size_of_uleb128 (disp
);
3015 pad
= before_disp
+ disp_size
+ after_disp
;
3016 if (pad
% tt_format_size
)
3017 pad
= tt_format_size
- (pad
% tt_format_size
);
3020 disp
= after_disp
+ pad
;
3022 while (disp
!= last_disp
);
3024 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3028 /* Indicate the format of the call-site offsets. */
3029 #ifdef HAVE_AS_LEB128
3030 cs_format
= DW_EH_PE_uleb128
;
3032 cs_format
= DW_EH_PE_udata4
;
3034 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3035 eh_data_format_name (cs_format
));
3037 #ifdef HAVE_AS_LEB128
3038 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3039 section
? "LLSDACSBC" : "LLSDACSB",
3040 current_function_funcdef_no
);
3041 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3042 section
? "LLSDACSEC" : "LLSDACSE",
3043 current_function_funcdef_no
);
3044 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3045 "Call-site table length");
3046 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3047 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3048 sjlj_output_call_site_table ();
3050 dw2_output_call_site_table (cs_format
, section
);
3051 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3053 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3054 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3055 sjlj_output_call_site_table ();
3057 dw2_output_call_site_table (cs_format
, section
);
3060 /* ??? Decode and interpret the data for flag_debug_asm. */
3063 FOR_EACH_VEC_ELT (*crtl
->eh
.action_record_data
, i
, uc
)
3064 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3068 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3070 i
= vec_safe_length (cfun
->eh
->ttype_data
);
3073 tree type
= (*cfun
->eh
->ttype_data
)[i
];
3074 output_ttype (type
, tt_format
, tt_format_size
);
3077 #ifdef HAVE_AS_LEB128
3079 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3082 /* ??? Decode and interpret the data for flag_debug_asm. */
3083 if (targetm
.arm_eabi_unwinder
)
3087 vec_safe_iterate (cfun
->eh
->ehspec_data
.arm_eabi
, i
, &type
); ++i
)
3088 output_ttype (type
, tt_format
, tt_format_size
);
3094 vec_safe_iterate (cfun
->eh
->ehspec_data
.other
, i
, &uc
); ++i
)
3095 dw2_asm_output_data (1, uc
,
3096 i
? NULL
: "Exception specification table");
3101 output_function_exception_table (const char *fnname
)
3103 rtx personality
= get_personality_function (current_function_decl
);
3105 /* Not all functions need anything. */
3106 if (! crtl
->uses_eh_lsda
)
3111 assemble_external_libcall (personality
);
3113 if (targetm
.asm_out
.emit_except_personality
)
3114 targetm
.asm_out
.emit_except_personality (personality
);
3117 switch_to_exception_section (fnname
);
3119 /* If the target wants a label to begin the table, emit it here. */
3120 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3122 output_one_function_exception_table (0);
3123 if (crtl
->eh
.call_site_record_v
[1])
3124 output_one_function_exception_table (1);
3126 switch_to_section (current_function_section ());
3130 set_eh_throw_stmt_table (function
*fun
, hash_map
<gimple
, int> *table
)
3132 fun
->eh
->throw_stmt_table
= table
;
3135 hash_map
<gimple
, int> *
3136 get_eh_throw_stmt_table (struct function
*fun
)
3138 return fun
->eh
->throw_stmt_table
;
3141 /* Determine if the function needs an EH personality function. */
3143 enum eh_personality_kind
3144 function_needs_eh_personality (struct function
*fn
)
3146 enum eh_personality_kind kind
= eh_personality_none
;
3149 FOR_ALL_EH_REGION_FN (i
, fn
)
3154 /* Can do with any personality including the generic C one. */
3155 kind
= eh_personality_any
;
3159 case ERT_ALLOWED_EXCEPTIONS
:
3160 /* Always needs a EH personality function. The generic C
3161 personality doesn't handle these even for empty type lists. */
3162 return eh_personality_lang
;
3164 case ERT_MUST_NOT_THROW
:
3165 /* Always needs a EH personality function. The language may specify
3166 what abort routine that must be used, e.g. std::terminate. */
3167 return eh_personality_lang
;
3174 /* Dump EH information to OUT. */
3177 dump_eh_tree (FILE * out
, struct function
*fun
)
3181 static const char *const type_name
[] = {
3182 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3185 i
= fun
->eh
->region_tree
;
3189 fprintf (out
, "Eh tree:\n");
3192 fprintf (out
, " %*s %i %s", depth
* 2, "",
3193 i
->index
, type_name
[(int) i
->type
]);
3195 if (i
->landing_pads
)
3199 fprintf (out
, " land:");
3200 if (current_ir_type () == IR_GIMPLE
)
3202 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3204 fprintf (out
, "{%i,", lp
->index
);
3205 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3213 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3215 fprintf (out
, "{%i,", lp
->index
);
3216 if (lp
->landing_pad
)
3217 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3218 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3220 fprintf (out
, "(nil),");
3221 if (lp
->post_landing_pad
)
3223 rtx lab
= label_rtx (lp
->post_landing_pad
);
3224 fprintf (out
, "%i%s}", INSN_UID (lab
),
3225 NOTE_P (lab
) ? "(del)" : "");
3228 fprintf (out
, "(nil)}");
3238 case ERT_MUST_NOT_THROW
:
3244 fprintf (out
, " catch:");
3245 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3250 fprintf (out
, "lab:");
3251 print_generic_expr (out
, c
->label
, 0);
3254 print_generic_expr (out
, c
->type_list
, 0);
3262 case ERT_ALLOWED_EXCEPTIONS
:
3263 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3264 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3269 /* If there are sub-regions, process them. */
3271 i
= i
->inner
, depth
++;
3272 /* If there are peers, process them. */
3273 else if (i
->next_peer
)
3275 /* Otherwise, step back up the tree to the next peer. */
3285 while (i
->next_peer
== NULL
);
3291 /* Dump the EH tree for FN on stderr. */
3294 debug_eh_tree (struct function
*fn
)
3296 dump_eh_tree (stderr
, fn
);
3299 /* Verify invariants on EH datastructures. */
3302 verify_eh_tree (struct function
*fun
)
3305 int nvisited_lp
, nvisited_r
;
3306 int count_lp
, count_r
, depth
, i
;
3310 if (!fun
->eh
->region_tree
)
3314 for (i
= 1; vec_safe_iterate (fun
->eh
->region_array
, i
, &r
); ++i
)
3321 error ("region_array is corrupted for region %i", r
->index
);
3327 for (i
= 1; vec_safe_iterate (fun
->eh
->lp_array
, i
, &lp
); ++i
)
3334 error ("lp_array is corrupted for lp %i", lp
->index
);
3339 depth
= nvisited_lp
= nvisited_r
= 0;
3341 r
= fun
->eh
->region_tree
;
3344 if ((*fun
->eh
->region_array
)[r
->index
] != r
)
3346 error ("region_array is corrupted for region %i", r
->index
);
3349 if (r
->outer
!= outer
)
3351 error ("outer block of region %i is wrong", r
->index
);
3356 error ("negative nesting depth of region %i", r
->index
);
3361 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3363 if ((*fun
->eh
->lp_array
)[lp
->index
] != lp
)
3365 error ("lp_array is corrupted for lp %i", lp
->index
);
3368 if (lp
->region
!= r
)
3370 error ("region of lp %i is wrong", lp
->index
);
3377 outer
= r
, r
= r
->inner
, depth
++;
3378 else if (r
->next_peer
)
3390 while (r
->next_peer
== NULL
);
3397 error ("tree list ends on depth %i", depth
);
3400 if (count_r
!= nvisited_r
)
3402 error ("region_array does not match region_tree");
3405 if (count_lp
!= nvisited_lp
)
3407 error ("lp_array does not match region_tree");
3413 dump_eh_tree (stderr
, fun
);
3414 internal_error ("verify_eh_tree failed");
3418 #include "gt-except.h"