1 /* Implements exception handling.
2 Copyright (C) 1989-2015 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"
116 #include "cfghooks.h"
120 #include "fold-const.h"
121 #include "stringpool.h"
122 #include "stor-layout.h"
124 #include "insn-codes.h"
126 #include "insn-config.h"
131 #include "emit-rtl.h"
135 #include "libfuncs.h"
138 #include "dwarf2asm.h"
139 #include "dwarf2out.h"
145 #include "common/common-target.h"
146 #include "langhooks.h"
149 #include "diagnostic.h"
150 #include "tree-pretty-print.h"
151 #include "tree-pass.h"
153 #include "builtins.h"
154 #include "tree-hash-traits.h"
156 static GTY(()) int call_site_base
;
158 static GTY (()) hash_map
<tree_hash
, tree
> *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
: free_ptr_hash
<action_record
>
198 static inline hashval_t
hash (const action_record
*);
199 static inline bool equal (const action_record
*, const action_record
*);
203 action_record_hasher::hash (const action_record
*entry
)
205 return entry
->next
* 1009 + entry
->filter
;
209 action_record_hasher::equal (const action_record
*entry
,
210 const action_record
*data
)
212 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
215 typedef hash_table
<action_record_hasher
> action_hash_type
;
217 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
220 static void dw2_build_landing_pads (void);
222 static int collect_one_action_chain (action_hash_type
*, eh_region
);
223 static int add_call_site (rtx
, int, int);
225 static void push_uleb128 (vec
<uchar
, va_gc
> **, unsigned int);
226 static void push_sleb128 (vec
<uchar
, va_gc
> **, int);
227 #ifndef HAVE_AS_LEB128
228 static int dw2_size_of_call_site_table (int);
229 static int sjlj_size_of_call_site_table (void);
231 static void dw2_output_call_site_table (int, int);
232 static void sjlj_output_call_site_table (void);
238 if (! flag_exceptions
)
241 type_to_runtime_map
= hash_map
<tree_hash
, tree
>::create_ggc (31);
243 /* Create the SjLj_Function_Context structure. This should match
244 the definition in unwind-sjlj.c. */
245 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
247 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
249 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
251 f_prev
= build_decl (BUILTINS_LOCATION
,
252 FIELD_DECL
, get_identifier ("__prev"),
253 build_pointer_type (sjlj_fc_type_node
));
254 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
256 f_cs
= build_decl (BUILTINS_LOCATION
,
257 FIELD_DECL
, get_identifier ("__call_site"),
259 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
261 tmp
= build_index_type (size_int (4 - 1));
262 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
263 (targetm
.unwind_word_mode (), 1),
265 f_data
= build_decl (BUILTINS_LOCATION
,
266 FIELD_DECL
, get_identifier ("__data"), tmp
);
267 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
269 f_per
= build_decl (BUILTINS_LOCATION
,
270 FIELD_DECL
, get_identifier ("__personality"),
272 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
274 f_lsda
= build_decl (BUILTINS_LOCATION
,
275 FIELD_DECL
, get_identifier ("__lsda"),
277 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
279 #ifdef DONT_USE_BUILTIN_SETJMP
281 tmp
= size_int (JMP_BUF_SIZE
- 1);
283 /* Should be large enough for most systems, if it is not,
284 JMP_BUF_SIZE should be defined with the proper value. It will
285 also tend to be larger than necessary for most systems, a more
286 optimal port will define JMP_BUF_SIZE. */
287 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
290 /* Compute a minimally sized jump buffer. We need room to store at
291 least 3 pointers - stack pointer, frame pointer and return address.
292 Plus for some targets we need room for an extra pointer - in the
293 case of MIPS this is the global pointer. This makes a total of four
294 pointers, but to be safe we actually allocate room for 5.
296 If pointers are smaller than words then we allocate enough room for
297 5 words, just in case the backend needs this much room. For more
298 discussion on this issue see:
299 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
300 if (POINTER_SIZE
> BITS_PER_WORD
)
301 tmp
= size_int (5 - 1);
303 tmp
= size_int ((5 * BITS_PER_WORD
/ POINTER_SIZE
) - 1);
306 tmp
= build_index_type (tmp
);
307 tmp
= build_array_type (ptr_type_node
, tmp
);
308 f_jbuf
= build_decl (BUILTINS_LOCATION
,
309 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
310 #ifdef DONT_USE_BUILTIN_SETJMP
311 /* We don't know what the alignment requirements of the
312 runtime's jmp_buf has. Overestimate. */
313 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
314 DECL_USER_ALIGN (f_jbuf
) = 1;
316 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
318 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
319 TREE_CHAIN (f_prev
) = f_cs
;
320 TREE_CHAIN (f_cs
) = f_data
;
321 TREE_CHAIN (f_data
) = f_per
;
322 TREE_CHAIN (f_per
) = f_lsda
;
323 TREE_CHAIN (f_lsda
) = f_jbuf
;
325 layout_type (sjlj_fc_type_node
);
327 /* Cache the interesting field offsets so that we have
328 easy access from rtl. */
329 sjlj_fc_call_site_ofs
330 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs
))
331 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs
)) / BITS_PER_UNIT
);
333 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data
))
334 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data
)) / BITS_PER_UNIT
);
335 sjlj_fc_personality_ofs
336 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per
))
337 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per
)) / BITS_PER_UNIT
);
339 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda
))
340 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda
)) / BITS_PER_UNIT
);
342 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf
))
343 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf
)) / BITS_PER_UNIT
);
348 init_eh_for_function (void)
350 cfun
->eh
= ggc_cleared_alloc
<eh_status
> ();
352 /* Make sure zero'th entries are used. */
353 vec_safe_push (cfun
->eh
->region_array
, (eh_region
)0);
354 vec_safe_push (cfun
->eh
->lp_array
, (eh_landing_pad
)0);
357 /* Routines to generate the exception tree somewhat directly.
358 These are used from tree-eh.c when processing exception related
359 nodes during tree optimization. */
362 gen_eh_region (enum eh_region_type type
, eh_region outer
)
366 /* Insert a new blank region as a leaf in the tree. */
367 new_eh
= ggc_cleared_alloc
<eh_region_d
> ();
369 new_eh
->outer
= outer
;
372 new_eh
->next_peer
= outer
->inner
;
373 outer
->inner
= new_eh
;
377 new_eh
->next_peer
= cfun
->eh
->region_tree
;
378 cfun
->eh
->region_tree
= new_eh
;
381 new_eh
->index
= vec_safe_length (cfun
->eh
->region_array
);
382 vec_safe_push (cfun
->eh
->region_array
, new_eh
);
384 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
385 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
386 new_eh
->use_cxa_end_cleanup
= true;
392 gen_eh_region_cleanup (eh_region outer
)
394 return gen_eh_region (ERT_CLEANUP
, outer
);
398 gen_eh_region_try (eh_region outer
)
400 return gen_eh_region (ERT_TRY
, outer
);
404 gen_eh_region_catch (eh_region t
, tree type_or_list
)
407 tree type_list
, type_node
;
409 gcc_assert (t
->type
== ERT_TRY
);
411 /* Ensure to always end up with a type list to normalize further
412 processing, then register each type against the runtime types map. */
413 type_list
= type_or_list
;
416 if (TREE_CODE (type_or_list
) != TREE_LIST
)
417 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
419 type_node
= type_list
;
420 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
421 add_type_for_runtime (TREE_VALUE (type_node
));
424 c
= ggc_cleared_alloc
<eh_catch_d
> ();
425 c
->type_list
= type_list
;
426 l
= t
->u
.eh_try
.last_catch
;
431 t
->u
.eh_try
.first_catch
= c
;
432 t
->u
.eh_try
.last_catch
= c
;
438 gen_eh_region_allowed (eh_region outer
, tree allowed
)
440 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
441 region
->u
.allowed
.type_list
= allowed
;
443 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
444 add_type_for_runtime (TREE_VALUE (allowed
));
450 gen_eh_region_must_not_throw (eh_region outer
)
452 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
456 gen_eh_landing_pad (eh_region region
)
458 eh_landing_pad lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
460 lp
->next_lp
= region
->landing_pads
;
462 lp
->index
= vec_safe_length (cfun
->eh
->lp_array
);
463 region
->landing_pads
= lp
;
465 vec_safe_push (cfun
->eh
->lp_array
, lp
);
471 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
473 return (*ifun
->eh
->region_array
)[i
];
477 get_eh_region_from_number (int i
)
479 return get_eh_region_from_number_fn (cfun
, i
);
483 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
485 return (*ifun
->eh
->lp_array
)[i
];
489 get_eh_landing_pad_from_number (int i
)
491 return get_eh_landing_pad_from_number_fn (cfun
, i
);
495 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
498 return (*ifun
->eh
->region_array
)[-i
];
504 lp
= (*ifun
->eh
->lp_array
)[i
];
510 get_eh_region_from_lp_number (int i
)
512 return get_eh_region_from_lp_number_fn (cfun
, i
);
515 /* Returns true if the current function has exception handling regions. */
518 current_function_has_exception_handlers (void)
520 return cfun
->eh
->region_tree
!= NULL
;
523 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
524 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
526 struct duplicate_eh_regions_data
528 duplicate_eh_regions_map label_map
;
529 void *label_map_data
;
530 hash_map
<void *, void *> *eh_map
;
534 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
535 eh_region old_r
, eh_region outer
)
537 eh_landing_pad old_lp
, new_lp
;
540 new_r
= gen_eh_region (old_r
->type
, outer
);
541 gcc_assert (!data
->eh_map
->put (old_r
, new_r
));
551 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
553 /* We should be doing all our region duplication before and
554 during inlining, which is before filter lists are created. */
555 gcc_assert (oc
->filter_list
== NULL
);
556 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
557 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
562 case ERT_ALLOWED_EXCEPTIONS
:
563 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
564 if (old_r
->u
.allowed
.label
)
565 new_r
->u
.allowed
.label
566 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
568 new_r
->u
.allowed
.label
= NULL_TREE
;
571 case ERT_MUST_NOT_THROW
:
572 new_r
->u
.must_not_throw
.failure_loc
=
573 LOCATION_LOCUS (old_r
->u
.must_not_throw
.failure_loc
);
574 new_r
->u
.must_not_throw
.failure_decl
=
575 old_r
->u
.must_not_throw
.failure_decl
;
579 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
581 /* Don't bother copying unused landing pads. */
582 if (old_lp
->post_landing_pad
== NULL
)
585 new_lp
= gen_eh_landing_pad (new_r
);
586 gcc_assert (!data
->eh_map
->put (old_lp
, new_lp
));
588 new_lp
->post_landing_pad
589 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
590 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
593 /* Make sure to preserve the original use of __cxa_end_cleanup. */
594 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
596 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
597 duplicate_eh_regions_1 (data
, old_r
, new_r
);
600 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
601 the current function and root the tree below OUTER_REGION.
602 The special case of COPY_REGION of NULL means all regions.
603 Remap labels using MAP/MAP_DATA callback. Return a pointer map
604 that allows the caller to remap uses of both EH regions and
607 hash_map
<void *, void *> *
608 duplicate_eh_regions (struct function
*ifun
,
609 eh_region copy_region
, int outer_lp
,
610 duplicate_eh_regions_map map
, void *map_data
)
612 struct duplicate_eh_regions_data data
;
613 eh_region outer_region
;
615 #ifdef ENABLE_CHECKING
616 verify_eh_tree (ifun
);
619 data
.label_map
= map
;
620 data
.label_map_data
= map_data
;
621 data
.eh_map
= new hash_map
<void *, void *>;
623 outer_region
= get_eh_region_from_lp_number_fn (cfun
, outer_lp
);
625 /* Copy all the regions in the subtree. */
627 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
631 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
632 duplicate_eh_regions_1 (&data
, r
, outer_region
);
635 #ifdef ENABLE_CHECKING
636 verify_eh_tree (cfun
);
642 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
645 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
650 gcc_assert (ifun
->eh
->region_array
);
651 gcc_assert (ifun
->eh
->region_tree
);
653 b_outer
= sbitmap_alloc (ifun
->eh
->region_array
->length ());
654 bitmap_clear (b_outer
);
658 bitmap_set_bit (b_outer
, region_b
->index
);
659 region_b
= region_b
->outer
;
665 if (bitmap_bit_p (b_outer
, region_a
->index
))
667 region_a
= region_a
->outer
;
671 sbitmap_free (b_outer
);
676 add_type_for_runtime (tree type
)
678 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
679 if (TREE_CODE (type
) == NOP_EXPR
)
682 bool existed
= false;
683 tree
*slot
= &type_to_runtime_map
->get_or_insert (type
, &existed
);
685 *slot
= lang_hooks
.eh_runtime_type (type
);
689 lookup_type_for_runtime (tree type
)
691 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
692 if (TREE_CODE (type
) == NOP_EXPR
)
695 /* We should have always inserted the data earlier. */
696 return *type_to_runtime_map
->get (type
);
700 /* Represent an entry in @TTypes for either catch actions
701 or exception filter actions. */
702 struct ttypes_filter
{
707 /* Helper for ttypes_filter hashing. */
709 struct ttypes_filter_hasher
: free_ptr_hash
<ttypes_filter
>
711 typedef tree_node
*compare_type
;
712 static inline hashval_t
hash (const ttypes_filter
*);
713 static inline bool equal (const ttypes_filter
*, const tree_node
*);
716 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
717 (a tree) for a @TTypes type node we are thinking about adding. */
720 ttypes_filter_hasher::equal (const ttypes_filter
*entry
, const tree_node
*data
)
722 return entry
->t
== data
;
726 ttypes_filter_hasher::hash (const ttypes_filter
*entry
)
728 return TREE_HASH (entry
->t
);
731 typedef hash_table
<ttypes_filter_hasher
> ttypes_hash_type
;
734 /* Helper for ehspec hashing. */
736 struct ehspec_hasher
: free_ptr_hash
<ttypes_filter
>
738 static inline hashval_t
hash (const ttypes_filter
*);
739 static inline bool equal (const ttypes_filter
*, const ttypes_filter
*);
742 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
743 exception specification list we are thinking about adding. */
744 /* ??? Currently we use the type lists in the order given. Someone
745 should put these in some canonical order. */
748 ehspec_hasher::equal (const ttypes_filter
*entry
, const ttypes_filter
*data
)
750 return type_list_equal (entry
->t
, data
->t
);
753 /* Hash function for exception specification lists. */
756 ehspec_hasher::hash (const ttypes_filter
*entry
)
761 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
762 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
766 typedef hash_table
<ehspec_hasher
> ehspec_hash_type
;
769 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
770 to speed up the search. Return the filter value to be used. */
773 add_ttypes_entry (ttypes_hash_type
*ttypes_hash
, tree type
)
775 struct ttypes_filter
**slot
, *n
;
777 slot
= ttypes_hash
->find_slot_with_hash (type
, (hashval_t
) TREE_HASH (type
),
780 if ((n
= *slot
) == NULL
)
782 /* Filter value is a 1 based table index. */
784 n
= XNEW (struct ttypes_filter
);
786 n
->filter
= vec_safe_length (cfun
->eh
->ttype_data
) + 1;
789 vec_safe_push (cfun
->eh
->ttype_data
, type
);
795 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
796 to speed up the search. Return the filter value to be used. */
799 add_ehspec_entry (ehspec_hash_type
*ehspec_hash
, ttypes_hash_type
*ttypes_hash
,
802 struct ttypes_filter
**slot
, *n
;
803 struct ttypes_filter dummy
;
806 slot
= ehspec_hash
->find_slot (&dummy
, INSERT
);
808 if ((n
= *slot
) == NULL
)
812 if (targetm
.arm_eabi_unwinder
)
813 len
= vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
);
815 len
= vec_safe_length (cfun
->eh
->ehspec_data
.other
);
817 /* Filter value is a -1 based byte index into a uleb128 buffer. */
819 n
= XNEW (struct ttypes_filter
);
821 n
->filter
= -(len
+ 1);
824 /* Generate a 0 terminated list of filter values. */
825 for (; list
; list
= TREE_CHAIN (list
))
827 if (targetm
.arm_eabi_unwinder
)
828 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, TREE_VALUE (list
));
831 /* Look up each type in the list and encode its filter
832 value as a uleb128. */
833 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
834 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
837 if (targetm
.arm_eabi_unwinder
)
838 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
840 vec_safe_push (cfun
->eh
->ehspec_data
.other
, (uchar
)0);
846 /* Generate the action filter values to be used for CATCH and
847 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
848 we use lots of landing pads, and so every type or list can share
849 the same filter value, which saves table space. */
852 assign_filter_values (void)
858 vec_alloc (cfun
->eh
->ttype_data
, 16);
859 if (targetm
.arm_eabi_unwinder
)
860 vec_alloc (cfun
->eh
->ehspec_data
.arm_eabi
, 64);
862 vec_alloc (cfun
->eh
->ehspec_data
.other
, 64);
864 ehspec_hash_type
ehspec (31);
865 ttypes_hash_type
ttypes (31);
867 for (i
= 1; vec_safe_iterate (cfun
->eh
->region_array
, i
, &r
); ++i
)
875 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
877 /* Whatever type_list is (NULL or true list), we build a list
878 of filters for the region. */
879 c
->filter_list
= NULL_TREE
;
881 if (c
->type_list
!= NULL
)
883 /* Get a filter value for each of the types caught and store
884 them in the region's dedicated list. */
885 tree tp_node
= c
->type_list
;
887 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
890 = add_ttypes_entry (&ttypes
, TREE_VALUE (tp_node
));
891 tree flt_node
= build_int_cst (integer_type_node
, flt
);
894 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
899 /* Get a filter value for the NULL list also since it
900 will need an action record anyway. */
901 int flt
= add_ttypes_entry (&ttypes
, NULL
);
902 tree flt_node
= build_int_cst (integer_type_node
, flt
);
905 = tree_cons (NULL_TREE
, flt_node
, NULL
);
910 case ERT_ALLOWED_EXCEPTIONS
:
912 = add_ehspec_entry (&ehspec
, &ttypes
, r
->u
.allowed
.type_list
);
921 /* Emit SEQ into basic block just before INSN (that is assumed to be
922 first instruction of some existing BB and return the newly
925 emit_to_new_bb_before (rtx_insn
*seq
, rtx insn
)
932 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
933 call), we don't want it to go into newly created landing pad or other EH
935 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
936 if (e
->flags
& EDGE_FALLTHRU
)
937 force_nonfallthru (e
);
940 last
= emit_insn_before (seq
, insn
);
941 if (BARRIER_P (last
))
942 last
= PREV_INSN (last
);
943 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
944 update_bb_for_insn (bb
);
945 bb
->flags
|= BB_SUPERBLOCK
;
949 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
950 at the rtl level. Emit the code required by the target at a landing
951 pad for the given region. */
954 expand_dw2_landing_pad_for_region (eh_region region
)
956 if (targetm
.have_exception_receiver ())
957 emit_insn (targetm
.gen_exception_receiver ());
958 else if (targetm
.have_nonlocal_goto_receiver ())
959 emit_insn (targetm
.gen_nonlocal_goto_receiver ());
963 if (region
->exc_ptr_reg
)
964 emit_move_insn (region
->exc_ptr_reg
,
965 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
966 if (region
->filter_reg
)
967 emit_move_insn (region
->filter_reg
,
968 gen_rtx_REG (targetm
.eh_return_filter_mode (),
969 EH_RETURN_DATA_REGNO (1)));
972 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
975 dw2_build_landing_pads (void)
979 int e_flags
= EDGE_FALLTHRU
;
981 /* If we're going to partition blocks, we need to be able to add
982 new landing pads later, which means that we need to hold on to
983 the post-landing-pad block. Prevent it from being merged away.
984 We'll remove this bit after partitioning. */
985 if (flag_reorder_blocks_and_partition
)
986 e_flags
|= EDGE_PRESERVE
;
988 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
994 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
999 lp
->landing_pad
= gen_label_rtx ();
1000 emit_label (lp
->landing_pad
);
1001 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
1003 expand_dw2_landing_pad_for_region (lp
->region
);
1008 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
1009 e
= make_edge (bb
, bb
->next_bb
, e_flags
);
1010 e
->count
= bb
->count
;
1011 e
->probability
= REG_BR_PROB_BASE
;
1014 struct loop
*loop
= bb
->next_bb
->loop_father
;
1015 /* If we created a pre-header block, add the new block to the
1016 outer loop, otherwise to the loop itself. */
1017 if (bb
->next_bb
== loop
->header
)
1018 add_bb_to_loop (bb
, loop_outer (loop
));
1020 add_bb_to_loop (bb
, loop
);
1026 static vec
<int> sjlj_lp_call_site_index
;
1028 /* Process all active landing pads. Assign each one a compact dispatch
1029 index, and a call-site index. */
1032 sjlj_assign_call_site_values (void)
1034 action_hash_type
ar_hash (31);
1038 vec_alloc (crtl
->eh
.action_record_data
, 64);
1042 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1043 if (lp
&& lp
->post_landing_pad
)
1045 int action
, call_site
;
1047 /* First: build the action table. */
1048 action
= collect_one_action_chain (&ar_hash
, lp
->region
);
1050 /* Next: assign call-site values. If dwarf2 terms, this would be
1051 the region number assigned by convert_to_eh_region_ranges, but
1052 handles no-action and must-not-throw differently. */
1053 /* Map must-not-throw to otherwise unused call-site index 0. */
1056 /* Map no-action to otherwise unused call-site index -1. */
1057 else if (action
== -1)
1059 /* Otherwise, look it up in the table. */
1061 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1062 sjlj_lp_call_site_index
[i
] = call_site
;
1070 /* Emit code to record the current call-site index before every
1071 insn that can throw. */
1074 sjlj_mark_call_sites (void)
1076 int last_call_site
= -2;
1080 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1086 rtx_insn
*before
, *p
;
1088 /* Reset value tracking at extended basic block boundaries. */
1090 last_call_site
= -2;
1092 /* If the function allocates dynamic stack space, the context must
1093 be updated after every allocation/deallocation accordingly. */
1094 if (NOTE_P (insn
) && NOTE_KIND (insn
) == NOTE_INSN_UPDATE_SJLJ_CONTEXT
)
1099 buf_addr
= plus_constant (Pmode
, XEXP (crtl
->eh
.sjlj_fc
, 0),
1101 expand_builtin_update_setjmp_buf (buf_addr
);
1104 emit_insn_before (p
, insn
);
1107 if (! INSN_P (insn
))
1110 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1114 this_call_site
= sjlj_lp_call_site_index
[lp
->index
];
1117 /* Calls (and trapping insns) without notes are outside any
1118 exception handling region in this function. Mark them as
1120 this_call_site
= -1;
1124 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1128 if (this_call_site
!= -1)
1129 crtl
->uses_eh_lsda
= 1;
1131 if (this_call_site
== last_call_site
)
1134 /* Don't separate a call from it's argument loads. */
1137 before
= find_first_parameter_load (insn
, NULL
);
1140 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1141 sjlj_fc_call_site_ofs
);
1142 emit_move_insn (mem
, gen_int_mode (this_call_site
, GET_MODE (mem
)));
1146 emit_insn_before (p
, before
);
1147 last_call_site
= this_call_site
;
1151 /* Construct the SjLj_Function_Context. */
1154 sjlj_emit_function_enter (rtx_code_label
*dispatch_label
)
1156 rtx_insn
*fn_begin
, *seq
;
1158 bool fn_begin_outside_block
;
1159 rtx personality
= get_personality_function (current_function_decl
);
1161 fc
= crtl
->eh
.sjlj_fc
;
1165 /* We're storing this libcall's address into memory instead of
1166 calling it directly. Thus, we must call assemble_external_libcall
1167 here, as we can not depend on emit_library_call to do it for us. */
1168 assemble_external_libcall (personality
);
1169 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1170 emit_move_insn (mem
, personality
);
1172 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1173 if (crtl
->uses_eh_lsda
)
1178 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1179 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1180 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1181 emit_move_insn (mem
, sym
);
1184 emit_move_insn (mem
, const0_rtx
);
1188 #ifdef DONT_USE_BUILTIN_SETJMP
1190 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1191 TYPE_MODE (integer_type_node
), 1,
1192 plus_constant (Pmode
, XEXP (fc
, 0),
1193 sjlj_fc_jbuf_ofs
), Pmode
);
1195 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1196 TYPE_MODE (integer_type_node
), 0,
1197 dispatch_label
, REG_BR_PROB_BASE
/ 100);
1199 expand_builtin_setjmp_setup (plus_constant (Pmode
, XEXP (fc
, 0),
1205 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1206 1, XEXP (fc
, 0), Pmode
);
1211 /* ??? Instead of doing this at the beginning of the function,
1212 do this in a block that is at loop level 0 and dominates all
1213 can_throw_internal instructions. */
1215 fn_begin_outside_block
= true;
1216 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1217 if (NOTE_P (fn_begin
))
1219 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1221 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1222 fn_begin_outside_block
= false;
1225 if (fn_begin_outside_block
)
1226 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1228 emit_insn_after (seq
, fn_begin
);
1231 /* Call back from expand_function_end to know where we should put
1232 the call to unwind_sjlj_unregister_libfunc if needed. */
1235 sjlj_emit_function_exit_after (rtx_insn
*after
)
1237 crtl
->eh
.sjlj_exit_after
= after
;
1241 sjlj_emit_function_exit (void)
1243 rtx_insn
*seq
, *insn
;
1247 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1248 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1253 /* ??? Really this can be done in any block at loop level 0 that
1254 post-dominates all can_throw_internal instructions. This is
1255 the last possible moment. */
1257 insn
= crtl
->eh
.sjlj_exit_after
;
1259 insn
= NEXT_INSN (insn
);
1261 emit_insn_after (seq
, insn
);
1265 sjlj_emit_dispatch_table (rtx_code_label
*dispatch_label
, int num_dispatch
)
1267 machine_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1268 machine_mode filter_mode
= targetm
.eh_return_filter_mode ();
1270 rtx mem
, fc
, exc_ptr_reg
, filter_reg
;
1276 vec
<tree
> dispatch_labels
= vNULL
;
1278 fc
= crtl
->eh
.sjlj_fc
;
1282 emit_label (dispatch_label
);
1284 #ifndef DONT_USE_BUILTIN_SETJMP
1285 expand_builtin_setjmp_receiver (dispatch_label
);
1287 /* The caller of expand_builtin_setjmp_receiver is responsible for
1288 making sure that the label doesn't vanish. The only other caller
1289 is the expander for __builtin_setjmp_receiver, which places this
1290 label on the nonlocal_goto_label list. Since we're modeling these
1291 CFG edges more exactly, we can use the forced_labels list instead. */
1292 LABEL_PRESERVE_P (dispatch_label
) = 1;
1294 = gen_rtx_INSN_LIST (VOIDmode
, dispatch_label
, forced_labels
);
1297 /* Load up exc_ptr and filter values from the function context. */
1298 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1299 if (unwind_word_mode
!= ptr_mode
)
1301 #ifdef POINTERS_EXTEND_UNSIGNED
1302 mem
= convert_memory_address (ptr_mode
, mem
);
1304 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1307 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1309 mem
= adjust_address (fc
, unwind_word_mode
,
1310 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1311 if (unwind_word_mode
!= filter_mode
)
1312 mem
= convert_to_mode (filter_mode
, mem
, 0);
1313 filter_reg
= force_reg (filter_mode
, mem
);
1315 /* Jump to one of the directly reachable regions. */
1318 rtx_code_label
*first_reachable_label
= NULL
;
1320 /* If there's exactly one call site in the function, don't bother
1321 generating a switch statement. */
1322 if (num_dispatch
> 1)
1323 dispatch_labels
.create (num_dispatch
);
1325 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1326 if (lp
&& lp
->post_landing_pad
)
1329 rtx_code_label
*label
;
1333 lp
->landing_pad
= dispatch_label
;
1335 if (num_dispatch
> 1)
1337 tree t_label
, case_elt
, t
;
1339 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1340 t
= build_int_cst (integer_type_node
, disp_index
);
1341 case_elt
= build_case_label (t
, NULL
, t_label
);
1342 dispatch_labels
.quick_push (case_elt
);
1343 label
= jump_target_rtx (t_label
);
1346 label
= gen_label_rtx ();
1348 if (disp_index
== 0)
1349 first_reachable_label
= label
;
1354 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1356 emit_move_insn (r
->filter_reg
, filter_reg
);
1358 seq2
= get_insns ();
1361 rtx_insn
*before
= label_rtx (lp
->post_landing_pad
);
1362 bb
= emit_to_new_bb_before (seq2
, before
);
1363 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1364 e
->count
= bb
->count
;
1365 e
->probability
= REG_BR_PROB_BASE
;
1368 struct loop
*loop
= bb
->next_bb
->loop_father
;
1369 /* If we created a pre-header block, add the new block to the
1370 outer loop, otherwise to the loop itself. */
1371 if (bb
->next_bb
== loop
->header
)
1372 add_bb_to_loop (bb
, loop_outer (loop
));
1374 add_bb_to_loop (bb
, loop
);
1375 /* ??? For multiple dispatches we will end up with edges
1376 from the loop tree root into this loop, making it a
1377 multiple-entry loop. Discard all affected loops. */
1378 if (num_dispatch
> 1)
1380 for (loop
= bb
->loop_father
;
1381 loop_outer (loop
); loop
= loop_outer (loop
))
1382 mark_loop_for_removal (loop
);
1388 gcc_assert (disp_index
== num_dispatch
);
1390 if (num_dispatch
> 1)
1392 rtx disp
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1393 sjlj_fc_call_site_ofs
);
1394 expand_sjlj_dispatch_table (disp
, dispatch_labels
);
1400 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1401 if (num_dispatch
== 1)
1403 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1404 e
->count
= bb
->count
;
1405 e
->probability
= REG_BR_PROB_BASE
;
1408 struct loop
*loop
= bb
->next_bb
->loop_father
;
1409 /* If we created a pre-header block, add the new block to the
1410 outer loop, otherwise to the loop itself. */
1411 if (bb
->next_bb
== loop
->header
)
1412 add_bb_to_loop (bb
, loop_outer (loop
));
1414 add_bb_to_loop (bb
, loop
);
1419 /* We are not wiring up edges here, but as the dispatcher call
1420 is at function begin simply associate the block with the
1421 outermost (non-)loop. */
1423 add_bb_to_loop (bb
, current_loops
->tree_root
);
1428 sjlj_build_landing_pads (void)
1432 num_dispatch
= vec_safe_length (cfun
->eh
->lp_array
);
1433 if (num_dispatch
== 0)
1435 sjlj_lp_call_site_index
.safe_grow_cleared (num_dispatch
);
1437 num_dispatch
= sjlj_assign_call_site_values ();
1438 if (num_dispatch
> 0)
1440 rtx_code_label
*dispatch_label
= gen_label_rtx ();
1441 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1442 TYPE_MODE (sjlj_fc_type_node
),
1443 TYPE_ALIGN (sjlj_fc_type_node
));
1445 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1446 int_size_in_bytes (sjlj_fc_type_node
),
1449 sjlj_mark_call_sites ();
1450 sjlj_emit_function_enter (dispatch_label
);
1451 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1452 sjlj_emit_function_exit ();
1455 /* If we do not have any landing pads, we may still need to register a
1456 personality routine and (empty) LSDA to handle must-not-throw regions. */
1457 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
1459 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1460 TYPE_MODE (sjlj_fc_type_node
),
1461 TYPE_ALIGN (sjlj_fc_type_node
));
1463 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1464 int_size_in_bytes (sjlj_fc_type_node
),
1467 sjlj_mark_call_sites ();
1468 sjlj_emit_function_enter (NULL
);
1469 sjlj_emit_function_exit ();
1472 sjlj_lp_call_site_index
.release ();
1475 /* Update the sjlj function context. This function should be called
1476 whenever we allocate or deallocate dynamic stack space. */
1479 update_sjlj_context (void)
1481 if (!flag_exceptions
)
1484 emit_note (NOTE_INSN_UPDATE_SJLJ_CONTEXT
);
1487 /* After initial rtl generation, call back to finish generating
1488 exception support code. */
1491 finish_eh_generation (void)
1495 /* Construct the landing pads. */
1496 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1497 sjlj_build_landing_pads ();
1499 dw2_build_landing_pads ();
1500 break_superblocks ();
1502 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1503 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1504 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->insns
.r
)
1505 commit_edge_insertions ();
1507 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1508 FOR_EACH_BB_FN (bb
, cfun
)
1514 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1516 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1517 if (e
->flags
& EDGE_EH
)
1520 /* We should not have generated any new throwing insns during this
1521 pass, and we should not have lost any EH edges, so we only need
1522 to handle two cases here:
1523 (1) reachable handler and an existing edge to post-landing-pad,
1524 (2) no reachable handler and no edge. */
1525 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1528 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1530 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1531 e
->flags
|= (CALL_P (BB_END (bb
))
1532 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1538 /* This section handles removing dead code for flow. */
1541 remove_eh_landing_pad (eh_landing_pad lp
)
1545 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1549 if (lp
->post_landing_pad
)
1550 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1551 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1554 /* Splice the EH region at PP from the region tree. */
1557 remove_eh_handler_splicer (eh_region
*pp
)
1559 eh_region region
= *pp
;
1562 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1564 if (lp
->post_landing_pad
)
1565 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1566 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1572 outer
= region
->outer
;
1574 *pp
= p
= region
->inner
;
1583 *pp
= region
->next_peer
;
1585 (*cfun
->eh
->region_array
)[region
->index
] = NULL
;
1588 /* Splice a single EH region REGION from the region tree.
1590 To unlink REGION, we need to find the pointer to it with a relatively
1591 expensive search in REGION's outer region. If you are going to
1592 remove a number of handlers, using remove_unreachable_eh_regions may
1593 be a better option. */
1596 remove_eh_handler (eh_region region
)
1598 eh_region
*pp
, *pp_start
, p
, outer
;
1600 outer
= region
->outer
;
1602 pp_start
= &outer
->inner
;
1604 pp_start
= &cfun
->eh
->region_tree
;
1605 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1608 remove_eh_handler_splicer (pp
);
1611 /* Worker for remove_unreachable_eh_regions.
1612 PP is a pointer to the region to start a region tree depth-first
1613 search from. R_REACHABLE is the set of regions that have to be
1617 remove_unreachable_eh_regions_worker (eh_region
*pp
, sbitmap r_reachable
)
1621 eh_region region
= *pp
;
1622 remove_unreachable_eh_regions_worker (®ion
->inner
, r_reachable
);
1623 if (!bitmap_bit_p (r_reachable
, region
->index
))
1624 remove_eh_handler_splicer (pp
);
1626 pp
= ®ion
->next_peer
;
1630 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1631 Do this by traversing the EH tree top-down and splice out regions that
1632 are not marked. By removing regions from the leaves, we avoid costly
1633 searches in the region tree. */
1636 remove_unreachable_eh_regions (sbitmap r_reachable
)
1638 remove_unreachable_eh_regions_worker (&cfun
->eh
->region_tree
, r_reachable
);
1641 /* Invokes CALLBACK for every exception handler landing pad label.
1642 Only used by reload hackery; should not be used by new code. */
1645 for_each_eh_label (void (*callback
) (rtx
))
1650 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1654 rtx_code_label
*lab
= lp
->landing_pad
;
1655 if (lab
&& LABEL_P (lab
))
1661 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1664 At the gimple level, we use LP_NR
1665 > 0 : The statement transfers to landing pad LP_NR
1666 = 0 : The statement is outside any EH region
1667 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1669 At the rtl level, we use LP_NR
1670 > 0 : The insn transfers to landing pad LP_NR
1671 = 0 : The insn cannot throw
1672 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1673 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1674 missing note: The insn is outside any EH region.
1676 ??? This difference probably ought to be avoided. We could stand
1677 to record nothrow for arbitrary gimple statements, and so avoid
1678 some moderately complex lookups in stmt_could_throw_p. Perhaps
1679 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1680 no-nonlocal-goto property should be recorded elsewhere as a bit
1681 on the call_insn directly. Perhaps we should make more use of
1682 attaching the trees to call_insns (reachable via symbol_ref in
1683 direct call cases) and just pull the data out of the trees. */
1686 make_reg_eh_region_note (rtx_insn
*insn
, int ecf_flags
, int lp_nr
)
1689 if (ecf_flags
& ECF_NOTHROW
)
1691 else if (lp_nr
!= 0)
1692 value
= GEN_INT (lp_nr
);
1695 add_reg_note (insn
, REG_EH_REGION
, value
);
1698 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1699 nor perform a non-local goto. Replace the region note if it
1703 make_reg_eh_region_note_nothrow_nononlocal (rtx_insn
*insn
)
1705 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1706 rtx intmin
= GEN_INT (INT_MIN
);
1709 XEXP (note
, 0) = intmin
;
1711 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1714 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1718 insn_could_throw_p (const_rtx insn
)
1720 if (!flag_exceptions
)
1724 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1725 return may_trap_p (PATTERN (insn
));
1729 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1730 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1731 to look for a note, or the note itself. */
1734 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx_insn
*first
, rtx last
)
1737 rtx note
= note_or_insn
;
1739 if (INSN_P (note_or_insn
))
1741 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1745 note
= XEXP (note
, 0);
1747 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1748 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1749 && insn_could_throw_p (insn
))
1750 add_reg_note (insn
, REG_EH_REGION
, note
);
1753 /* Likewise, but iterate backward. */
1756 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx_insn
*last
, rtx first
)
1759 rtx note
= note_or_insn
;
1761 if (INSN_P (note_or_insn
))
1763 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1767 note
= XEXP (note
, 0);
1769 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1770 if (insn_could_throw_p (insn
))
1771 add_reg_note (insn
, REG_EH_REGION
, note
);
1775 /* Extract all EH information from INSN. Return true if the insn
1776 was marked NOTHROW. */
1779 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1780 eh_landing_pad
*plp
)
1782 eh_landing_pad lp
= NULL
;
1788 if (! INSN_P (insn
))
1791 if (NONJUMP_INSN_P (insn
)
1792 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1793 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1795 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1798 ret
= !insn_could_throw_p (insn
);
1802 lp_nr
= INTVAL (XEXP (note
, 0));
1803 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1810 r
= (*cfun
->eh
->region_array
)[-lp_nr
];
1813 lp
= (*cfun
->eh
->lp_array
)[lp_nr
];
1823 /* Return the landing pad to which INSN may go, or NULL if it does not
1824 have a reachable landing pad within this function. */
1827 get_eh_landing_pad_from_rtx (const_rtx insn
)
1832 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1836 /* Return the region to which INSN may go, or NULL if it does not
1837 have a reachable region within this function. */
1840 get_eh_region_from_rtx (const_rtx insn
)
1845 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1849 /* Return true if INSN throws and is caught by something in this function. */
1852 can_throw_internal (const_rtx insn
)
1854 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1857 /* Return true if INSN throws and escapes from the current function. */
1860 can_throw_external (const_rtx insn
)
1866 if (! INSN_P (insn
))
1869 if (NONJUMP_INSN_P (insn
)
1870 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1872 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1873 int i
, n
= seq
->len ();
1875 for (i
= 0; i
< n
; i
++)
1876 if (can_throw_external (seq
->element (i
)))
1882 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1884 /* If we can't throw, we obviously can't throw external. */
1888 /* If we have an internal landing pad, then we're not external. */
1892 /* If we're not within an EH region, then we are external. */
1896 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1897 which don't always have landing pads. */
1898 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1902 /* Return true if INSN cannot throw at all. */
1905 insn_nothrow_p (const_rtx insn
)
1910 if (! INSN_P (insn
))
1913 if (NONJUMP_INSN_P (insn
)
1914 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1916 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1917 int i
, n
= seq
->len ();
1919 for (i
= 0; i
< n
; i
++)
1920 if (!insn_nothrow_p (seq
->element (i
)))
1926 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1929 /* Return true if INSN can perform a non-local goto. */
1930 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1933 can_nonlocal_goto (const rtx_insn
*insn
)
1935 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1937 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1938 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1944 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1947 set_nothrow_function_flags (void)
1953 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1954 something that can throw an exception. We specifically exempt
1955 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1956 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1959 crtl
->all_throwers_are_sibcalls
= 1;
1961 /* If we don't know that this implementation of the function will
1962 actually be used, then we must not set TREE_NOTHROW, since
1963 callers must not assume that this function does not throw. */
1964 if (TREE_NOTHROW (current_function_decl
))
1967 if (! flag_exceptions
)
1970 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1971 if (can_throw_external (insn
))
1975 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1977 crtl
->all_throwers_are_sibcalls
= 0;
1983 && (cgraph_node::get (current_function_decl
)->get_availability ()
1984 >= AVAIL_AVAILABLE
))
1986 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1987 struct cgraph_edge
*e
;
1988 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1989 e
->can_throw_external
= false;
1990 node
->set_nothrow_flag (true);
1993 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
1994 current_function_name ());
2001 const pass_data pass_data_set_nothrow_function_flags
=
2003 RTL_PASS
, /* type */
2004 "nothrow", /* name */
2005 OPTGROUP_NONE
, /* optinfo_flags */
2006 TV_NONE
, /* tv_id */
2007 0, /* properties_required */
2008 0, /* properties_provided */
2009 0, /* properties_destroyed */
2010 0, /* todo_flags_start */
2011 0, /* todo_flags_finish */
2014 class pass_set_nothrow_function_flags
: public rtl_opt_pass
2017 pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2018 : rtl_opt_pass (pass_data_set_nothrow_function_flags
, ctxt
)
2021 /* opt_pass methods: */
2022 virtual unsigned int execute (function
*)
2024 return set_nothrow_function_flags ();
2027 }; // class pass_set_nothrow_function_flags
2032 make_pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2034 return new pass_set_nothrow_function_flags (ctxt
);
2038 /* Various hooks for unwind library. */
2040 /* Expand the EH support builtin functions:
2041 __builtin_eh_pointer and __builtin_eh_filter. */
2044 expand_builtin_eh_common (tree region_nr_t
)
2046 HOST_WIDE_INT region_nr
;
2049 gcc_assert (tree_fits_shwi_p (region_nr_t
));
2050 region_nr
= tree_to_shwi (region_nr_t
);
2052 region
= (*cfun
->eh
->region_array
)[region_nr
];
2054 /* ??? We shouldn't have been able to delete a eh region without
2055 deleting all the code that depended on it. */
2056 gcc_assert (region
!= NULL
);
2061 /* Expand to the exc_ptr value from the given eh region. */
2064 expand_builtin_eh_pointer (tree exp
)
2067 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2068 if (region
->exc_ptr_reg
== NULL
)
2069 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2070 return region
->exc_ptr_reg
;
2073 /* Expand to the filter value from the given eh region. */
2076 expand_builtin_eh_filter (tree exp
)
2079 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2080 if (region
->filter_reg
== NULL
)
2081 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
2082 return region
->filter_reg
;
2085 /* Copy the exc_ptr and filter values from one landing pad's registers
2086 to another. This is used to inline the resx statement. */
2089 expand_builtin_eh_copy_values (tree exp
)
2092 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2094 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
2095 machine_mode fmode
= targetm
.eh_return_filter_mode ();
2097 if (dst
->exc_ptr_reg
== NULL
)
2098 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2099 if (src
->exc_ptr_reg
== NULL
)
2100 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2102 if (dst
->filter_reg
== NULL
)
2103 dst
->filter_reg
= gen_reg_rtx (fmode
);
2104 if (src
->filter_reg
== NULL
)
2105 src
->filter_reg
= gen_reg_rtx (fmode
);
2107 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2108 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2113 /* Do any necessary initialization to access arbitrary stack frames.
2114 On the SPARC, this means flushing the register windows. */
2117 expand_builtin_unwind_init (void)
2119 /* Set this so all the registers get saved in our frame; we need to be
2120 able to copy the saved values for any registers from frames we unwind. */
2121 crtl
->saves_all_registers
= 1;
2123 SETUP_FRAME_ADDRESSES ();
2126 /* Map a non-negative number to an eh return data register number; expands
2127 to -1 if no return data register is associated with the input number.
2128 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2131 expand_builtin_eh_return_data_regno (tree exp
)
2133 tree which
= CALL_EXPR_ARG (exp
, 0);
2134 unsigned HOST_WIDE_INT iwhich
;
2136 if (TREE_CODE (which
) != INTEGER_CST
)
2138 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2142 iwhich
= tree_to_uhwi (which
);
2143 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2144 if (iwhich
== INVALID_REGNUM
)
2147 #ifdef DWARF_FRAME_REGNUM
2148 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2150 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2153 return GEN_INT (iwhich
);
2156 /* Given a value extracted from the return address register or stack slot,
2157 return the actual address encoded in that value. */
2160 expand_builtin_extract_return_addr (tree addr_tree
)
2162 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2164 if (GET_MODE (addr
) != Pmode
2165 && GET_MODE (addr
) != VOIDmode
)
2167 #ifdef POINTERS_EXTEND_UNSIGNED
2168 addr
= convert_memory_address (Pmode
, addr
);
2170 addr
= convert_to_mode (Pmode
, addr
, 0);
2174 /* First mask out any unwanted bits. */
2175 rtx mask
= MASK_RETURN_ADDR
;
2177 expand_and (Pmode
, addr
, mask
, addr
);
2179 /* Then adjust to find the real return address. */
2180 if (RETURN_ADDR_OFFSET
)
2181 addr
= plus_constant (Pmode
, addr
, RETURN_ADDR_OFFSET
);
2186 /* Given an actual address in addr_tree, do any necessary encoding
2187 and return the value to be stored in the return address register or
2188 stack slot so the epilogue will return to that address. */
2191 expand_builtin_frob_return_addr (tree addr_tree
)
2193 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2195 addr
= convert_memory_address (Pmode
, addr
);
2197 if (RETURN_ADDR_OFFSET
)
2199 addr
= force_reg (Pmode
, addr
);
2200 addr
= plus_constant (Pmode
, addr
, -RETURN_ADDR_OFFSET
);
2206 /* Set up the epilogue with the magic bits we'll need to return to the
2207 exception handler. */
2210 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2215 #ifdef EH_RETURN_STACKADJ_RTX
2216 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2217 VOIDmode
, EXPAND_NORMAL
);
2218 tmp
= convert_memory_address (Pmode
, tmp
);
2219 if (!crtl
->eh
.ehr_stackadj
)
2220 crtl
->eh
.ehr_stackadj
= copy_addr_to_reg (tmp
);
2221 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2222 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2225 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2226 VOIDmode
, EXPAND_NORMAL
);
2227 tmp
= convert_memory_address (Pmode
, tmp
);
2228 if (!crtl
->eh
.ehr_handler
)
2229 crtl
->eh
.ehr_handler
= copy_addr_to_reg (tmp
);
2230 else if (tmp
!= crtl
->eh
.ehr_handler
)
2231 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2233 if (!crtl
->eh
.ehr_label
)
2234 crtl
->eh
.ehr_label
= gen_label_rtx ();
2235 emit_jump (crtl
->eh
.ehr_label
);
2238 /* Expand __builtin_eh_return. This exit path from the function loads up
2239 the eh return data registers, adjusts the stack, and branches to a
2240 given PC other than the normal return address. */
2243 expand_eh_return (void)
2245 rtx_code_label
*around_label
;
2247 if (! crtl
->eh
.ehr_label
)
2250 crtl
->calls_eh_return
= 1;
2252 #ifdef EH_RETURN_STACKADJ_RTX
2253 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2256 around_label
= gen_label_rtx ();
2257 emit_jump (around_label
);
2259 emit_label (crtl
->eh
.ehr_label
);
2260 clobber_return_register ();
2262 #ifdef EH_RETURN_STACKADJ_RTX
2263 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2266 if (targetm
.have_eh_return ())
2267 emit_insn (targetm
.gen_eh_return (crtl
->eh
.ehr_handler
));
2270 #ifdef EH_RETURN_HANDLER_RTX
2271 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2273 error ("__builtin_eh_return not supported on this target");
2277 emit_label (around_label
);
2280 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2281 POINTERS_EXTEND_UNSIGNED and return it. */
2284 expand_builtin_extend_pointer (tree addr_tree
)
2286 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2289 #ifdef POINTERS_EXTEND_UNSIGNED
2290 extend
= POINTERS_EXTEND_UNSIGNED
;
2292 /* The previous EH code did an unsigned extend by default, so we do this also
2297 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2301 add_action_record (action_hash_type
*ar_hash
, int filter
, int next
)
2303 struct action_record
**slot
, *new_ar
, tmp
;
2305 tmp
.filter
= filter
;
2307 slot
= ar_hash
->find_slot (&tmp
, INSERT
);
2309 if ((new_ar
= *slot
) == NULL
)
2311 new_ar
= XNEW (struct action_record
);
2312 new_ar
->offset
= crtl
->eh
.action_record_data
->length () + 1;
2313 new_ar
->filter
= filter
;
2314 new_ar
->next
= next
;
2317 /* The filter value goes in untouched. The link to the next
2318 record is a "self-relative" byte offset, or zero to indicate
2319 that there is no next record. So convert the absolute 1 based
2320 indices we've been carrying around into a displacement. */
2322 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2324 next
-= crtl
->eh
.action_record_data
->length () + 1;
2325 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2328 return new_ar
->offset
;
2332 collect_one_action_chain (action_hash_type
*ar_hash
, eh_region region
)
2336 /* If we've reached the top of the region chain, then we have
2337 no actions, and require no landing pad. */
2341 switch (region
->type
)
2346 /* A cleanup adds a zero filter to the beginning of the chain, but
2347 there are special cases to look out for. If there are *only*
2348 cleanups along a path, then it compresses to a zero action.
2349 Further, if there are multiple cleanups along a path, we only
2350 need to represent one of them, as that is enough to trigger
2351 entry to the landing pad at runtime. */
2352 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2355 for (r
= region
->outer
; r
; r
= r
->outer
)
2356 if (r
->type
== ERT_CLEANUP
)
2358 return add_action_record (ar_hash
, 0, next
);
2365 /* Process the associated catch regions in reverse order.
2366 If there's a catch-all handler, then we don't need to
2367 search outer regions. Use a magic -3 value to record
2368 that we haven't done the outer search. */
2370 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2372 if (c
->type_list
== NULL
)
2374 /* Retrieve the filter from the head of the filter list
2375 where we have stored it (see assign_filter_values). */
2376 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2377 next
= add_action_record (ar_hash
, filter
, 0);
2381 /* Once the outer search is done, trigger an action record for
2382 each filter we have. */
2387 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2389 /* If there is no next action, terminate the chain. */
2392 /* If all outer actions are cleanups or must_not_throw,
2393 we'll have no action record for it, since we had wanted
2394 to encode these states in the call-site record directly.
2395 Add a cleanup action to the chain to catch these. */
2397 next
= add_action_record (ar_hash
, 0, 0);
2400 flt_node
= c
->filter_list
;
2401 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2403 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2404 next
= add_action_record (ar_hash
, filter
, next
);
2411 case ERT_ALLOWED_EXCEPTIONS
:
2412 /* An exception specification adds its filter to the
2413 beginning of the chain. */
2414 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2416 /* If there is no next action, terminate the chain. */
2419 /* If all outer actions are cleanups or must_not_throw,
2420 we'll have no action record for it, since we had wanted
2421 to encode these states in the call-site record directly.
2422 Add a cleanup action to the chain to catch these. */
2424 next
= add_action_record (ar_hash
, 0, 0);
2426 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2428 case ERT_MUST_NOT_THROW
:
2429 /* A must-not-throw region with no inner handlers or cleanups
2430 requires no call-site entry. Note that this differs from
2431 the no handler or cleanup case in that we do require an lsda
2432 to be generated. Return a magic -2 value to record this. */
2440 add_call_site (rtx landing_pad
, int action
, int section
)
2442 call_site_record record
;
2444 record
= ggc_alloc
<call_site_record_d
> ();
2445 record
->landing_pad
= landing_pad
;
2446 record
->action
= action
;
2448 vec_safe_push (crtl
->eh
.call_site_record_v
[section
], record
);
2450 return call_site_base
+ crtl
->eh
.call_site_record_v
[section
]->length () - 1;
2454 emit_note_eh_region_end (rtx_insn
*insn
)
2456 rtx_insn
*next
= NEXT_INSN (insn
);
2458 /* Make sure we do not split a call and its corresponding
2459 CALL_ARG_LOCATION note. */
2460 if (next
&& NOTE_P (next
)
2461 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
2464 return emit_note_after (NOTE_INSN_EH_REGION_END
, insn
);
2467 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2468 The new note numbers will not refer to region numbers, but
2469 instead to call site entries. */
2472 convert_to_eh_region_ranges (void)
2477 action_hash_type
ar_hash (31);
2478 int last_action
= -3;
2479 rtx_insn
*last_action_insn
= NULL
;
2480 rtx last_landing_pad
= NULL_RTX
;
2481 rtx_insn
*first_no_action_insn
= NULL
;
2484 rtx_insn
*section_switch_note
= NULL
;
2485 rtx_insn
*first_no_action_insn_before_switch
= NULL
;
2486 rtx_insn
*last_no_action_insn_before_switch
= NULL
;
2487 int saved_call_site_base
= call_site_base
;
2489 vec_alloc (crtl
->eh
.action_record_data
, 64);
2491 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2498 rtx_code_label
*this_landing_pad
;
2501 if (NONJUMP_INSN_P (insn
)
2502 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2503 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2505 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2509 this_action
= collect_one_action_chain (&ar_hash
, region
);
2513 /* Existence of catch handlers, or must-not-throw regions
2514 implies that an lsda is needed (even if empty). */
2515 if (this_action
!= -1)
2516 crtl
->uses_eh_lsda
= 1;
2518 /* Delay creation of region notes for no-action regions
2519 until we're sure that an lsda will be required. */
2520 else if (last_action
== -3)
2522 first_no_action_insn
= iter
;
2526 if (this_action
>= 0)
2527 this_landing_pad
= lp
->landing_pad
;
2529 this_landing_pad
= NULL
;
2531 /* Differing actions or landing pads implies a change in call-site
2532 info, which implies some EH_REGION note should be emitted. */
2533 if (last_action
!= this_action
2534 || last_landing_pad
!= this_landing_pad
)
2536 /* If there is a queued no-action region in the other section
2537 with hot/cold partitioning, emit it now. */
2538 if (first_no_action_insn_before_switch
)
2540 gcc_assert (this_action
!= -1
2541 && last_action
== (first_no_action_insn
2543 call_site
= add_call_site (NULL_RTX
, 0, 0);
2544 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2545 first_no_action_insn_before_switch
);
2546 NOTE_EH_HANDLER (note
) = call_site
;
2548 = emit_note_eh_region_end (last_no_action_insn_before_switch
);
2549 NOTE_EH_HANDLER (note
) = call_site
;
2550 gcc_assert (last_action
!= -3
2551 || (last_action_insn
2552 == last_no_action_insn_before_switch
));
2553 first_no_action_insn_before_switch
= NULL
;
2554 last_no_action_insn_before_switch
= NULL
;
2557 /* If we'd not seen a previous action (-3) or the previous
2558 action was must-not-throw (-2), then we do not need an
2560 if (last_action
>= -1)
2562 /* If we delayed the creation of the begin, do it now. */
2563 if (first_no_action_insn
)
2565 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2566 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2567 first_no_action_insn
);
2568 NOTE_EH_HANDLER (note
) = call_site
;
2569 first_no_action_insn
= NULL
;
2572 note
= emit_note_eh_region_end (last_action_insn
);
2573 NOTE_EH_HANDLER (note
) = call_site
;
2576 /* If the new action is must-not-throw, then no region notes
2578 if (this_action
>= -1)
2580 call_site
= add_call_site (this_landing_pad
,
2581 this_action
< 0 ? 0 : this_action
,
2583 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2584 NOTE_EH_HANDLER (note
) = call_site
;
2587 last_action
= this_action
;
2588 last_landing_pad
= this_landing_pad
;
2590 last_action_insn
= iter
;
2592 else if (NOTE_P (iter
)
2593 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2595 gcc_assert (section_switch_note
== NULL_RTX
);
2596 gcc_assert (flag_reorder_blocks_and_partition
);
2597 section_switch_note
= iter
;
2598 if (first_no_action_insn
)
2600 first_no_action_insn_before_switch
= first_no_action_insn
;
2601 last_no_action_insn_before_switch
= last_action_insn
;
2602 first_no_action_insn
= NULL
;
2603 gcc_assert (last_action
== -1);
2606 /* Force closing of current EH region before section switch and
2607 opening a new one afterwards. */
2608 else if (last_action
!= -3)
2609 last_landing_pad
= pc_rtx
;
2610 if (crtl
->eh
.call_site_record_v
[cur_sec
])
2611 call_site_base
+= crtl
->eh
.call_site_record_v
[cur_sec
]->length ();
2613 gcc_assert (crtl
->eh
.call_site_record_v
[cur_sec
] == NULL
);
2614 vec_alloc (crtl
->eh
.call_site_record_v
[cur_sec
], 10);
2617 if (last_action
>= -1 && ! first_no_action_insn
)
2619 note
= emit_note_eh_region_end (last_action_insn
);
2620 NOTE_EH_HANDLER (note
) = call_site
;
2623 call_site_base
= saved_call_site_base
;
2630 const pass_data pass_data_convert_to_eh_region_ranges
=
2632 RTL_PASS
, /* type */
2633 "eh_ranges", /* name */
2634 OPTGROUP_NONE
, /* optinfo_flags */
2635 TV_NONE
, /* tv_id */
2636 0, /* properties_required */
2637 0, /* properties_provided */
2638 0, /* properties_destroyed */
2639 0, /* todo_flags_start */
2640 0, /* todo_flags_finish */
2643 class pass_convert_to_eh_region_ranges
: public rtl_opt_pass
2646 pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2647 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges
, ctxt
)
2650 /* opt_pass methods: */
2651 virtual bool gate (function
*);
2652 virtual unsigned int execute (function
*)
2654 return convert_to_eh_region_ranges ();
2657 }; // class pass_convert_to_eh_region_ranges
2660 pass_convert_to_eh_region_ranges::gate (function
*)
2662 /* Nothing to do for SJLJ exceptions or if no regions created. */
2663 if (cfun
->eh
->region_tree
== NULL
)
2665 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2673 make_pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2675 return new pass_convert_to_eh_region_ranges (ctxt
);
2679 push_uleb128 (vec
<uchar
, va_gc
> **data_area
, unsigned int value
)
2683 unsigned char byte
= value
& 0x7f;
2687 vec_safe_push (*data_area
, byte
);
2693 push_sleb128 (vec
<uchar
, va_gc
> **data_area
, int value
)
2700 byte
= value
& 0x7f;
2702 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2703 || (value
== -1 && (byte
& 0x40) != 0));
2706 vec_safe_push (*data_area
, byte
);
2712 #ifndef HAVE_AS_LEB128
2714 dw2_size_of_call_site_table (int section
)
2716 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2717 int size
= n
* (4 + 4 + 4);
2720 for (i
= 0; i
< n
; ++i
)
2722 struct call_site_record_d
*cs
=
2723 (*crtl
->eh
.call_site_record_v
[section
])[i
];
2724 size
+= size_of_uleb128 (cs
->action
);
2731 sjlj_size_of_call_site_table (void)
2733 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2737 for (i
= 0; i
< n
; ++i
)
2739 struct call_site_record_d
*cs
=
2740 (*crtl
->eh
.call_site_record_v
[0])[i
];
2741 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2742 size
+= size_of_uleb128 (cs
->action
);
2750 dw2_output_call_site_table (int cs_format
, int section
)
2752 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2757 begin
= current_function_func_begin_label
;
2758 else if (first_function_block_is_cold
)
2759 begin
= crtl
->subsections
.hot_section_label
;
2761 begin
= crtl
->subsections
.cold_section_label
;
2763 for (i
= 0; i
< n
; ++i
)
2765 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[section
])[i
];
2766 char reg_start_lab
[32];
2767 char reg_end_lab
[32];
2768 char landing_pad_lab
[32];
2770 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2771 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2773 if (cs
->landing_pad
)
2774 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2775 CODE_LABEL_NUMBER (cs
->landing_pad
));
2777 /* ??? Perhaps use insn length scaling if the assembler supports
2778 generic arithmetic. */
2779 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2780 data4 if the function is small enough. */
2781 if (cs_format
== DW_EH_PE_uleb128
)
2783 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2784 "region %d start", i
);
2785 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2787 if (cs
->landing_pad
)
2788 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2791 dw2_asm_output_data_uleb128 (0, "landing pad");
2795 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2796 "region %d start", i
);
2797 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2798 if (cs
->landing_pad
)
2799 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2802 dw2_asm_output_data (4, 0, "landing pad");
2804 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2807 call_site_base
+= n
;
2811 sjlj_output_call_site_table (void)
2813 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2816 for (i
= 0; i
< n
; ++i
)
2818 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[0])[i
];
2820 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2821 "region %d landing pad", i
);
2822 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2825 call_site_base
+= n
;
2828 /* Switch to the section that should be used for exception tables. */
2831 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2835 if (exception_section
)
2836 s
= exception_section
;
2841 if (EH_TABLES_CAN_BE_READ_ONLY
)
2844 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2845 flags
= ((! flag_pic
2846 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2847 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2848 ? 0 : SECTION_WRITE
);
2851 flags
= SECTION_WRITE
;
2853 /* Compute the section and cache it into exception_section,
2854 unless it depends on the function name. */
2855 if (targetm_common
.have_named_sections
)
2857 #ifdef HAVE_LD_EH_GC_SECTIONS
2858 if (flag_function_sections
2859 || (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
))
2861 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2862 /* The EH table must match the code section, so only mark
2863 it linkonce if we have COMDAT groups to tie them together. */
2864 if (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
)
2865 flags
|= SECTION_LINKONCE
;
2866 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2867 s
= get_section (section_name
, flags
, current_function_decl
);
2868 free (section_name
);
2873 = s
= get_section (".gcc_except_table", flags
, NULL
);
2877 = s
= flags
== SECTION_WRITE
? data_section
: readonly_data_section
;
2880 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 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2899 runtime types so TYPE should already be a runtime type
2900 reference. When pass_ipa_free_lang data is made a default
2901 pass, we can then remove the call to lookup_type_for_runtime
2904 type
= lookup_type_for_runtime (type
);
2906 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2908 /* Let cgraph know that the rtti decl is used. Not all of the
2909 paths below go through assemble_integer, which would take
2910 care of this for us. */
2912 if (TREE_CODE (type
) == ADDR_EXPR
)
2914 type
= TREE_OPERAND (type
, 0);
2915 if (TREE_CODE (type
) == VAR_DECL
)
2916 is_public
= TREE_PUBLIC (type
);
2919 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2922 /* Allow the target to override the type table entry format. */
2923 if (targetm
.asm_out
.ttype (value
))
2926 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2927 assemble_integer (value
, tt_format_size
,
2928 tt_format_size
* BITS_PER_UNIT
, 1);
2930 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2934 output_one_function_exception_table (int section
)
2936 int tt_format
, cs_format
, lp_format
, i
;
2937 #ifdef HAVE_AS_LEB128
2938 char ttype_label
[32];
2939 char cs_after_size_label
[32];
2940 char cs_end_label
[32];
2945 int tt_format_size
= 0;
2947 have_tt_data
= (vec_safe_length (cfun
->eh
->ttype_data
)
2948 || (targetm
.arm_eabi_unwinder
2949 ? vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
)
2950 : vec_safe_length (cfun
->eh
->ehspec_data
.other
)));
2952 /* Indicate the format of the @TType entries. */
2954 tt_format
= DW_EH_PE_omit
;
2957 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2958 #ifdef HAVE_AS_LEB128
2959 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2960 section
? "LLSDATTC" : "LLSDATT",
2961 current_function_funcdef_no
);
2963 tt_format_size
= size_of_encoded_value (tt_format
);
2965 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2968 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2969 current_function_funcdef_no
);
2971 /* The LSDA header. */
2973 /* Indicate the format of the landing pad start pointer. An omitted
2974 field implies @LPStart == @Start. */
2975 /* Currently we always put @LPStart == @Start. This field would
2976 be most useful in moving the landing pads completely out of
2977 line to another section, but it could also be used to minimize
2978 the size of uleb128 landing pad offsets. */
2979 lp_format
= DW_EH_PE_omit
;
2980 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
2981 eh_data_format_name (lp_format
));
2983 /* @LPStart pointer would go here. */
2985 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
2986 eh_data_format_name (tt_format
));
2988 #ifndef HAVE_AS_LEB128
2989 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2990 call_site_len
= sjlj_size_of_call_site_table ();
2992 call_site_len
= dw2_size_of_call_site_table (section
);
2995 /* A pc-relative 4-byte displacement to the @TType data. */
2998 #ifdef HAVE_AS_LEB128
2999 char ttype_after_disp_label
[32];
3000 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
3001 section
? "LLSDATTDC" : "LLSDATTD",
3002 current_function_funcdef_no
);
3003 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3004 "@TType base offset");
3005 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3007 /* Ug. Alignment queers things. */
3008 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3010 before_disp
= 1 + 1;
3011 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3013 + vec_safe_length (crtl
->eh
.action_record_data
)
3014 + (vec_safe_length (cfun
->eh
->ttype_data
)
3020 unsigned int disp_size
, pad
;
3023 disp_size
= size_of_uleb128 (disp
);
3024 pad
= before_disp
+ disp_size
+ after_disp
;
3025 if (pad
% tt_format_size
)
3026 pad
= tt_format_size
- (pad
% tt_format_size
);
3029 disp
= after_disp
+ pad
;
3031 while (disp
!= last_disp
);
3033 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3037 /* Indicate the format of the call-site offsets. */
3038 #ifdef HAVE_AS_LEB128
3039 cs_format
= DW_EH_PE_uleb128
;
3041 cs_format
= DW_EH_PE_udata4
;
3043 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3044 eh_data_format_name (cs_format
));
3046 #ifdef HAVE_AS_LEB128
3047 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3048 section
? "LLSDACSBC" : "LLSDACSB",
3049 current_function_funcdef_no
);
3050 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3051 section
? "LLSDACSEC" : "LLSDACSE",
3052 current_function_funcdef_no
);
3053 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3054 "Call-site table length");
3055 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3056 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3057 sjlj_output_call_site_table ();
3059 dw2_output_call_site_table (cs_format
, section
);
3060 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3062 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3063 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3064 sjlj_output_call_site_table ();
3066 dw2_output_call_site_table (cs_format
, section
);
3069 /* ??? Decode and interpret the data for flag_debug_asm. */
3072 FOR_EACH_VEC_ELT (*crtl
->eh
.action_record_data
, i
, uc
)
3073 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3077 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3079 i
= vec_safe_length (cfun
->eh
->ttype_data
);
3082 tree type
= (*cfun
->eh
->ttype_data
)[i
];
3083 output_ttype (type
, tt_format
, tt_format_size
);
3086 #ifdef HAVE_AS_LEB128
3088 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3091 /* ??? Decode and interpret the data for flag_debug_asm. */
3092 if (targetm
.arm_eabi_unwinder
)
3096 vec_safe_iterate (cfun
->eh
->ehspec_data
.arm_eabi
, i
, &type
); ++i
)
3097 output_ttype (type
, tt_format
, tt_format_size
);
3103 vec_safe_iterate (cfun
->eh
->ehspec_data
.other
, i
, &uc
); ++i
)
3104 dw2_asm_output_data (1, uc
,
3105 i
? NULL
: "Exception specification table");
3110 output_function_exception_table (const char *fnname
)
3112 rtx personality
= get_personality_function (current_function_decl
);
3114 /* Not all functions need anything. */
3115 if (! crtl
->uses_eh_lsda
)
3120 assemble_external_libcall (personality
);
3122 if (targetm
.asm_out
.emit_except_personality
)
3123 targetm
.asm_out
.emit_except_personality (personality
);
3126 switch_to_exception_section (fnname
);
3128 /* If the target wants a label to begin the table, emit it here. */
3129 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3131 output_one_function_exception_table (0);
3132 if (crtl
->eh
.call_site_record_v
[1])
3133 output_one_function_exception_table (1);
3135 switch_to_section (current_function_section ());
3139 set_eh_throw_stmt_table (function
*fun
, hash_map
<gimple
*, int> *table
)
3141 fun
->eh
->throw_stmt_table
= table
;
3144 hash_map
<gimple
*, int> *
3145 get_eh_throw_stmt_table (struct function
*fun
)
3147 return fun
->eh
->throw_stmt_table
;
3150 /* Determine if the function needs an EH personality function. */
3152 enum eh_personality_kind
3153 function_needs_eh_personality (struct function
*fn
)
3155 enum eh_personality_kind kind
= eh_personality_none
;
3158 FOR_ALL_EH_REGION_FN (i
, fn
)
3163 /* Can do with any personality including the generic C one. */
3164 kind
= eh_personality_any
;
3168 case ERT_ALLOWED_EXCEPTIONS
:
3169 /* Always needs a EH personality function. The generic C
3170 personality doesn't handle these even for empty type lists. */
3171 return eh_personality_lang
;
3173 case ERT_MUST_NOT_THROW
:
3174 /* Always needs a EH personality function. The language may specify
3175 what abort routine that must be used, e.g. std::terminate. */
3176 return eh_personality_lang
;
3183 /* Dump EH information to OUT. */
3186 dump_eh_tree (FILE * out
, struct function
*fun
)
3190 static const char *const type_name
[] = {
3191 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3194 i
= fun
->eh
->region_tree
;
3198 fprintf (out
, "Eh tree:\n");
3201 fprintf (out
, " %*s %i %s", depth
* 2, "",
3202 i
->index
, type_name
[(int) i
->type
]);
3204 if (i
->landing_pads
)
3208 fprintf (out
, " land:");
3209 if (current_ir_type () == IR_GIMPLE
)
3211 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3213 fprintf (out
, "{%i,", lp
->index
);
3214 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3222 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3224 fprintf (out
, "{%i,", lp
->index
);
3225 if (lp
->landing_pad
)
3226 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3227 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3229 fprintf (out
, "(nil),");
3230 if (lp
->post_landing_pad
)
3232 rtx_insn
*lab
= label_rtx (lp
->post_landing_pad
);
3233 fprintf (out
, "%i%s}", INSN_UID (lab
),
3234 NOTE_P (lab
) ? "(del)" : "");
3237 fprintf (out
, "(nil)}");
3247 case ERT_MUST_NOT_THROW
:
3253 fprintf (out
, " catch:");
3254 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3259 fprintf (out
, "lab:");
3260 print_generic_expr (out
, c
->label
, 0);
3263 print_generic_expr (out
, c
->type_list
, 0);
3271 case ERT_ALLOWED_EXCEPTIONS
:
3272 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3273 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3278 /* If there are sub-regions, process them. */
3280 i
= i
->inner
, depth
++;
3281 /* If there are peers, process them. */
3282 else if (i
->next_peer
)
3284 /* Otherwise, step back up the tree to the next peer. */
3294 while (i
->next_peer
== NULL
);
3300 /* Dump the EH tree for FN on stderr. */
3303 debug_eh_tree (struct function
*fn
)
3305 dump_eh_tree (stderr
, fn
);
3308 /* Verify invariants on EH datastructures. */
3311 verify_eh_tree (struct function
*fun
)
3314 int nvisited_lp
, nvisited_r
;
3315 int count_lp
, count_r
, depth
, i
;
3319 if (!fun
->eh
->region_tree
)
3323 for (i
= 1; vec_safe_iterate (fun
->eh
->region_array
, i
, &r
); ++i
)
3330 error ("region_array is corrupted for region %i", r
->index
);
3336 for (i
= 1; vec_safe_iterate (fun
->eh
->lp_array
, i
, &lp
); ++i
)
3343 error ("lp_array is corrupted for lp %i", lp
->index
);
3348 depth
= nvisited_lp
= nvisited_r
= 0;
3350 r
= fun
->eh
->region_tree
;
3353 if ((*fun
->eh
->region_array
)[r
->index
] != r
)
3355 error ("region_array is corrupted for region %i", r
->index
);
3358 if (r
->outer
!= outer
)
3360 error ("outer block of region %i is wrong", r
->index
);
3365 error ("negative nesting depth of region %i", r
->index
);
3370 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3372 if ((*fun
->eh
->lp_array
)[lp
->index
] != lp
)
3374 error ("lp_array is corrupted for lp %i", lp
->index
);
3377 if (lp
->region
!= r
)
3379 error ("region of lp %i is wrong", lp
->index
);
3386 outer
= r
, r
= r
->inner
, depth
++;
3387 else if (r
->next_peer
)
3399 while (r
->next_peer
== NULL
);
3406 error ("tree list ends on depth %i", depth
);
3409 if (count_r
!= nvisited_r
)
3411 error ("region_array does not match region_tree");
3414 if (count_lp
!= nvisited_lp
)
3416 error ("lp_array does not match region_tree");
3422 dump_eh_tree (stderr
, fun
);
3423 internal_error ("verify_eh_tree failed");
3427 #include "gt-except.h"