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"
120 #include "fold-const.h"
121 #include "stringpool.h"
122 #include "stor-layout.h"
124 #include "hard-reg-set.h"
125 #include "function.h"
126 #include "insn-codes.h"
128 #include "insn-config.h"
133 #include "emit-rtl.h"
137 #include "libfuncs.h"
140 #include "dwarf2asm.h"
141 #include "dwarf2out.h"
147 #include "common/common-target.h"
148 #include "langhooks.h"
150 #include "dominance.h"
153 #include "basic-block.h"
155 #include "diagnostic.h"
156 #include "tree-pretty-print.h"
157 #include "tree-pass.h"
159 #include "builtins.h"
160 #include "tree-hash-traits.h"
162 static GTY(()) int call_site_base
;
164 static GTY (()) hash_map
<tree_hash
, tree
> *type_to_runtime_map
;
166 /* Describe the SjLj_Function_Context structure. */
167 static GTY(()) tree sjlj_fc_type_node
;
168 static int sjlj_fc_call_site_ofs
;
169 static int sjlj_fc_data_ofs
;
170 static int sjlj_fc_personality_ofs
;
171 static int sjlj_fc_lsda_ofs
;
172 static int sjlj_fc_jbuf_ofs
;
175 struct GTY(()) call_site_record_d
181 /* In the following structure and associated functions,
182 we represent entries in the action table as 1-based indices.
185 0: null action record, non-null landing pad; implies cleanups
186 -1: null action record, null landing pad; implies no action
187 -2: no call-site entry; implies must_not_throw
188 -3: we have yet to process outer regions
190 Further, no special cases apply to the "next" field of the record.
191 For next, 0 means end of list. */
200 /* Hashtable helpers. */
202 struct action_record_hasher
: free_ptr_hash
<action_record
>
204 static inline hashval_t
hash (const action_record
*);
205 static inline bool equal (const action_record
*, const action_record
*);
209 action_record_hasher::hash (const action_record
*entry
)
211 return entry
->next
* 1009 + entry
->filter
;
215 action_record_hasher::equal (const action_record
*entry
,
216 const action_record
*data
)
218 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
221 typedef hash_table
<action_record_hasher
> action_hash_type
;
223 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
226 static void dw2_build_landing_pads (void);
228 static int collect_one_action_chain (action_hash_type
*, eh_region
);
229 static int add_call_site (rtx
, int, int);
231 static void push_uleb128 (vec
<uchar
, va_gc
> **, unsigned int);
232 static void push_sleb128 (vec
<uchar
, va_gc
> **, int);
233 #ifndef HAVE_AS_LEB128
234 static int dw2_size_of_call_site_table (int);
235 static int sjlj_size_of_call_site_table (void);
237 static void dw2_output_call_site_table (int, int);
238 static void sjlj_output_call_site_table (void);
244 if (! flag_exceptions
)
247 type_to_runtime_map
= hash_map
<tree_hash
, tree
>::create_ggc (31);
249 /* Create the SjLj_Function_Context structure. This should match
250 the definition in unwind-sjlj.c. */
251 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
253 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
255 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
257 f_prev
= build_decl (BUILTINS_LOCATION
,
258 FIELD_DECL
, get_identifier ("__prev"),
259 build_pointer_type (sjlj_fc_type_node
));
260 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
262 f_cs
= build_decl (BUILTINS_LOCATION
,
263 FIELD_DECL
, get_identifier ("__call_site"),
265 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
267 tmp
= build_index_type (size_int (4 - 1));
268 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
269 (targetm
.unwind_word_mode (), 1),
271 f_data
= build_decl (BUILTINS_LOCATION
,
272 FIELD_DECL
, get_identifier ("__data"), tmp
);
273 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
275 f_per
= build_decl (BUILTINS_LOCATION
,
276 FIELD_DECL
, get_identifier ("__personality"),
278 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
280 f_lsda
= build_decl (BUILTINS_LOCATION
,
281 FIELD_DECL
, get_identifier ("__lsda"),
283 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
285 #ifdef DONT_USE_BUILTIN_SETJMP
287 tmp
= size_int (JMP_BUF_SIZE
- 1);
289 /* Should be large enough for most systems, if it is not,
290 JMP_BUF_SIZE should be defined with the proper value. It will
291 also tend to be larger than necessary for most systems, a more
292 optimal port will define JMP_BUF_SIZE. */
293 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
296 /* Compute a minimally sized jump buffer. We need room to store at
297 least 3 pointers - stack pointer, frame pointer and return address.
298 Plus for some targets we need room for an extra pointer - in the
299 case of MIPS this is the global pointer. This makes a total of four
300 pointers, but to be safe we actually allocate room for 5.
302 If pointers are smaller than words then we allocate enough room for
303 5 words, just in case the backend needs this much room. For more
304 discussion on this issue see:
305 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
306 if (POINTER_SIZE
> BITS_PER_WORD
)
307 tmp
= size_int (5 - 1);
309 tmp
= size_int ((5 * BITS_PER_WORD
/ POINTER_SIZE
) - 1);
312 tmp
= build_index_type (tmp
);
313 tmp
= build_array_type (ptr_type_node
, tmp
);
314 f_jbuf
= build_decl (BUILTINS_LOCATION
,
315 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
316 #ifdef DONT_USE_BUILTIN_SETJMP
317 /* We don't know what the alignment requirements of the
318 runtime's jmp_buf has. Overestimate. */
319 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
320 DECL_USER_ALIGN (f_jbuf
) = 1;
322 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
324 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
325 TREE_CHAIN (f_prev
) = f_cs
;
326 TREE_CHAIN (f_cs
) = f_data
;
327 TREE_CHAIN (f_data
) = f_per
;
328 TREE_CHAIN (f_per
) = f_lsda
;
329 TREE_CHAIN (f_lsda
) = f_jbuf
;
331 layout_type (sjlj_fc_type_node
);
333 /* Cache the interesting field offsets so that we have
334 easy access from rtl. */
335 sjlj_fc_call_site_ofs
336 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs
))
337 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs
)) / BITS_PER_UNIT
);
339 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data
))
340 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data
)) / BITS_PER_UNIT
);
341 sjlj_fc_personality_ofs
342 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per
))
343 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per
)) / BITS_PER_UNIT
);
345 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda
))
346 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda
)) / BITS_PER_UNIT
);
348 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf
))
349 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf
)) / BITS_PER_UNIT
);
354 init_eh_for_function (void)
356 cfun
->eh
= ggc_cleared_alloc
<eh_status
> ();
358 /* Make sure zero'th entries are used. */
359 vec_safe_push (cfun
->eh
->region_array
, (eh_region
)0);
360 vec_safe_push (cfun
->eh
->lp_array
, (eh_landing_pad
)0);
363 /* Routines to generate the exception tree somewhat directly.
364 These are used from tree-eh.c when processing exception related
365 nodes during tree optimization. */
368 gen_eh_region (enum eh_region_type type
, eh_region outer
)
372 /* Insert a new blank region as a leaf in the tree. */
373 new_eh
= ggc_cleared_alloc
<eh_region_d
> ();
375 new_eh
->outer
= outer
;
378 new_eh
->next_peer
= outer
->inner
;
379 outer
->inner
= new_eh
;
383 new_eh
->next_peer
= cfun
->eh
->region_tree
;
384 cfun
->eh
->region_tree
= new_eh
;
387 new_eh
->index
= vec_safe_length (cfun
->eh
->region_array
);
388 vec_safe_push (cfun
->eh
->region_array
, new_eh
);
390 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
391 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
392 new_eh
->use_cxa_end_cleanup
= true;
398 gen_eh_region_cleanup (eh_region outer
)
400 return gen_eh_region (ERT_CLEANUP
, outer
);
404 gen_eh_region_try (eh_region outer
)
406 return gen_eh_region (ERT_TRY
, outer
);
410 gen_eh_region_catch (eh_region t
, tree type_or_list
)
413 tree type_list
, type_node
;
415 gcc_assert (t
->type
== ERT_TRY
);
417 /* Ensure to always end up with a type list to normalize further
418 processing, then register each type against the runtime types map. */
419 type_list
= type_or_list
;
422 if (TREE_CODE (type_or_list
) != TREE_LIST
)
423 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
425 type_node
= type_list
;
426 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
427 add_type_for_runtime (TREE_VALUE (type_node
));
430 c
= ggc_cleared_alloc
<eh_catch_d
> ();
431 c
->type_list
= type_list
;
432 l
= t
->u
.eh_try
.last_catch
;
437 t
->u
.eh_try
.first_catch
= c
;
438 t
->u
.eh_try
.last_catch
= c
;
444 gen_eh_region_allowed (eh_region outer
, tree allowed
)
446 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
447 region
->u
.allowed
.type_list
= allowed
;
449 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
450 add_type_for_runtime (TREE_VALUE (allowed
));
456 gen_eh_region_must_not_throw (eh_region outer
)
458 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
462 gen_eh_landing_pad (eh_region region
)
464 eh_landing_pad lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
466 lp
->next_lp
= region
->landing_pads
;
468 lp
->index
= vec_safe_length (cfun
->eh
->lp_array
);
469 region
->landing_pads
= lp
;
471 vec_safe_push (cfun
->eh
->lp_array
, lp
);
477 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
479 return (*ifun
->eh
->region_array
)[i
];
483 get_eh_region_from_number (int i
)
485 return get_eh_region_from_number_fn (cfun
, i
);
489 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
491 return (*ifun
->eh
->lp_array
)[i
];
495 get_eh_landing_pad_from_number (int i
)
497 return get_eh_landing_pad_from_number_fn (cfun
, i
);
501 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
504 return (*ifun
->eh
->region_array
)[-i
];
510 lp
= (*ifun
->eh
->lp_array
)[i
];
516 get_eh_region_from_lp_number (int i
)
518 return get_eh_region_from_lp_number_fn (cfun
, i
);
521 /* Returns true if the current function has exception handling regions. */
524 current_function_has_exception_handlers (void)
526 return cfun
->eh
->region_tree
!= NULL
;
529 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
530 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
532 struct duplicate_eh_regions_data
534 duplicate_eh_regions_map label_map
;
535 void *label_map_data
;
536 hash_map
<void *, void *> *eh_map
;
540 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
541 eh_region old_r
, eh_region outer
)
543 eh_landing_pad old_lp
, new_lp
;
546 new_r
= gen_eh_region (old_r
->type
, outer
);
547 gcc_assert (!data
->eh_map
->put (old_r
, new_r
));
557 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
559 /* We should be doing all our region duplication before and
560 during inlining, which is before filter lists are created. */
561 gcc_assert (oc
->filter_list
== NULL
);
562 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
563 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
568 case ERT_ALLOWED_EXCEPTIONS
:
569 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
570 if (old_r
->u
.allowed
.label
)
571 new_r
->u
.allowed
.label
572 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
574 new_r
->u
.allowed
.label
= NULL_TREE
;
577 case ERT_MUST_NOT_THROW
:
578 new_r
->u
.must_not_throw
.failure_loc
=
579 LOCATION_LOCUS (old_r
->u
.must_not_throw
.failure_loc
);
580 new_r
->u
.must_not_throw
.failure_decl
=
581 old_r
->u
.must_not_throw
.failure_decl
;
585 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
587 /* Don't bother copying unused landing pads. */
588 if (old_lp
->post_landing_pad
== NULL
)
591 new_lp
= gen_eh_landing_pad (new_r
);
592 gcc_assert (!data
->eh_map
->put (old_lp
, new_lp
));
594 new_lp
->post_landing_pad
595 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
596 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
599 /* Make sure to preserve the original use of __cxa_end_cleanup. */
600 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
602 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
603 duplicate_eh_regions_1 (data
, old_r
, new_r
);
606 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
607 the current function and root the tree below OUTER_REGION.
608 The special case of COPY_REGION of NULL means all regions.
609 Remap labels using MAP/MAP_DATA callback. Return a pointer map
610 that allows the caller to remap uses of both EH regions and
613 hash_map
<void *, void *> *
614 duplicate_eh_regions (struct function
*ifun
,
615 eh_region copy_region
, int outer_lp
,
616 duplicate_eh_regions_map map
, void *map_data
)
618 struct duplicate_eh_regions_data data
;
619 eh_region outer_region
;
621 #ifdef ENABLE_CHECKING
622 verify_eh_tree (ifun
);
625 data
.label_map
= map
;
626 data
.label_map_data
= map_data
;
627 data
.eh_map
= new hash_map
<void *, void *>;
629 outer_region
= get_eh_region_from_lp_number_fn (cfun
, outer_lp
);
631 /* Copy all the regions in the subtree. */
633 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
637 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
638 duplicate_eh_regions_1 (&data
, r
, outer_region
);
641 #ifdef ENABLE_CHECKING
642 verify_eh_tree (cfun
);
648 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
651 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
656 gcc_assert (ifun
->eh
->region_array
);
657 gcc_assert (ifun
->eh
->region_tree
);
659 b_outer
= sbitmap_alloc (ifun
->eh
->region_array
->length ());
660 bitmap_clear (b_outer
);
664 bitmap_set_bit (b_outer
, region_b
->index
);
665 region_b
= region_b
->outer
;
671 if (bitmap_bit_p (b_outer
, region_a
->index
))
673 region_a
= region_a
->outer
;
677 sbitmap_free (b_outer
);
682 add_type_for_runtime (tree type
)
684 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
685 if (TREE_CODE (type
) == NOP_EXPR
)
688 bool existed
= false;
689 tree
*slot
= &type_to_runtime_map
->get_or_insert (type
, &existed
);
691 *slot
= lang_hooks
.eh_runtime_type (type
);
695 lookup_type_for_runtime (tree type
)
697 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
698 if (TREE_CODE (type
) == NOP_EXPR
)
701 /* We should have always inserted the data earlier. */
702 return *type_to_runtime_map
->get (type
);
706 /* Represent an entry in @TTypes for either catch actions
707 or exception filter actions. */
708 struct ttypes_filter
{
713 /* Helper for ttypes_filter hashing. */
715 struct ttypes_filter_hasher
: free_ptr_hash
<ttypes_filter
>
717 typedef tree_node
*compare_type
;
718 static inline hashval_t
hash (const ttypes_filter
*);
719 static inline bool equal (const ttypes_filter
*, const tree_node
*);
722 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
723 (a tree) for a @TTypes type node we are thinking about adding. */
726 ttypes_filter_hasher::equal (const ttypes_filter
*entry
, const tree_node
*data
)
728 return entry
->t
== data
;
732 ttypes_filter_hasher::hash (const ttypes_filter
*entry
)
734 return TREE_HASH (entry
->t
);
737 typedef hash_table
<ttypes_filter_hasher
> ttypes_hash_type
;
740 /* Helper for ehspec hashing. */
742 struct ehspec_hasher
: free_ptr_hash
<ttypes_filter
>
744 static inline hashval_t
hash (const ttypes_filter
*);
745 static inline bool equal (const ttypes_filter
*, const ttypes_filter
*);
748 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
749 exception specification list we are thinking about adding. */
750 /* ??? Currently we use the type lists in the order given. Someone
751 should put these in some canonical order. */
754 ehspec_hasher::equal (const ttypes_filter
*entry
, const ttypes_filter
*data
)
756 return type_list_equal (entry
->t
, data
->t
);
759 /* Hash function for exception specification lists. */
762 ehspec_hasher::hash (const ttypes_filter
*entry
)
767 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
768 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
772 typedef hash_table
<ehspec_hasher
> ehspec_hash_type
;
775 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
776 to speed up the search. Return the filter value to be used. */
779 add_ttypes_entry (ttypes_hash_type
*ttypes_hash
, tree type
)
781 struct ttypes_filter
**slot
, *n
;
783 slot
= ttypes_hash
->find_slot_with_hash (type
, (hashval_t
) TREE_HASH (type
),
786 if ((n
= *slot
) == NULL
)
788 /* Filter value is a 1 based table index. */
790 n
= XNEW (struct ttypes_filter
);
792 n
->filter
= vec_safe_length (cfun
->eh
->ttype_data
) + 1;
795 vec_safe_push (cfun
->eh
->ttype_data
, type
);
801 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
802 to speed up the search. Return the filter value to be used. */
805 add_ehspec_entry (ehspec_hash_type
*ehspec_hash
, ttypes_hash_type
*ttypes_hash
,
808 struct ttypes_filter
**slot
, *n
;
809 struct ttypes_filter dummy
;
812 slot
= ehspec_hash
->find_slot (&dummy
, INSERT
);
814 if ((n
= *slot
) == NULL
)
818 if (targetm
.arm_eabi_unwinder
)
819 len
= vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
);
821 len
= vec_safe_length (cfun
->eh
->ehspec_data
.other
);
823 /* Filter value is a -1 based byte index into a uleb128 buffer. */
825 n
= XNEW (struct ttypes_filter
);
827 n
->filter
= -(len
+ 1);
830 /* Generate a 0 terminated list of filter values. */
831 for (; list
; list
= TREE_CHAIN (list
))
833 if (targetm
.arm_eabi_unwinder
)
834 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, TREE_VALUE (list
));
837 /* Look up each type in the list and encode its filter
838 value as a uleb128. */
839 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
840 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
843 if (targetm
.arm_eabi_unwinder
)
844 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
846 vec_safe_push (cfun
->eh
->ehspec_data
.other
, (uchar
)0);
852 /* Generate the action filter values to be used for CATCH and
853 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
854 we use lots of landing pads, and so every type or list can share
855 the same filter value, which saves table space. */
858 assign_filter_values (void)
864 vec_alloc (cfun
->eh
->ttype_data
, 16);
865 if (targetm
.arm_eabi_unwinder
)
866 vec_alloc (cfun
->eh
->ehspec_data
.arm_eabi
, 64);
868 vec_alloc (cfun
->eh
->ehspec_data
.other
, 64);
870 ehspec_hash_type
ehspec (31);
871 ttypes_hash_type
ttypes (31);
873 for (i
= 1; vec_safe_iterate (cfun
->eh
->region_array
, i
, &r
); ++i
)
881 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
883 /* Whatever type_list is (NULL or true list), we build a list
884 of filters for the region. */
885 c
->filter_list
= NULL_TREE
;
887 if (c
->type_list
!= NULL
)
889 /* Get a filter value for each of the types caught and store
890 them in the region's dedicated list. */
891 tree tp_node
= c
->type_list
;
893 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
896 = add_ttypes_entry (&ttypes
, TREE_VALUE (tp_node
));
897 tree flt_node
= build_int_cst (integer_type_node
, flt
);
900 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
905 /* Get a filter value for the NULL list also since it
906 will need an action record anyway. */
907 int flt
= add_ttypes_entry (&ttypes
, NULL
);
908 tree flt_node
= build_int_cst (integer_type_node
, flt
);
911 = tree_cons (NULL_TREE
, flt_node
, NULL
);
916 case ERT_ALLOWED_EXCEPTIONS
:
918 = add_ehspec_entry (&ehspec
, &ttypes
, r
->u
.allowed
.type_list
);
927 /* Emit SEQ into basic block just before INSN (that is assumed to be
928 first instruction of some existing BB and return the newly
931 emit_to_new_bb_before (rtx_insn
*seq
, rtx insn
)
938 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
939 call), we don't want it to go into newly created landing pad or other EH
941 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
942 if (e
->flags
& EDGE_FALLTHRU
)
943 force_nonfallthru (e
);
946 last
= emit_insn_before (seq
, insn
);
947 if (BARRIER_P (last
))
948 last
= PREV_INSN (last
);
949 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
950 update_bb_for_insn (bb
);
951 bb
->flags
|= BB_SUPERBLOCK
;
955 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
956 at the rtl level. Emit the code required by the target at a landing
957 pad for the given region. */
960 expand_dw2_landing_pad_for_region (eh_region region
)
962 if (targetm
.have_exception_receiver ())
963 emit_insn (targetm
.gen_exception_receiver ());
964 else if (targetm
.have_nonlocal_goto_receiver ())
965 emit_insn (targetm
.gen_nonlocal_goto_receiver ());
969 if (region
->exc_ptr_reg
)
970 emit_move_insn (region
->exc_ptr_reg
,
971 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
972 if (region
->filter_reg
)
973 emit_move_insn (region
->filter_reg
,
974 gen_rtx_REG (targetm
.eh_return_filter_mode (),
975 EH_RETURN_DATA_REGNO (1)));
978 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
981 dw2_build_landing_pads (void)
985 int e_flags
= EDGE_FALLTHRU
;
987 /* If we're going to partition blocks, we need to be able to add
988 new landing pads later, which means that we need to hold on to
989 the post-landing-pad block. Prevent it from being merged away.
990 We'll remove this bit after partitioning. */
991 if (flag_reorder_blocks_and_partition
)
992 e_flags
|= EDGE_PRESERVE
;
994 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1000 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
1005 lp
->landing_pad
= gen_label_rtx ();
1006 emit_label (lp
->landing_pad
);
1007 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
1009 expand_dw2_landing_pad_for_region (lp
->region
);
1014 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
1015 e
= make_edge (bb
, bb
->next_bb
, e_flags
);
1016 e
->count
= bb
->count
;
1017 e
->probability
= REG_BR_PROB_BASE
;
1020 struct loop
*loop
= bb
->next_bb
->loop_father
;
1021 /* If we created a pre-header block, add the new block to the
1022 outer loop, otherwise to the loop itself. */
1023 if (bb
->next_bb
== loop
->header
)
1024 add_bb_to_loop (bb
, loop_outer (loop
));
1026 add_bb_to_loop (bb
, loop
);
1032 static vec
<int> sjlj_lp_call_site_index
;
1034 /* Process all active landing pads. Assign each one a compact dispatch
1035 index, and a call-site index. */
1038 sjlj_assign_call_site_values (void)
1040 action_hash_type
ar_hash (31);
1044 vec_alloc (crtl
->eh
.action_record_data
, 64);
1048 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1049 if (lp
&& lp
->post_landing_pad
)
1051 int action
, call_site
;
1053 /* First: build the action table. */
1054 action
= collect_one_action_chain (&ar_hash
, lp
->region
);
1056 /* Next: assign call-site values. If dwarf2 terms, this would be
1057 the region number assigned by convert_to_eh_region_ranges, but
1058 handles no-action and must-not-throw differently. */
1059 /* Map must-not-throw to otherwise unused call-site index 0. */
1062 /* Map no-action to otherwise unused call-site index -1. */
1063 else if (action
== -1)
1065 /* Otherwise, look it up in the table. */
1067 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1068 sjlj_lp_call_site_index
[i
] = call_site
;
1076 /* Emit code to record the current call-site index before every
1077 insn that can throw. */
1080 sjlj_mark_call_sites (void)
1082 int last_call_site
= -2;
1086 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1092 rtx_insn
*before
, *p
;
1094 /* Reset value tracking at extended basic block boundaries. */
1096 last_call_site
= -2;
1098 /* If the function allocates dynamic stack space, the context must
1099 be updated after every allocation/deallocation accordingly. */
1100 if (NOTE_P (insn
) && NOTE_KIND (insn
) == NOTE_INSN_UPDATE_SJLJ_CONTEXT
)
1105 buf_addr
= plus_constant (Pmode
, XEXP (crtl
->eh
.sjlj_fc
, 0),
1107 expand_builtin_update_setjmp_buf (buf_addr
);
1110 emit_insn_before (p
, insn
);
1113 if (! INSN_P (insn
))
1116 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1120 this_call_site
= sjlj_lp_call_site_index
[lp
->index
];
1123 /* Calls (and trapping insns) without notes are outside any
1124 exception handling region in this function. Mark them as
1126 this_call_site
= -1;
1130 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1134 if (this_call_site
!= -1)
1135 crtl
->uses_eh_lsda
= 1;
1137 if (this_call_site
== last_call_site
)
1140 /* Don't separate a call from it's argument loads. */
1143 before
= find_first_parameter_load (insn
, NULL
);
1146 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1147 sjlj_fc_call_site_ofs
);
1148 emit_move_insn (mem
, gen_int_mode (this_call_site
, GET_MODE (mem
)));
1152 emit_insn_before (p
, before
);
1153 last_call_site
= this_call_site
;
1157 /* Construct the SjLj_Function_Context. */
1160 sjlj_emit_function_enter (rtx_code_label
*dispatch_label
)
1162 rtx_insn
*fn_begin
, *seq
;
1164 bool fn_begin_outside_block
;
1165 rtx personality
= get_personality_function (current_function_decl
);
1167 fc
= crtl
->eh
.sjlj_fc
;
1171 /* We're storing this libcall's address into memory instead of
1172 calling it directly. Thus, we must call assemble_external_libcall
1173 here, as we can not depend on emit_library_call to do it for us. */
1174 assemble_external_libcall (personality
);
1175 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1176 emit_move_insn (mem
, personality
);
1178 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1179 if (crtl
->uses_eh_lsda
)
1184 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1185 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1186 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1187 emit_move_insn (mem
, sym
);
1190 emit_move_insn (mem
, const0_rtx
);
1194 #ifdef DONT_USE_BUILTIN_SETJMP
1196 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1197 TYPE_MODE (integer_type_node
), 1,
1198 plus_constant (Pmode
, XEXP (fc
, 0),
1199 sjlj_fc_jbuf_ofs
), Pmode
);
1201 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1202 TYPE_MODE (integer_type_node
), 0,
1203 dispatch_label
, REG_BR_PROB_BASE
/ 100);
1205 expand_builtin_setjmp_setup (plus_constant (Pmode
, XEXP (fc
, 0),
1211 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1212 1, XEXP (fc
, 0), Pmode
);
1217 /* ??? Instead of doing this at the beginning of the function,
1218 do this in a block that is at loop level 0 and dominates all
1219 can_throw_internal instructions. */
1221 fn_begin_outside_block
= true;
1222 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1223 if (NOTE_P (fn_begin
))
1225 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1227 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1228 fn_begin_outside_block
= false;
1231 if (fn_begin_outside_block
)
1232 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1234 emit_insn_after (seq
, fn_begin
);
1237 /* Call back from expand_function_end to know where we should put
1238 the call to unwind_sjlj_unregister_libfunc if needed. */
1241 sjlj_emit_function_exit_after (rtx_insn
*after
)
1243 crtl
->eh
.sjlj_exit_after
= after
;
1247 sjlj_emit_function_exit (void)
1249 rtx_insn
*seq
, *insn
;
1253 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1254 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1259 /* ??? Really this can be done in any block at loop level 0 that
1260 post-dominates all can_throw_internal instructions. This is
1261 the last possible moment. */
1263 insn
= crtl
->eh
.sjlj_exit_after
;
1265 insn
= NEXT_INSN (insn
);
1267 emit_insn_after (seq
, insn
);
1271 sjlj_emit_dispatch_table (rtx_code_label
*dispatch_label
, int num_dispatch
)
1273 machine_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1274 machine_mode filter_mode
= targetm
.eh_return_filter_mode ();
1276 rtx mem
, fc
, exc_ptr_reg
, filter_reg
;
1282 vec
<tree
> dispatch_labels
= vNULL
;
1284 fc
= crtl
->eh
.sjlj_fc
;
1288 emit_label (dispatch_label
);
1290 #ifndef DONT_USE_BUILTIN_SETJMP
1291 expand_builtin_setjmp_receiver (dispatch_label
);
1293 /* The caller of expand_builtin_setjmp_receiver is responsible for
1294 making sure that the label doesn't vanish. The only other caller
1295 is the expander for __builtin_setjmp_receiver, which places this
1296 label on the nonlocal_goto_label list. Since we're modeling these
1297 CFG edges more exactly, we can use the forced_labels list instead. */
1298 LABEL_PRESERVE_P (dispatch_label
) = 1;
1300 = gen_rtx_INSN_LIST (VOIDmode
, dispatch_label
, forced_labels
);
1303 /* Load up exc_ptr and filter values from the function context. */
1304 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1305 if (unwind_word_mode
!= ptr_mode
)
1307 #ifdef POINTERS_EXTEND_UNSIGNED
1308 mem
= convert_memory_address (ptr_mode
, mem
);
1310 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1313 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1315 mem
= adjust_address (fc
, unwind_word_mode
,
1316 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1317 if (unwind_word_mode
!= filter_mode
)
1318 mem
= convert_to_mode (filter_mode
, mem
, 0);
1319 filter_reg
= force_reg (filter_mode
, mem
);
1321 /* Jump to one of the directly reachable regions. */
1324 rtx_code_label
*first_reachable_label
= NULL
;
1326 /* If there's exactly one call site in the function, don't bother
1327 generating a switch statement. */
1328 if (num_dispatch
> 1)
1329 dispatch_labels
.create (num_dispatch
);
1331 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1332 if (lp
&& lp
->post_landing_pad
)
1335 rtx_code_label
*label
;
1339 lp
->landing_pad
= dispatch_label
;
1341 if (num_dispatch
> 1)
1343 tree t_label
, case_elt
, t
;
1345 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1346 t
= build_int_cst (integer_type_node
, disp_index
);
1347 case_elt
= build_case_label (t
, NULL
, t_label
);
1348 dispatch_labels
.quick_push (case_elt
);
1349 label
= jump_target_rtx (t_label
);
1352 label
= gen_label_rtx ();
1354 if (disp_index
== 0)
1355 first_reachable_label
= label
;
1360 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1362 emit_move_insn (r
->filter_reg
, filter_reg
);
1364 seq2
= get_insns ();
1367 rtx_insn
*before
= label_rtx (lp
->post_landing_pad
);
1368 bb
= emit_to_new_bb_before (seq2
, before
);
1369 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1370 e
->count
= bb
->count
;
1371 e
->probability
= REG_BR_PROB_BASE
;
1374 struct loop
*loop
= bb
->next_bb
->loop_father
;
1375 /* If we created a pre-header block, add the new block to the
1376 outer loop, otherwise to the loop itself. */
1377 if (bb
->next_bb
== loop
->header
)
1378 add_bb_to_loop (bb
, loop_outer (loop
));
1380 add_bb_to_loop (bb
, loop
);
1381 /* ??? For multiple dispatches we will end up with edges
1382 from the loop tree root into this loop, making it a
1383 multiple-entry loop. Discard all affected loops. */
1384 if (num_dispatch
> 1)
1386 for (loop
= bb
->loop_father
;
1387 loop_outer (loop
); loop
= loop_outer (loop
))
1388 mark_loop_for_removal (loop
);
1394 gcc_assert (disp_index
== num_dispatch
);
1396 if (num_dispatch
> 1)
1398 rtx disp
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1399 sjlj_fc_call_site_ofs
);
1400 expand_sjlj_dispatch_table (disp
, dispatch_labels
);
1406 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1407 if (num_dispatch
== 1)
1409 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1410 e
->count
= bb
->count
;
1411 e
->probability
= REG_BR_PROB_BASE
;
1414 struct loop
*loop
= bb
->next_bb
->loop_father
;
1415 /* If we created a pre-header block, add the new block to the
1416 outer loop, otherwise to the loop itself. */
1417 if (bb
->next_bb
== loop
->header
)
1418 add_bb_to_loop (bb
, loop_outer (loop
));
1420 add_bb_to_loop (bb
, loop
);
1425 /* We are not wiring up edges here, but as the dispatcher call
1426 is at function begin simply associate the block with the
1427 outermost (non-)loop. */
1429 add_bb_to_loop (bb
, current_loops
->tree_root
);
1434 sjlj_build_landing_pads (void)
1438 num_dispatch
= vec_safe_length (cfun
->eh
->lp_array
);
1439 if (num_dispatch
== 0)
1441 sjlj_lp_call_site_index
.safe_grow_cleared (num_dispatch
);
1443 num_dispatch
= sjlj_assign_call_site_values ();
1444 if (num_dispatch
> 0)
1446 rtx_code_label
*dispatch_label
= gen_label_rtx ();
1447 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1448 TYPE_MODE (sjlj_fc_type_node
),
1449 TYPE_ALIGN (sjlj_fc_type_node
));
1451 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1452 int_size_in_bytes (sjlj_fc_type_node
),
1455 sjlj_mark_call_sites ();
1456 sjlj_emit_function_enter (dispatch_label
);
1457 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1458 sjlj_emit_function_exit ();
1461 /* If we do not have any landing pads, we may still need to register a
1462 personality routine and (empty) LSDA to handle must-not-throw regions. */
1463 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
1465 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1466 TYPE_MODE (sjlj_fc_type_node
),
1467 TYPE_ALIGN (sjlj_fc_type_node
));
1469 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1470 int_size_in_bytes (sjlj_fc_type_node
),
1473 sjlj_mark_call_sites ();
1474 sjlj_emit_function_enter (NULL
);
1475 sjlj_emit_function_exit ();
1478 sjlj_lp_call_site_index
.release ();
1481 /* Update the sjlj function context. This function should be called
1482 whenever we allocate or deallocate dynamic stack space. */
1485 update_sjlj_context (void)
1487 if (!flag_exceptions
)
1490 emit_note (NOTE_INSN_UPDATE_SJLJ_CONTEXT
);
1493 /* After initial rtl generation, call back to finish generating
1494 exception support code. */
1497 finish_eh_generation (void)
1501 /* Construct the landing pads. */
1502 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1503 sjlj_build_landing_pads ();
1505 dw2_build_landing_pads ();
1506 break_superblocks ();
1508 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1509 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1510 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->insns
.r
)
1511 commit_edge_insertions ();
1513 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1514 FOR_EACH_BB_FN (bb
, cfun
)
1520 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1522 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1523 if (e
->flags
& EDGE_EH
)
1526 /* We should not have generated any new throwing insns during this
1527 pass, and we should not have lost any EH edges, so we only need
1528 to handle two cases here:
1529 (1) reachable handler and an existing edge to post-landing-pad,
1530 (2) no reachable handler and no edge. */
1531 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1534 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1536 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1537 e
->flags
|= (CALL_P (BB_END (bb
))
1538 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1544 /* This section handles removing dead code for flow. */
1547 remove_eh_landing_pad (eh_landing_pad lp
)
1551 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1555 if (lp
->post_landing_pad
)
1556 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1557 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1560 /* Splice the EH region at PP from the region tree. */
1563 remove_eh_handler_splicer (eh_region
*pp
)
1565 eh_region region
= *pp
;
1568 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1570 if (lp
->post_landing_pad
)
1571 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1572 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1578 outer
= region
->outer
;
1580 *pp
= p
= region
->inner
;
1589 *pp
= region
->next_peer
;
1591 (*cfun
->eh
->region_array
)[region
->index
] = NULL
;
1594 /* Splice a single EH region REGION from the region tree.
1596 To unlink REGION, we need to find the pointer to it with a relatively
1597 expensive search in REGION's outer region. If you are going to
1598 remove a number of handlers, using remove_unreachable_eh_regions may
1599 be a better option. */
1602 remove_eh_handler (eh_region region
)
1604 eh_region
*pp
, *pp_start
, p
, outer
;
1606 outer
= region
->outer
;
1608 pp_start
= &outer
->inner
;
1610 pp_start
= &cfun
->eh
->region_tree
;
1611 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1614 remove_eh_handler_splicer (pp
);
1617 /* Worker for remove_unreachable_eh_regions.
1618 PP is a pointer to the region to start a region tree depth-first
1619 search from. R_REACHABLE is the set of regions that have to be
1623 remove_unreachable_eh_regions_worker (eh_region
*pp
, sbitmap r_reachable
)
1627 eh_region region
= *pp
;
1628 remove_unreachable_eh_regions_worker (®ion
->inner
, r_reachable
);
1629 if (!bitmap_bit_p (r_reachable
, region
->index
))
1630 remove_eh_handler_splicer (pp
);
1632 pp
= ®ion
->next_peer
;
1636 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1637 Do this by traversing the EH tree top-down and splice out regions that
1638 are not marked. By removing regions from the leaves, we avoid costly
1639 searches in the region tree. */
1642 remove_unreachable_eh_regions (sbitmap r_reachable
)
1644 remove_unreachable_eh_regions_worker (&cfun
->eh
->region_tree
, r_reachable
);
1647 /* Invokes CALLBACK for every exception handler landing pad label.
1648 Only used by reload hackery; should not be used by new code. */
1651 for_each_eh_label (void (*callback
) (rtx
))
1656 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1660 rtx_code_label
*lab
= lp
->landing_pad
;
1661 if (lab
&& LABEL_P (lab
))
1667 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1670 At the gimple level, we use LP_NR
1671 > 0 : The statement transfers to landing pad LP_NR
1672 = 0 : The statement is outside any EH region
1673 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1675 At the rtl level, we use LP_NR
1676 > 0 : The insn transfers to landing pad LP_NR
1677 = 0 : The insn cannot throw
1678 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1679 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1680 missing note: The insn is outside any EH region.
1682 ??? This difference probably ought to be avoided. We could stand
1683 to record nothrow for arbitrary gimple statements, and so avoid
1684 some moderately complex lookups in stmt_could_throw_p. Perhaps
1685 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1686 no-nonlocal-goto property should be recorded elsewhere as a bit
1687 on the call_insn directly. Perhaps we should make more use of
1688 attaching the trees to call_insns (reachable via symbol_ref in
1689 direct call cases) and just pull the data out of the trees. */
1692 make_reg_eh_region_note (rtx_insn
*insn
, int ecf_flags
, int lp_nr
)
1695 if (ecf_flags
& ECF_NOTHROW
)
1697 else if (lp_nr
!= 0)
1698 value
= GEN_INT (lp_nr
);
1701 add_reg_note (insn
, REG_EH_REGION
, value
);
1704 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1705 nor perform a non-local goto. Replace the region note if it
1709 make_reg_eh_region_note_nothrow_nononlocal (rtx_insn
*insn
)
1711 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1712 rtx intmin
= GEN_INT (INT_MIN
);
1715 XEXP (note
, 0) = intmin
;
1717 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1720 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1724 insn_could_throw_p (const_rtx insn
)
1726 if (!flag_exceptions
)
1730 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1731 return may_trap_p (PATTERN (insn
));
1735 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1736 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1737 to look for a note, or the note itself. */
1740 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx_insn
*first
, rtx last
)
1743 rtx note
= note_or_insn
;
1745 if (INSN_P (note_or_insn
))
1747 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1751 note
= XEXP (note
, 0);
1753 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1754 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1755 && insn_could_throw_p (insn
))
1756 add_reg_note (insn
, REG_EH_REGION
, note
);
1759 /* Likewise, but iterate backward. */
1762 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx_insn
*last
, rtx first
)
1765 rtx note
= note_or_insn
;
1767 if (INSN_P (note_or_insn
))
1769 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1773 note
= XEXP (note
, 0);
1775 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1776 if (insn_could_throw_p (insn
))
1777 add_reg_note (insn
, REG_EH_REGION
, note
);
1781 /* Extract all EH information from INSN. Return true if the insn
1782 was marked NOTHROW. */
1785 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1786 eh_landing_pad
*plp
)
1788 eh_landing_pad lp
= NULL
;
1794 if (! INSN_P (insn
))
1797 if (NONJUMP_INSN_P (insn
)
1798 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1799 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1801 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1804 ret
= !insn_could_throw_p (insn
);
1808 lp_nr
= INTVAL (XEXP (note
, 0));
1809 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1816 r
= (*cfun
->eh
->region_array
)[-lp_nr
];
1819 lp
= (*cfun
->eh
->lp_array
)[lp_nr
];
1829 /* Return the landing pad to which INSN may go, or NULL if it does not
1830 have a reachable landing pad within this function. */
1833 get_eh_landing_pad_from_rtx (const_rtx insn
)
1838 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1842 /* Return the region to which INSN may go, or NULL if it does not
1843 have a reachable region within this function. */
1846 get_eh_region_from_rtx (const_rtx insn
)
1851 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1855 /* Return true if INSN throws and is caught by something in this function. */
1858 can_throw_internal (const_rtx insn
)
1860 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1863 /* Return true if INSN throws and escapes from the current function. */
1866 can_throw_external (const_rtx insn
)
1872 if (! INSN_P (insn
))
1875 if (NONJUMP_INSN_P (insn
)
1876 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1878 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1879 int i
, n
= seq
->len ();
1881 for (i
= 0; i
< n
; i
++)
1882 if (can_throw_external (seq
->element (i
)))
1888 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1890 /* If we can't throw, we obviously can't throw external. */
1894 /* If we have an internal landing pad, then we're not external. */
1898 /* If we're not within an EH region, then we are external. */
1902 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1903 which don't always have landing pads. */
1904 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1908 /* Return true if INSN cannot throw at all. */
1911 insn_nothrow_p (const_rtx insn
)
1916 if (! INSN_P (insn
))
1919 if (NONJUMP_INSN_P (insn
)
1920 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1922 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1923 int i
, n
= seq
->len ();
1925 for (i
= 0; i
< n
; i
++)
1926 if (!insn_nothrow_p (seq
->element (i
)))
1932 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1935 /* Return true if INSN can perform a non-local goto. */
1936 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1939 can_nonlocal_goto (const rtx_insn
*insn
)
1941 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1943 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1944 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1950 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1953 set_nothrow_function_flags (void)
1959 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1960 something that can throw an exception. We specifically exempt
1961 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1962 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1965 crtl
->all_throwers_are_sibcalls
= 1;
1967 /* If we don't know that this implementation of the function will
1968 actually be used, then we must not set TREE_NOTHROW, since
1969 callers must not assume that this function does not throw. */
1970 if (TREE_NOTHROW (current_function_decl
))
1973 if (! flag_exceptions
)
1976 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1977 if (can_throw_external (insn
))
1981 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1983 crtl
->all_throwers_are_sibcalls
= 0;
1989 && (cgraph_node::get (current_function_decl
)->get_availability ()
1990 >= AVAIL_AVAILABLE
))
1992 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1993 struct cgraph_edge
*e
;
1994 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1995 e
->can_throw_external
= false;
1996 node
->set_nothrow_flag (true);
1999 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
2000 current_function_name ());
2007 const pass_data pass_data_set_nothrow_function_flags
=
2009 RTL_PASS
, /* type */
2010 "nothrow", /* name */
2011 OPTGROUP_NONE
, /* optinfo_flags */
2012 TV_NONE
, /* tv_id */
2013 0, /* properties_required */
2014 0, /* properties_provided */
2015 0, /* properties_destroyed */
2016 0, /* todo_flags_start */
2017 0, /* todo_flags_finish */
2020 class pass_set_nothrow_function_flags
: public rtl_opt_pass
2023 pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2024 : rtl_opt_pass (pass_data_set_nothrow_function_flags
, ctxt
)
2027 /* opt_pass methods: */
2028 virtual unsigned int execute (function
*)
2030 return set_nothrow_function_flags ();
2033 }; // class pass_set_nothrow_function_flags
2038 make_pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2040 return new pass_set_nothrow_function_flags (ctxt
);
2044 /* Various hooks for unwind library. */
2046 /* Expand the EH support builtin functions:
2047 __builtin_eh_pointer and __builtin_eh_filter. */
2050 expand_builtin_eh_common (tree region_nr_t
)
2052 HOST_WIDE_INT region_nr
;
2055 gcc_assert (tree_fits_shwi_p (region_nr_t
));
2056 region_nr
= tree_to_shwi (region_nr_t
);
2058 region
= (*cfun
->eh
->region_array
)[region_nr
];
2060 /* ??? We shouldn't have been able to delete a eh region without
2061 deleting all the code that depended on it. */
2062 gcc_assert (region
!= NULL
);
2067 /* Expand to the exc_ptr value from the given eh region. */
2070 expand_builtin_eh_pointer (tree exp
)
2073 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2074 if (region
->exc_ptr_reg
== NULL
)
2075 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2076 return region
->exc_ptr_reg
;
2079 /* Expand to the filter value from the given eh region. */
2082 expand_builtin_eh_filter (tree exp
)
2085 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2086 if (region
->filter_reg
== NULL
)
2087 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
2088 return region
->filter_reg
;
2091 /* Copy the exc_ptr and filter values from one landing pad's registers
2092 to another. This is used to inline the resx statement. */
2095 expand_builtin_eh_copy_values (tree exp
)
2098 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2100 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
2101 machine_mode fmode
= targetm
.eh_return_filter_mode ();
2103 if (dst
->exc_ptr_reg
== NULL
)
2104 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2105 if (src
->exc_ptr_reg
== NULL
)
2106 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2108 if (dst
->filter_reg
== NULL
)
2109 dst
->filter_reg
= gen_reg_rtx (fmode
);
2110 if (src
->filter_reg
== NULL
)
2111 src
->filter_reg
= gen_reg_rtx (fmode
);
2113 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2114 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2119 /* Do any necessary initialization to access arbitrary stack frames.
2120 On the SPARC, this means flushing the register windows. */
2123 expand_builtin_unwind_init (void)
2125 /* Set this so all the registers get saved in our frame; we need to be
2126 able to copy the saved values for any registers from frames we unwind. */
2127 crtl
->saves_all_registers
= 1;
2129 #ifdef SETUP_FRAME_ADDRESSES
2130 SETUP_FRAME_ADDRESSES ();
2134 /* Map a non-negative number to an eh return data register number; expands
2135 to -1 if no return data register is associated with the input number.
2136 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2139 expand_builtin_eh_return_data_regno (tree exp
)
2141 tree which
= CALL_EXPR_ARG (exp
, 0);
2142 unsigned HOST_WIDE_INT iwhich
;
2144 if (TREE_CODE (which
) != INTEGER_CST
)
2146 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2150 iwhich
= tree_to_uhwi (which
);
2151 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2152 if (iwhich
== INVALID_REGNUM
)
2155 #ifdef DWARF_FRAME_REGNUM
2156 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2158 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2161 return GEN_INT (iwhich
);
2164 /* Given a value extracted from the return address register or stack slot,
2165 return the actual address encoded in that value. */
2168 expand_builtin_extract_return_addr (tree addr_tree
)
2170 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2172 if (GET_MODE (addr
) != Pmode
2173 && GET_MODE (addr
) != VOIDmode
)
2175 #ifdef POINTERS_EXTEND_UNSIGNED
2176 addr
= convert_memory_address (Pmode
, addr
);
2178 addr
= convert_to_mode (Pmode
, addr
, 0);
2182 /* First mask out any unwanted bits. */
2183 rtx mask
= MASK_RETURN_ADDR
;
2185 expand_and (Pmode
, addr
, mask
, addr
);
2187 /* Then adjust to find the real return address. */
2188 if (RETURN_ADDR_OFFSET
)
2189 addr
= plus_constant (Pmode
, addr
, RETURN_ADDR_OFFSET
);
2194 /* Given an actual address in addr_tree, do any necessary encoding
2195 and return the value to be stored in the return address register or
2196 stack slot so the epilogue will return to that address. */
2199 expand_builtin_frob_return_addr (tree addr_tree
)
2201 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2203 addr
= convert_memory_address (Pmode
, addr
);
2205 if (RETURN_ADDR_OFFSET
)
2207 addr
= force_reg (Pmode
, addr
);
2208 addr
= plus_constant (Pmode
, addr
, -RETURN_ADDR_OFFSET
);
2214 /* Set up the epilogue with the magic bits we'll need to return to the
2215 exception handler. */
2218 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2223 #ifdef EH_RETURN_STACKADJ_RTX
2224 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2225 VOIDmode
, EXPAND_NORMAL
);
2226 tmp
= convert_memory_address (Pmode
, tmp
);
2227 if (!crtl
->eh
.ehr_stackadj
)
2228 crtl
->eh
.ehr_stackadj
= copy_to_reg (tmp
);
2229 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2230 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2233 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2234 VOIDmode
, EXPAND_NORMAL
);
2235 tmp
= convert_memory_address (Pmode
, tmp
);
2236 if (!crtl
->eh
.ehr_handler
)
2237 crtl
->eh
.ehr_handler
= copy_to_reg (tmp
);
2238 else if (tmp
!= crtl
->eh
.ehr_handler
)
2239 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2241 if (!crtl
->eh
.ehr_label
)
2242 crtl
->eh
.ehr_label
= gen_label_rtx ();
2243 emit_jump (crtl
->eh
.ehr_label
);
2246 /* Expand __builtin_eh_return. This exit path from the function loads up
2247 the eh return data registers, adjusts the stack, and branches to a
2248 given PC other than the normal return address. */
2251 expand_eh_return (void)
2253 rtx_code_label
*around_label
;
2255 if (! crtl
->eh
.ehr_label
)
2258 crtl
->calls_eh_return
= 1;
2260 #ifdef EH_RETURN_STACKADJ_RTX
2261 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2264 around_label
= gen_label_rtx ();
2265 emit_jump (around_label
);
2267 emit_label (crtl
->eh
.ehr_label
);
2268 clobber_return_register ();
2270 #ifdef EH_RETURN_STACKADJ_RTX
2271 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2274 #ifdef HAVE_eh_return
2276 emit_insn (gen_eh_return (crtl
->eh
.ehr_handler
));
2280 #ifdef EH_RETURN_HANDLER_RTX
2281 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2283 error ("__builtin_eh_return not supported on this target");
2287 emit_label (around_label
);
2290 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2291 POINTERS_EXTEND_UNSIGNED and return it. */
2294 expand_builtin_extend_pointer (tree addr_tree
)
2296 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2299 #ifdef POINTERS_EXTEND_UNSIGNED
2300 extend
= POINTERS_EXTEND_UNSIGNED
;
2302 /* The previous EH code did an unsigned extend by default, so we do this also
2307 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2311 add_action_record (action_hash_type
*ar_hash
, int filter
, int next
)
2313 struct action_record
**slot
, *new_ar
, tmp
;
2315 tmp
.filter
= filter
;
2317 slot
= ar_hash
->find_slot (&tmp
, INSERT
);
2319 if ((new_ar
= *slot
) == NULL
)
2321 new_ar
= XNEW (struct action_record
);
2322 new_ar
->offset
= crtl
->eh
.action_record_data
->length () + 1;
2323 new_ar
->filter
= filter
;
2324 new_ar
->next
= next
;
2327 /* The filter value goes in untouched. The link to the next
2328 record is a "self-relative" byte offset, or zero to indicate
2329 that there is no next record. So convert the absolute 1 based
2330 indices we've been carrying around into a displacement. */
2332 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2334 next
-= crtl
->eh
.action_record_data
->length () + 1;
2335 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2338 return new_ar
->offset
;
2342 collect_one_action_chain (action_hash_type
*ar_hash
, eh_region region
)
2346 /* If we've reached the top of the region chain, then we have
2347 no actions, and require no landing pad. */
2351 switch (region
->type
)
2356 /* A cleanup adds a zero filter to the beginning of the chain, but
2357 there are special cases to look out for. If there are *only*
2358 cleanups along a path, then it compresses to a zero action.
2359 Further, if there are multiple cleanups along a path, we only
2360 need to represent one of them, as that is enough to trigger
2361 entry to the landing pad at runtime. */
2362 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2365 for (r
= region
->outer
; r
; r
= r
->outer
)
2366 if (r
->type
== ERT_CLEANUP
)
2368 return add_action_record (ar_hash
, 0, next
);
2375 /* Process the associated catch regions in reverse order.
2376 If there's a catch-all handler, then we don't need to
2377 search outer regions. Use a magic -3 value to record
2378 that we haven't done the outer search. */
2380 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2382 if (c
->type_list
== NULL
)
2384 /* Retrieve the filter from the head of the filter list
2385 where we have stored it (see assign_filter_values). */
2386 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2387 next
= add_action_record (ar_hash
, filter
, 0);
2391 /* Once the outer search is done, trigger an action record for
2392 each filter we have. */
2397 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2399 /* If there is no next action, terminate the chain. */
2402 /* If all outer actions are cleanups or must_not_throw,
2403 we'll have no action record for it, since we had wanted
2404 to encode these states in the call-site record directly.
2405 Add a cleanup action to the chain to catch these. */
2407 next
= add_action_record (ar_hash
, 0, 0);
2410 flt_node
= c
->filter_list
;
2411 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2413 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2414 next
= add_action_record (ar_hash
, filter
, next
);
2421 case ERT_ALLOWED_EXCEPTIONS
:
2422 /* An exception specification adds its filter to the
2423 beginning of the chain. */
2424 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2426 /* If there is no next action, terminate the chain. */
2429 /* If all outer actions are cleanups or must_not_throw,
2430 we'll have no action record for it, since we had wanted
2431 to encode these states in the call-site record directly.
2432 Add a cleanup action to the chain to catch these. */
2434 next
= add_action_record (ar_hash
, 0, 0);
2436 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2438 case ERT_MUST_NOT_THROW
:
2439 /* A must-not-throw region with no inner handlers or cleanups
2440 requires no call-site entry. Note that this differs from
2441 the no handler or cleanup case in that we do require an lsda
2442 to be generated. Return a magic -2 value to record this. */
2450 add_call_site (rtx landing_pad
, int action
, int section
)
2452 call_site_record record
;
2454 record
= ggc_alloc
<call_site_record_d
> ();
2455 record
->landing_pad
= landing_pad
;
2456 record
->action
= action
;
2458 vec_safe_push (crtl
->eh
.call_site_record_v
[section
], record
);
2460 return call_site_base
+ crtl
->eh
.call_site_record_v
[section
]->length () - 1;
2464 emit_note_eh_region_end (rtx_insn
*insn
)
2466 rtx_insn
*next
= NEXT_INSN (insn
);
2468 /* Make sure we do not split a call and its corresponding
2469 CALL_ARG_LOCATION note. */
2470 if (next
&& NOTE_P (next
)
2471 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
2474 return emit_note_after (NOTE_INSN_EH_REGION_END
, insn
);
2477 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2478 The new note numbers will not refer to region numbers, but
2479 instead to call site entries. */
2482 convert_to_eh_region_ranges (void)
2487 action_hash_type
ar_hash (31);
2488 int last_action
= -3;
2489 rtx_insn
*last_action_insn
= NULL
;
2490 rtx last_landing_pad
= NULL_RTX
;
2491 rtx_insn
*first_no_action_insn
= NULL
;
2494 rtx_insn
*section_switch_note
= NULL
;
2495 rtx_insn
*first_no_action_insn_before_switch
= NULL
;
2496 rtx_insn
*last_no_action_insn_before_switch
= NULL
;
2497 int saved_call_site_base
= call_site_base
;
2499 vec_alloc (crtl
->eh
.action_record_data
, 64);
2501 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2508 rtx_code_label
*this_landing_pad
;
2511 if (NONJUMP_INSN_P (insn
)
2512 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2513 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2515 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2519 this_action
= collect_one_action_chain (&ar_hash
, region
);
2523 /* Existence of catch handlers, or must-not-throw regions
2524 implies that an lsda is needed (even if empty). */
2525 if (this_action
!= -1)
2526 crtl
->uses_eh_lsda
= 1;
2528 /* Delay creation of region notes for no-action regions
2529 until we're sure that an lsda will be required. */
2530 else if (last_action
== -3)
2532 first_no_action_insn
= iter
;
2536 if (this_action
>= 0)
2537 this_landing_pad
= lp
->landing_pad
;
2539 this_landing_pad
= NULL
;
2541 /* Differing actions or landing pads implies a change in call-site
2542 info, which implies some EH_REGION note should be emitted. */
2543 if (last_action
!= this_action
2544 || last_landing_pad
!= this_landing_pad
)
2546 /* If there is a queued no-action region in the other section
2547 with hot/cold partitioning, emit it now. */
2548 if (first_no_action_insn_before_switch
)
2550 gcc_assert (this_action
!= -1
2551 && last_action
== (first_no_action_insn
2553 call_site
= add_call_site (NULL_RTX
, 0, 0);
2554 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2555 first_no_action_insn_before_switch
);
2556 NOTE_EH_HANDLER (note
) = call_site
;
2558 = emit_note_eh_region_end (last_no_action_insn_before_switch
);
2559 NOTE_EH_HANDLER (note
) = call_site
;
2560 gcc_assert (last_action
!= -3
2561 || (last_action_insn
2562 == last_no_action_insn_before_switch
));
2563 first_no_action_insn_before_switch
= NULL
;
2564 last_no_action_insn_before_switch
= NULL
;
2567 /* If we'd not seen a previous action (-3) or the previous
2568 action was must-not-throw (-2), then we do not need an
2570 if (last_action
>= -1)
2572 /* If we delayed the creation of the begin, do it now. */
2573 if (first_no_action_insn
)
2575 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2576 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2577 first_no_action_insn
);
2578 NOTE_EH_HANDLER (note
) = call_site
;
2579 first_no_action_insn
= NULL
;
2582 note
= emit_note_eh_region_end (last_action_insn
);
2583 NOTE_EH_HANDLER (note
) = call_site
;
2586 /* If the new action is must-not-throw, then no region notes
2588 if (this_action
>= -1)
2590 call_site
= add_call_site (this_landing_pad
,
2591 this_action
< 0 ? 0 : this_action
,
2593 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2594 NOTE_EH_HANDLER (note
) = call_site
;
2597 last_action
= this_action
;
2598 last_landing_pad
= this_landing_pad
;
2600 last_action_insn
= iter
;
2602 else if (NOTE_P (iter
)
2603 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2605 gcc_assert (section_switch_note
== NULL_RTX
);
2606 gcc_assert (flag_reorder_blocks_and_partition
);
2607 section_switch_note
= iter
;
2608 if (first_no_action_insn
)
2610 first_no_action_insn_before_switch
= first_no_action_insn
;
2611 last_no_action_insn_before_switch
= last_action_insn
;
2612 first_no_action_insn
= NULL
;
2613 gcc_assert (last_action
== -1);
2616 /* Force closing of current EH region before section switch and
2617 opening a new one afterwards. */
2618 else if (last_action
!= -3)
2619 last_landing_pad
= pc_rtx
;
2620 if (crtl
->eh
.call_site_record_v
[cur_sec
])
2621 call_site_base
+= crtl
->eh
.call_site_record_v
[cur_sec
]->length ();
2623 gcc_assert (crtl
->eh
.call_site_record_v
[cur_sec
] == NULL
);
2624 vec_alloc (crtl
->eh
.call_site_record_v
[cur_sec
], 10);
2627 if (last_action
>= -1 && ! first_no_action_insn
)
2629 note
= emit_note_eh_region_end (last_action_insn
);
2630 NOTE_EH_HANDLER (note
) = call_site
;
2633 call_site_base
= saved_call_site_base
;
2640 const pass_data pass_data_convert_to_eh_region_ranges
=
2642 RTL_PASS
, /* type */
2643 "eh_ranges", /* name */
2644 OPTGROUP_NONE
, /* optinfo_flags */
2645 TV_NONE
, /* tv_id */
2646 0, /* properties_required */
2647 0, /* properties_provided */
2648 0, /* properties_destroyed */
2649 0, /* todo_flags_start */
2650 0, /* todo_flags_finish */
2653 class pass_convert_to_eh_region_ranges
: public rtl_opt_pass
2656 pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2657 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges
, ctxt
)
2660 /* opt_pass methods: */
2661 virtual bool gate (function
*);
2662 virtual unsigned int execute (function
*)
2664 return convert_to_eh_region_ranges ();
2667 }; // class pass_convert_to_eh_region_ranges
2670 pass_convert_to_eh_region_ranges::gate (function
*)
2672 /* Nothing to do for SJLJ exceptions or if no regions created. */
2673 if (cfun
->eh
->region_tree
== NULL
)
2675 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2683 make_pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2685 return new pass_convert_to_eh_region_ranges (ctxt
);
2689 push_uleb128 (vec
<uchar
, va_gc
> **data_area
, unsigned int value
)
2693 unsigned char byte
= value
& 0x7f;
2697 vec_safe_push (*data_area
, byte
);
2703 push_sleb128 (vec
<uchar
, va_gc
> **data_area
, int value
)
2710 byte
= value
& 0x7f;
2712 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2713 || (value
== -1 && (byte
& 0x40) != 0));
2716 vec_safe_push (*data_area
, byte
);
2722 #ifndef HAVE_AS_LEB128
2724 dw2_size_of_call_site_table (int section
)
2726 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2727 int size
= n
* (4 + 4 + 4);
2730 for (i
= 0; i
< n
; ++i
)
2732 struct call_site_record_d
*cs
=
2733 (*crtl
->eh
.call_site_record_v
[section
])[i
];
2734 size
+= size_of_uleb128 (cs
->action
);
2741 sjlj_size_of_call_site_table (void)
2743 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2747 for (i
= 0; i
< n
; ++i
)
2749 struct call_site_record_d
*cs
=
2750 (*crtl
->eh
.call_site_record_v
[0])[i
];
2751 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2752 size
+= size_of_uleb128 (cs
->action
);
2760 dw2_output_call_site_table (int cs_format
, int section
)
2762 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2767 begin
= current_function_func_begin_label
;
2768 else if (first_function_block_is_cold
)
2769 begin
= crtl
->subsections
.hot_section_label
;
2771 begin
= crtl
->subsections
.cold_section_label
;
2773 for (i
= 0; i
< n
; ++i
)
2775 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[section
])[i
];
2776 char reg_start_lab
[32];
2777 char reg_end_lab
[32];
2778 char landing_pad_lab
[32];
2780 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2781 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2783 if (cs
->landing_pad
)
2784 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2785 CODE_LABEL_NUMBER (cs
->landing_pad
));
2787 /* ??? Perhaps use insn length scaling if the assembler supports
2788 generic arithmetic. */
2789 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2790 data4 if the function is small enough. */
2791 if (cs_format
== DW_EH_PE_uleb128
)
2793 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2794 "region %d start", i
);
2795 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2797 if (cs
->landing_pad
)
2798 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2801 dw2_asm_output_data_uleb128 (0, "landing pad");
2805 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2806 "region %d start", i
);
2807 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2808 if (cs
->landing_pad
)
2809 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2812 dw2_asm_output_data (4, 0, "landing pad");
2814 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2817 call_site_base
+= n
;
2821 sjlj_output_call_site_table (void)
2823 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2826 for (i
= 0; i
< n
; ++i
)
2828 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[0])[i
];
2830 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2831 "region %d landing pad", i
);
2832 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2835 call_site_base
+= n
;
2838 /* Switch to the section that should be used for exception tables. */
2841 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2845 if (exception_section
)
2846 s
= exception_section
;
2849 /* Compute the section and cache it into exception_section,
2850 unless it depends on the function name. */
2851 if (targetm_common
.have_named_sections
)
2855 if (EH_TABLES_CAN_BE_READ_ONLY
)
2858 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2859 flags
= ((! flag_pic
2860 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2861 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2862 ? 0 : SECTION_WRITE
);
2865 flags
= SECTION_WRITE
;
2867 #ifdef HAVE_LD_EH_GC_SECTIONS
2868 if (flag_function_sections
2869 || (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
))
2871 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2872 /* The EH table must match the code section, so only mark
2873 it linkonce if we have COMDAT groups to tie them together. */
2874 if (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
)
2875 flags
|= SECTION_LINKONCE
;
2876 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2877 s
= get_section (section_name
, flags
, current_function_decl
);
2878 free (section_name
);
2883 = s
= get_section (".gcc_except_table", flags
, NULL
);
2887 = s
= flag_pic
? data_section
: readonly_data_section
;
2890 switch_to_section (s
);
2894 /* Output a reference from an exception table to the type_info object TYPE.
2895 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2899 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2902 bool is_public
= true;
2904 if (type
== NULL_TREE
)
2908 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2909 runtime types so TYPE should already be a runtime type
2910 reference. When pass_ipa_free_lang data is made a default
2911 pass, we can then remove the call to lookup_type_for_runtime
2914 type
= lookup_type_for_runtime (type
);
2916 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2918 /* Let cgraph know that the rtti decl is used. Not all of the
2919 paths below go through assemble_integer, which would take
2920 care of this for us. */
2922 if (TREE_CODE (type
) == ADDR_EXPR
)
2924 type
= TREE_OPERAND (type
, 0);
2925 if (TREE_CODE (type
) == VAR_DECL
)
2926 is_public
= TREE_PUBLIC (type
);
2929 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2932 /* Allow the target to override the type table entry format. */
2933 if (targetm
.asm_out
.ttype (value
))
2936 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2937 assemble_integer (value
, tt_format_size
,
2938 tt_format_size
* BITS_PER_UNIT
, 1);
2940 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2944 output_one_function_exception_table (int section
)
2946 int tt_format
, cs_format
, lp_format
, i
;
2947 #ifdef HAVE_AS_LEB128
2948 char ttype_label
[32];
2949 char cs_after_size_label
[32];
2950 char cs_end_label
[32];
2955 int tt_format_size
= 0;
2957 have_tt_data
= (vec_safe_length (cfun
->eh
->ttype_data
)
2958 || (targetm
.arm_eabi_unwinder
2959 ? vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
)
2960 : vec_safe_length (cfun
->eh
->ehspec_data
.other
)));
2962 /* Indicate the format of the @TType entries. */
2964 tt_format
= DW_EH_PE_omit
;
2967 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2968 #ifdef HAVE_AS_LEB128
2969 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2970 section
? "LLSDATTC" : "LLSDATT",
2971 current_function_funcdef_no
);
2973 tt_format_size
= size_of_encoded_value (tt_format
);
2975 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2978 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2979 current_function_funcdef_no
);
2981 /* The LSDA header. */
2983 /* Indicate the format of the landing pad start pointer. An omitted
2984 field implies @LPStart == @Start. */
2985 /* Currently we always put @LPStart == @Start. This field would
2986 be most useful in moving the landing pads completely out of
2987 line to another section, but it could also be used to minimize
2988 the size of uleb128 landing pad offsets. */
2989 lp_format
= DW_EH_PE_omit
;
2990 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
2991 eh_data_format_name (lp_format
));
2993 /* @LPStart pointer would go here. */
2995 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
2996 eh_data_format_name (tt_format
));
2998 #ifndef HAVE_AS_LEB128
2999 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3000 call_site_len
= sjlj_size_of_call_site_table ();
3002 call_site_len
= dw2_size_of_call_site_table (section
);
3005 /* A pc-relative 4-byte displacement to the @TType data. */
3008 #ifdef HAVE_AS_LEB128
3009 char ttype_after_disp_label
[32];
3010 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
3011 section
? "LLSDATTDC" : "LLSDATTD",
3012 current_function_funcdef_no
);
3013 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3014 "@TType base offset");
3015 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3017 /* Ug. Alignment queers things. */
3018 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3020 before_disp
= 1 + 1;
3021 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3023 + vec_safe_length (crtl
->eh
.action_record_data
)
3024 + (vec_safe_length (cfun
->eh
->ttype_data
)
3030 unsigned int disp_size
, pad
;
3033 disp_size
= size_of_uleb128 (disp
);
3034 pad
= before_disp
+ disp_size
+ after_disp
;
3035 if (pad
% tt_format_size
)
3036 pad
= tt_format_size
- (pad
% tt_format_size
);
3039 disp
= after_disp
+ pad
;
3041 while (disp
!= last_disp
);
3043 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3047 /* Indicate the format of the call-site offsets. */
3048 #ifdef HAVE_AS_LEB128
3049 cs_format
= DW_EH_PE_uleb128
;
3051 cs_format
= DW_EH_PE_udata4
;
3053 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3054 eh_data_format_name (cs_format
));
3056 #ifdef HAVE_AS_LEB128
3057 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3058 section
? "LLSDACSBC" : "LLSDACSB",
3059 current_function_funcdef_no
);
3060 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3061 section
? "LLSDACSEC" : "LLSDACSE",
3062 current_function_funcdef_no
);
3063 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3064 "Call-site table length");
3065 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3066 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3067 sjlj_output_call_site_table ();
3069 dw2_output_call_site_table (cs_format
, section
);
3070 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3072 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3073 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3074 sjlj_output_call_site_table ();
3076 dw2_output_call_site_table (cs_format
, section
);
3079 /* ??? Decode and interpret the data for flag_debug_asm. */
3082 FOR_EACH_VEC_ELT (*crtl
->eh
.action_record_data
, i
, uc
)
3083 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3087 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3089 i
= vec_safe_length (cfun
->eh
->ttype_data
);
3092 tree type
= (*cfun
->eh
->ttype_data
)[i
];
3093 output_ttype (type
, tt_format
, tt_format_size
);
3096 #ifdef HAVE_AS_LEB128
3098 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3101 /* ??? Decode and interpret the data for flag_debug_asm. */
3102 if (targetm
.arm_eabi_unwinder
)
3106 vec_safe_iterate (cfun
->eh
->ehspec_data
.arm_eabi
, i
, &type
); ++i
)
3107 output_ttype (type
, tt_format
, tt_format_size
);
3113 vec_safe_iterate (cfun
->eh
->ehspec_data
.other
, i
, &uc
); ++i
)
3114 dw2_asm_output_data (1, uc
,
3115 i
? NULL
: "Exception specification table");
3120 output_function_exception_table (const char *fnname
)
3122 rtx personality
= get_personality_function (current_function_decl
);
3124 /* Not all functions need anything. */
3125 if (! crtl
->uses_eh_lsda
)
3130 assemble_external_libcall (personality
);
3132 if (targetm
.asm_out
.emit_except_personality
)
3133 targetm
.asm_out
.emit_except_personality (personality
);
3136 switch_to_exception_section (fnname
);
3138 /* If the target wants a label to begin the table, emit it here. */
3139 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3141 output_one_function_exception_table (0);
3142 if (crtl
->eh
.call_site_record_v
[1])
3143 output_one_function_exception_table (1);
3145 switch_to_section (current_function_section ());
3149 set_eh_throw_stmt_table (function
*fun
, hash_map
<gimple
, int> *table
)
3151 fun
->eh
->throw_stmt_table
= table
;
3154 hash_map
<gimple
, int> *
3155 get_eh_throw_stmt_table (struct function
*fun
)
3157 return fun
->eh
->throw_stmt_table
;
3160 /* Determine if the function needs an EH personality function. */
3162 enum eh_personality_kind
3163 function_needs_eh_personality (struct function
*fn
)
3165 enum eh_personality_kind kind
= eh_personality_none
;
3168 FOR_ALL_EH_REGION_FN (i
, fn
)
3173 /* Can do with any personality including the generic C one. */
3174 kind
= eh_personality_any
;
3178 case ERT_ALLOWED_EXCEPTIONS
:
3179 /* Always needs a EH personality function. The generic C
3180 personality doesn't handle these even for empty type lists. */
3181 return eh_personality_lang
;
3183 case ERT_MUST_NOT_THROW
:
3184 /* Always needs a EH personality function. The language may specify
3185 what abort routine that must be used, e.g. std::terminate. */
3186 return eh_personality_lang
;
3193 /* Dump EH information to OUT. */
3196 dump_eh_tree (FILE * out
, struct function
*fun
)
3200 static const char *const type_name
[] = {
3201 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3204 i
= fun
->eh
->region_tree
;
3208 fprintf (out
, "Eh tree:\n");
3211 fprintf (out
, " %*s %i %s", depth
* 2, "",
3212 i
->index
, type_name
[(int) i
->type
]);
3214 if (i
->landing_pads
)
3218 fprintf (out
, " land:");
3219 if (current_ir_type () == IR_GIMPLE
)
3221 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3223 fprintf (out
, "{%i,", lp
->index
);
3224 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3232 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3234 fprintf (out
, "{%i,", lp
->index
);
3235 if (lp
->landing_pad
)
3236 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3237 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3239 fprintf (out
, "(nil),");
3240 if (lp
->post_landing_pad
)
3242 rtx_insn
*lab
= label_rtx (lp
->post_landing_pad
);
3243 fprintf (out
, "%i%s}", INSN_UID (lab
),
3244 NOTE_P (lab
) ? "(del)" : "");
3247 fprintf (out
, "(nil)}");
3257 case ERT_MUST_NOT_THROW
:
3263 fprintf (out
, " catch:");
3264 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3269 fprintf (out
, "lab:");
3270 print_generic_expr (out
, c
->label
, 0);
3273 print_generic_expr (out
, c
->type_list
, 0);
3281 case ERT_ALLOWED_EXCEPTIONS
:
3282 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3283 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3288 /* If there are sub-regions, process them. */
3290 i
= i
->inner
, depth
++;
3291 /* If there are peers, process them. */
3292 else if (i
->next_peer
)
3294 /* Otherwise, step back up the tree to the next peer. */
3304 while (i
->next_peer
== NULL
);
3310 /* Dump the EH tree for FN on stderr. */
3313 debug_eh_tree (struct function
*fn
)
3315 dump_eh_tree (stderr
, fn
);
3318 /* Verify invariants on EH datastructures. */
3321 verify_eh_tree (struct function
*fun
)
3324 int nvisited_lp
, nvisited_r
;
3325 int count_lp
, count_r
, depth
, i
;
3329 if (!fun
->eh
->region_tree
)
3333 for (i
= 1; vec_safe_iterate (fun
->eh
->region_array
, i
, &r
); ++i
)
3340 error ("region_array is corrupted for region %i", r
->index
);
3346 for (i
= 1; vec_safe_iterate (fun
->eh
->lp_array
, i
, &lp
); ++i
)
3353 error ("lp_array is corrupted for lp %i", lp
->index
);
3358 depth
= nvisited_lp
= nvisited_r
= 0;
3360 r
= fun
->eh
->region_tree
;
3363 if ((*fun
->eh
->region_array
)[r
->index
] != r
)
3365 error ("region_array is corrupted for region %i", r
->index
);
3368 if (r
->outer
!= outer
)
3370 error ("outer block of region %i is wrong", r
->index
);
3375 error ("negative nesting depth of region %i", r
->index
);
3380 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3382 if ((*fun
->eh
->lp_array
)[lp
->index
] != lp
)
3384 error ("lp_array is corrupted for lp %i", lp
->index
);
3387 if (lp
->region
!= r
)
3389 error ("region of lp %i is wrong", lp
->index
);
3396 outer
= r
, r
= r
->inner
, depth
++;
3397 else if (r
->next_peer
)
3409 while (r
->next_peer
== NULL
);
3416 error ("tree list ends on depth %i", depth
);
3419 if (count_r
!= nvisited_r
)
3421 error ("region_array does not match region_tree");
3424 if (count_lp
!= nvisited_lp
)
3426 error ("lp_array does not match region_tree");
3432 dump_eh_tree (stderr
, fun
);
3433 internal_error ("verify_eh_tree failed");
3437 #include "gt-except.h"