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"
119 #include "cfghooks.h"
120 #include "tree-pass.h"
122 #include "stringpool.h"
125 #include "emit-rtl.h"
127 #include "diagnostic.h"
128 #include "fold-const.h"
129 #include "stor-layout.h"
133 #include "libfuncs.h"
136 #include "dwarf2asm.h"
137 #include "dwarf2out.h"
138 #include "common/common-target.h"
139 #include "langhooks.h"
141 #include "tree-pretty-print.h"
143 #include "builtins.h"
144 #include "tree-hash-traits.h"
146 static GTY(()) int call_site_base
;
148 static GTY (()) hash_map
<tree_hash
, tree
> *type_to_runtime_map
;
150 /* Describe the SjLj_Function_Context structure. */
151 static GTY(()) tree sjlj_fc_type_node
;
152 static int sjlj_fc_call_site_ofs
;
153 static int sjlj_fc_data_ofs
;
154 static int sjlj_fc_personality_ofs
;
155 static int sjlj_fc_lsda_ofs
;
156 static int sjlj_fc_jbuf_ofs
;
159 struct GTY(()) call_site_record_d
165 /* In the following structure and associated functions,
166 we represent entries in the action table as 1-based indices.
169 0: null action record, non-null landing pad; implies cleanups
170 -1: null action record, null landing pad; implies no action
171 -2: no call-site entry; implies must_not_throw
172 -3: we have yet to process outer regions
174 Further, no special cases apply to the "next" field of the record.
175 For next, 0 means end of list. */
184 /* Hashtable helpers. */
186 struct action_record_hasher
: free_ptr_hash
<action_record
>
188 static inline hashval_t
hash (const action_record
*);
189 static inline bool equal (const action_record
*, const action_record
*);
193 action_record_hasher::hash (const action_record
*entry
)
195 return entry
->next
* 1009 + entry
->filter
;
199 action_record_hasher::equal (const action_record
*entry
,
200 const action_record
*data
)
202 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
205 typedef hash_table
<action_record_hasher
> action_hash_type
;
207 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
210 static void dw2_build_landing_pads (void);
212 static int collect_one_action_chain (action_hash_type
*, eh_region
);
213 static int add_call_site (rtx
, int, int);
215 static void push_uleb128 (vec
<uchar
, va_gc
> **, unsigned int);
216 static void push_sleb128 (vec
<uchar
, va_gc
> **, int);
217 #ifndef HAVE_AS_LEB128
218 static int dw2_size_of_call_site_table (int);
219 static int sjlj_size_of_call_site_table (void);
221 static void dw2_output_call_site_table (int, int);
222 static void sjlj_output_call_site_table (void);
228 if (! flag_exceptions
)
231 type_to_runtime_map
= hash_map
<tree_hash
, tree
>::create_ggc (31);
233 /* Create the SjLj_Function_Context structure. This should match
234 the definition in unwind-sjlj.c. */
235 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
237 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
239 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
241 f_prev
= build_decl (BUILTINS_LOCATION
,
242 FIELD_DECL
, get_identifier ("__prev"),
243 build_pointer_type (sjlj_fc_type_node
));
244 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
246 f_cs
= build_decl (BUILTINS_LOCATION
,
247 FIELD_DECL
, get_identifier ("__call_site"),
249 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
251 tmp
= build_index_type (size_int (4 - 1));
252 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
253 (targetm
.unwind_word_mode (), 1),
255 f_data
= build_decl (BUILTINS_LOCATION
,
256 FIELD_DECL
, get_identifier ("__data"), tmp
);
257 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
259 f_per
= build_decl (BUILTINS_LOCATION
,
260 FIELD_DECL
, get_identifier ("__personality"),
262 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
264 f_lsda
= build_decl (BUILTINS_LOCATION
,
265 FIELD_DECL
, get_identifier ("__lsda"),
267 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
269 #ifdef DONT_USE_BUILTIN_SETJMP
271 tmp
= size_int (JMP_BUF_SIZE
- 1);
273 /* Should be large enough for most systems, if it is not,
274 JMP_BUF_SIZE should be defined with the proper value. It will
275 also tend to be larger than necessary for most systems, a more
276 optimal port will define JMP_BUF_SIZE. */
277 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
280 /* Compute a minimally sized jump buffer. We need room to store at
281 least 3 pointers - stack pointer, frame pointer and return address.
282 Plus for some targets we need room for an extra pointer - in the
283 case of MIPS this is the global pointer. This makes a total of four
284 pointers, but to be safe we actually allocate room for 5.
286 If pointers are smaller than words then we allocate enough room for
287 5 words, just in case the backend needs this much room. For more
288 discussion on this issue see:
289 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
290 if (POINTER_SIZE
> BITS_PER_WORD
)
291 tmp
= size_int (5 - 1);
293 tmp
= size_int ((5 * BITS_PER_WORD
/ POINTER_SIZE
) - 1);
296 tmp
= build_index_type (tmp
);
297 tmp
= build_array_type (ptr_type_node
, tmp
);
298 f_jbuf
= build_decl (BUILTINS_LOCATION
,
299 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
300 #ifdef DONT_USE_BUILTIN_SETJMP
301 /* We don't know what the alignment requirements of the
302 runtime's jmp_buf has. Overestimate. */
303 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
304 DECL_USER_ALIGN (f_jbuf
) = 1;
306 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
308 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
309 TREE_CHAIN (f_prev
) = f_cs
;
310 TREE_CHAIN (f_cs
) = f_data
;
311 TREE_CHAIN (f_data
) = f_per
;
312 TREE_CHAIN (f_per
) = f_lsda
;
313 TREE_CHAIN (f_lsda
) = f_jbuf
;
315 layout_type (sjlj_fc_type_node
);
317 /* Cache the interesting field offsets so that we have
318 easy access from rtl. */
319 sjlj_fc_call_site_ofs
320 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs
))
321 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs
)) / BITS_PER_UNIT
);
323 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data
))
324 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data
)) / BITS_PER_UNIT
);
325 sjlj_fc_personality_ofs
326 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per
))
327 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per
)) / BITS_PER_UNIT
);
329 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda
))
330 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda
)) / BITS_PER_UNIT
);
332 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf
))
333 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf
)) / BITS_PER_UNIT
);
338 init_eh_for_function (void)
340 cfun
->eh
= ggc_cleared_alloc
<eh_status
> ();
342 /* Make sure zero'th entries are used. */
343 vec_safe_push (cfun
->eh
->region_array
, (eh_region
)0);
344 vec_safe_push (cfun
->eh
->lp_array
, (eh_landing_pad
)0);
347 /* Routines to generate the exception tree somewhat directly.
348 These are used from tree-eh.c when processing exception related
349 nodes during tree optimization. */
352 gen_eh_region (enum eh_region_type type
, eh_region outer
)
356 /* Insert a new blank region as a leaf in the tree. */
357 new_eh
= ggc_cleared_alloc
<eh_region_d
> ();
359 new_eh
->outer
= outer
;
362 new_eh
->next_peer
= outer
->inner
;
363 outer
->inner
= new_eh
;
367 new_eh
->next_peer
= cfun
->eh
->region_tree
;
368 cfun
->eh
->region_tree
= new_eh
;
371 new_eh
->index
= vec_safe_length (cfun
->eh
->region_array
);
372 vec_safe_push (cfun
->eh
->region_array
, new_eh
);
374 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
375 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
376 new_eh
->use_cxa_end_cleanup
= true;
382 gen_eh_region_cleanup (eh_region outer
)
384 return gen_eh_region (ERT_CLEANUP
, outer
);
388 gen_eh_region_try (eh_region outer
)
390 return gen_eh_region (ERT_TRY
, outer
);
394 gen_eh_region_catch (eh_region t
, tree type_or_list
)
397 tree type_list
, type_node
;
399 gcc_assert (t
->type
== ERT_TRY
);
401 /* Ensure to always end up with a type list to normalize further
402 processing, then register each type against the runtime types map. */
403 type_list
= type_or_list
;
406 if (TREE_CODE (type_or_list
) != TREE_LIST
)
407 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
409 type_node
= type_list
;
410 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
411 add_type_for_runtime (TREE_VALUE (type_node
));
414 c
= ggc_cleared_alloc
<eh_catch_d
> ();
415 c
->type_list
= type_list
;
416 l
= t
->u
.eh_try
.last_catch
;
421 t
->u
.eh_try
.first_catch
= c
;
422 t
->u
.eh_try
.last_catch
= c
;
428 gen_eh_region_allowed (eh_region outer
, tree allowed
)
430 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
431 region
->u
.allowed
.type_list
= allowed
;
433 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
434 add_type_for_runtime (TREE_VALUE (allowed
));
440 gen_eh_region_must_not_throw (eh_region outer
)
442 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
446 gen_eh_landing_pad (eh_region region
)
448 eh_landing_pad lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
450 lp
->next_lp
= region
->landing_pads
;
452 lp
->index
= vec_safe_length (cfun
->eh
->lp_array
);
453 region
->landing_pads
= lp
;
455 vec_safe_push (cfun
->eh
->lp_array
, lp
);
461 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
463 return (*ifun
->eh
->region_array
)[i
];
467 get_eh_region_from_number (int i
)
469 return get_eh_region_from_number_fn (cfun
, i
);
473 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
475 return (*ifun
->eh
->lp_array
)[i
];
479 get_eh_landing_pad_from_number (int i
)
481 return get_eh_landing_pad_from_number_fn (cfun
, i
);
485 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
488 return (*ifun
->eh
->region_array
)[-i
];
494 lp
= (*ifun
->eh
->lp_array
)[i
];
500 get_eh_region_from_lp_number (int i
)
502 return get_eh_region_from_lp_number_fn (cfun
, i
);
505 /* Returns true if the current function has exception handling regions. */
508 current_function_has_exception_handlers (void)
510 return cfun
->eh
->region_tree
!= NULL
;
513 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
514 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
516 struct duplicate_eh_regions_data
518 duplicate_eh_regions_map label_map
;
519 void *label_map_data
;
520 hash_map
<void *, void *> *eh_map
;
524 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
525 eh_region old_r
, eh_region outer
)
527 eh_landing_pad old_lp
, new_lp
;
530 new_r
= gen_eh_region (old_r
->type
, outer
);
531 gcc_assert (!data
->eh_map
->put (old_r
, new_r
));
541 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
543 /* We should be doing all our region duplication before and
544 during inlining, which is before filter lists are created. */
545 gcc_assert (oc
->filter_list
== NULL
);
546 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
547 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
552 case ERT_ALLOWED_EXCEPTIONS
:
553 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
554 if (old_r
->u
.allowed
.label
)
555 new_r
->u
.allowed
.label
556 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
558 new_r
->u
.allowed
.label
= NULL_TREE
;
561 case ERT_MUST_NOT_THROW
:
562 new_r
->u
.must_not_throw
.failure_loc
=
563 LOCATION_LOCUS (old_r
->u
.must_not_throw
.failure_loc
);
564 new_r
->u
.must_not_throw
.failure_decl
=
565 old_r
->u
.must_not_throw
.failure_decl
;
569 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
571 /* Don't bother copying unused landing pads. */
572 if (old_lp
->post_landing_pad
== NULL
)
575 new_lp
= gen_eh_landing_pad (new_r
);
576 gcc_assert (!data
->eh_map
->put (old_lp
, new_lp
));
578 new_lp
->post_landing_pad
579 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
580 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
583 /* Make sure to preserve the original use of __cxa_end_cleanup. */
584 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
586 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
587 duplicate_eh_regions_1 (data
, old_r
, new_r
);
590 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
591 the current function and root the tree below OUTER_REGION.
592 The special case of COPY_REGION of NULL means all regions.
593 Remap labels using MAP/MAP_DATA callback. Return a pointer map
594 that allows the caller to remap uses of both EH regions and
597 hash_map
<void *, void *> *
598 duplicate_eh_regions (struct function
*ifun
,
599 eh_region copy_region
, int outer_lp
,
600 duplicate_eh_regions_map map
, void *map_data
)
602 struct duplicate_eh_regions_data data
;
603 eh_region outer_region
;
606 verify_eh_tree (ifun
);
608 data
.label_map
= map
;
609 data
.label_map_data
= map_data
;
610 data
.eh_map
= new hash_map
<void *, void *>;
612 outer_region
= get_eh_region_from_lp_number_fn (cfun
, outer_lp
);
614 /* Copy all the regions in the subtree. */
616 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
620 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
621 duplicate_eh_regions_1 (&data
, r
, outer_region
);
625 verify_eh_tree (cfun
);
630 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
633 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
638 gcc_assert (ifun
->eh
->region_array
);
639 gcc_assert (ifun
->eh
->region_tree
);
641 b_outer
= sbitmap_alloc (ifun
->eh
->region_array
->length ());
642 bitmap_clear (b_outer
);
646 bitmap_set_bit (b_outer
, region_b
->index
);
647 region_b
= region_b
->outer
;
653 if (bitmap_bit_p (b_outer
, region_a
->index
))
655 region_a
= region_a
->outer
;
659 sbitmap_free (b_outer
);
664 add_type_for_runtime (tree type
)
666 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
667 if (TREE_CODE (type
) == NOP_EXPR
)
670 bool existed
= false;
671 tree
*slot
= &type_to_runtime_map
->get_or_insert (type
, &existed
);
673 *slot
= lang_hooks
.eh_runtime_type (type
);
677 lookup_type_for_runtime (tree type
)
679 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
680 if (TREE_CODE (type
) == NOP_EXPR
)
683 /* We should have always inserted the data earlier. */
684 return *type_to_runtime_map
->get (type
);
688 /* Represent an entry in @TTypes for either catch actions
689 or exception filter actions. */
690 struct ttypes_filter
{
695 /* Helper for ttypes_filter hashing. */
697 struct ttypes_filter_hasher
: free_ptr_hash
<ttypes_filter
>
699 typedef tree_node
*compare_type
;
700 static inline hashval_t
hash (const ttypes_filter
*);
701 static inline bool equal (const ttypes_filter
*, const tree_node
*);
704 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
705 (a tree) for a @TTypes type node we are thinking about adding. */
708 ttypes_filter_hasher::equal (const ttypes_filter
*entry
, const tree_node
*data
)
710 return entry
->t
== data
;
714 ttypes_filter_hasher::hash (const ttypes_filter
*entry
)
716 return TREE_HASH (entry
->t
);
719 typedef hash_table
<ttypes_filter_hasher
> ttypes_hash_type
;
722 /* Helper for ehspec hashing. */
724 struct ehspec_hasher
: free_ptr_hash
<ttypes_filter
>
726 static inline hashval_t
hash (const ttypes_filter
*);
727 static inline bool equal (const ttypes_filter
*, const ttypes_filter
*);
730 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
731 exception specification list we are thinking about adding. */
732 /* ??? Currently we use the type lists in the order given. Someone
733 should put these in some canonical order. */
736 ehspec_hasher::equal (const ttypes_filter
*entry
, const ttypes_filter
*data
)
738 return type_list_equal (entry
->t
, data
->t
);
741 /* Hash function for exception specification lists. */
744 ehspec_hasher::hash (const ttypes_filter
*entry
)
749 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
750 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
754 typedef hash_table
<ehspec_hasher
> ehspec_hash_type
;
757 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
758 to speed up the search. Return the filter value to be used. */
761 add_ttypes_entry (ttypes_hash_type
*ttypes_hash
, tree type
)
763 struct ttypes_filter
**slot
, *n
;
765 slot
= ttypes_hash
->find_slot_with_hash (type
, (hashval_t
) TREE_HASH (type
),
768 if ((n
= *slot
) == NULL
)
770 /* Filter value is a 1 based table index. */
772 n
= XNEW (struct ttypes_filter
);
774 n
->filter
= vec_safe_length (cfun
->eh
->ttype_data
) + 1;
777 vec_safe_push (cfun
->eh
->ttype_data
, type
);
783 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
784 to speed up the search. Return the filter value to be used. */
787 add_ehspec_entry (ehspec_hash_type
*ehspec_hash
, ttypes_hash_type
*ttypes_hash
,
790 struct ttypes_filter
**slot
, *n
;
791 struct ttypes_filter dummy
;
794 slot
= ehspec_hash
->find_slot (&dummy
, INSERT
);
796 if ((n
= *slot
) == NULL
)
800 if (targetm
.arm_eabi_unwinder
)
801 len
= vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
);
803 len
= vec_safe_length (cfun
->eh
->ehspec_data
.other
);
805 /* Filter value is a -1 based byte index into a uleb128 buffer. */
807 n
= XNEW (struct ttypes_filter
);
809 n
->filter
= -(len
+ 1);
812 /* Generate a 0 terminated list of filter values. */
813 for (; list
; list
= TREE_CHAIN (list
))
815 if (targetm
.arm_eabi_unwinder
)
816 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, TREE_VALUE (list
));
819 /* Look up each type in the list and encode its filter
820 value as a uleb128. */
821 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
822 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
825 if (targetm
.arm_eabi_unwinder
)
826 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
828 vec_safe_push (cfun
->eh
->ehspec_data
.other
, (uchar
)0);
834 /* Generate the action filter values to be used for CATCH and
835 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
836 we use lots of landing pads, and so every type or list can share
837 the same filter value, which saves table space. */
840 assign_filter_values (void)
846 vec_alloc (cfun
->eh
->ttype_data
, 16);
847 if (targetm
.arm_eabi_unwinder
)
848 vec_alloc (cfun
->eh
->ehspec_data
.arm_eabi
, 64);
850 vec_alloc (cfun
->eh
->ehspec_data
.other
, 64);
852 ehspec_hash_type
ehspec (31);
853 ttypes_hash_type
ttypes (31);
855 for (i
= 1; vec_safe_iterate (cfun
->eh
->region_array
, i
, &r
); ++i
)
863 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
865 /* Whatever type_list is (NULL or true list), we build a list
866 of filters for the region. */
867 c
->filter_list
= NULL_TREE
;
869 if (c
->type_list
!= NULL
)
871 /* Get a filter value for each of the types caught and store
872 them in the region's dedicated list. */
873 tree tp_node
= c
->type_list
;
875 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
878 = add_ttypes_entry (&ttypes
, TREE_VALUE (tp_node
));
879 tree flt_node
= build_int_cst (integer_type_node
, flt
);
882 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
887 /* Get a filter value for the NULL list also since it
888 will need an action record anyway. */
889 int flt
= add_ttypes_entry (&ttypes
, NULL
);
890 tree flt_node
= build_int_cst (integer_type_node
, flt
);
893 = tree_cons (NULL_TREE
, flt_node
, NULL
);
898 case ERT_ALLOWED_EXCEPTIONS
:
900 = add_ehspec_entry (&ehspec
, &ttypes
, r
->u
.allowed
.type_list
);
909 /* Emit SEQ into basic block just before INSN (that is assumed to be
910 first instruction of some existing BB and return the newly
913 emit_to_new_bb_before (rtx_insn
*seq
, rtx insn
)
920 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
921 call), we don't want it to go into newly created landing pad or other EH
923 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
924 if (e
->flags
& EDGE_FALLTHRU
)
925 force_nonfallthru (e
);
928 last
= emit_insn_before (seq
, insn
);
929 if (BARRIER_P (last
))
930 last
= PREV_INSN (last
);
931 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
932 update_bb_for_insn (bb
);
933 bb
->flags
|= BB_SUPERBLOCK
;
937 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
938 at the rtl level. Emit the code required by the target at a landing
939 pad for the given region. */
942 expand_dw2_landing_pad_for_region (eh_region region
)
944 if (targetm
.have_exception_receiver ())
945 emit_insn (targetm
.gen_exception_receiver ());
946 else if (targetm
.have_nonlocal_goto_receiver ())
947 emit_insn (targetm
.gen_nonlocal_goto_receiver ());
951 if (region
->exc_ptr_reg
)
952 emit_move_insn (region
->exc_ptr_reg
,
953 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
954 if (region
->filter_reg
)
955 emit_move_insn (region
->filter_reg
,
956 gen_rtx_REG (targetm
.eh_return_filter_mode (),
957 EH_RETURN_DATA_REGNO (1)));
960 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
963 dw2_build_landing_pads (void)
967 int e_flags
= EDGE_FALLTHRU
;
969 /* If we're going to partition blocks, we need to be able to add
970 new landing pads later, which means that we need to hold on to
971 the post-landing-pad block. Prevent it from being merged away.
972 We'll remove this bit after partitioning. */
973 if (flag_reorder_blocks_and_partition
)
974 e_flags
|= EDGE_PRESERVE
;
976 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
982 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
987 lp
->landing_pad
= gen_label_rtx ();
988 emit_label (lp
->landing_pad
);
989 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
991 expand_dw2_landing_pad_for_region (lp
->region
);
996 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
997 e
= make_edge (bb
, bb
->next_bb
, e_flags
);
998 e
->count
= bb
->count
;
999 e
->probability
= REG_BR_PROB_BASE
;
1002 struct loop
*loop
= bb
->next_bb
->loop_father
;
1003 /* If we created a pre-header block, add the new block to the
1004 outer loop, otherwise to the loop itself. */
1005 if (bb
->next_bb
== loop
->header
)
1006 add_bb_to_loop (bb
, loop_outer (loop
));
1008 add_bb_to_loop (bb
, loop
);
1014 static vec
<int> sjlj_lp_call_site_index
;
1016 /* Process all active landing pads. Assign each one a compact dispatch
1017 index, and a call-site index. */
1020 sjlj_assign_call_site_values (void)
1022 action_hash_type
ar_hash (31);
1026 vec_alloc (crtl
->eh
.action_record_data
, 64);
1030 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1031 if (lp
&& lp
->post_landing_pad
)
1033 int action
, call_site
;
1035 /* First: build the action table. */
1036 action
= collect_one_action_chain (&ar_hash
, lp
->region
);
1038 /* Next: assign call-site values. If dwarf2 terms, this would be
1039 the region number assigned by convert_to_eh_region_ranges, but
1040 handles no-action and must-not-throw differently. */
1041 /* Map must-not-throw to otherwise unused call-site index 0. */
1044 /* Map no-action to otherwise unused call-site index -1. */
1045 else if (action
== -1)
1047 /* Otherwise, look it up in the table. */
1049 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1050 sjlj_lp_call_site_index
[i
] = call_site
;
1058 /* Emit code to record the current call-site index before every
1059 insn that can throw. */
1062 sjlj_mark_call_sites (void)
1064 int last_call_site
= -2;
1068 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1074 rtx_insn
*before
, *p
;
1076 /* Reset value tracking at extended basic block boundaries. */
1078 last_call_site
= -2;
1080 /* If the function allocates dynamic stack space, the context must
1081 be updated after every allocation/deallocation accordingly. */
1082 if (NOTE_P (insn
) && NOTE_KIND (insn
) == NOTE_INSN_UPDATE_SJLJ_CONTEXT
)
1087 buf_addr
= plus_constant (Pmode
, XEXP (crtl
->eh
.sjlj_fc
, 0),
1089 expand_builtin_update_setjmp_buf (buf_addr
);
1092 emit_insn_before (p
, insn
);
1095 if (! INSN_P (insn
))
1098 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1102 this_call_site
= sjlj_lp_call_site_index
[lp
->index
];
1105 /* Calls (and trapping insns) without notes are outside any
1106 exception handling region in this function. Mark them as
1108 this_call_site
= -1;
1112 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1116 if (this_call_site
!= -1)
1117 crtl
->uses_eh_lsda
= 1;
1119 if (this_call_site
== last_call_site
)
1122 /* Don't separate a call from it's argument loads. */
1125 before
= find_first_parameter_load (insn
, NULL
);
1128 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1129 sjlj_fc_call_site_ofs
);
1130 emit_move_insn (mem
, gen_int_mode (this_call_site
, GET_MODE (mem
)));
1134 emit_insn_before (p
, before
);
1135 last_call_site
= this_call_site
;
1139 /* Construct the SjLj_Function_Context. */
1142 sjlj_emit_function_enter (rtx_code_label
*dispatch_label
)
1144 rtx_insn
*fn_begin
, *seq
;
1146 bool fn_begin_outside_block
;
1147 rtx personality
= get_personality_function (current_function_decl
);
1149 fc
= crtl
->eh
.sjlj_fc
;
1153 /* We're storing this libcall's address into memory instead of
1154 calling it directly. Thus, we must call assemble_external_libcall
1155 here, as we can not depend on emit_library_call to do it for us. */
1156 assemble_external_libcall (personality
);
1157 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1158 emit_move_insn (mem
, personality
);
1160 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1161 if (crtl
->uses_eh_lsda
)
1166 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1167 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1168 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1169 emit_move_insn (mem
, sym
);
1172 emit_move_insn (mem
, const0_rtx
);
1176 #ifdef DONT_USE_BUILTIN_SETJMP
1178 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1179 TYPE_MODE (integer_type_node
), 1,
1180 plus_constant (Pmode
, XEXP (fc
, 0),
1181 sjlj_fc_jbuf_ofs
), Pmode
);
1183 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1184 TYPE_MODE (integer_type_node
), 0,
1185 dispatch_label
, REG_BR_PROB_BASE
/ 100);
1187 expand_builtin_setjmp_setup (plus_constant (Pmode
, XEXP (fc
, 0),
1193 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1194 1, XEXP (fc
, 0), Pmode
);
1199 /* ??? Instead of doing this at the beginning of the function,
1200 do this in a block that is at loop level 0 and dominates all
1201 can_throw_internal instructions. */
1203 fn_begin_outside_block
= true;
1204 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1205 if (NOTE_P (fn_begin
))
1207 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1209 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1210 fn_begin_outside_block
= false;
1213 if (fn_begin_outside_block
)
1214 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1216 emit_insn_after (seq
, fn_begin
);
1219 /* Call back from expand_function_end to know where we should put
1220 the call to unwind_sjlj_unregister_libfunc if needed. */
1223 sjlj_emit_function_exit_after (rtx_insn
*after
)
1225 crtl
->eh
.sjlj_exit_after
= after
;
1229 sjlj_emit_function_exit (void)
1231 rtx_insn
*seq
, *insn
;
1235 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1236 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1241 /* ??? Really this can be done in any block at loop level 0 that
1242 post-dominates all can_throw_internal instructions. This is
1243 the last possible moment. */
1245 insn
= crtl
->eh
.sjlj_exit_after
;
1247 insn
= NEXT_INSN (insn
);
1249 emit_insn_after (seq
, insn
);
1253 sjlj_emit_dispatch_table (rtx_code_label
*dispatch_label
, int num_dispatch
)
1255 machine_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1256 machine_mode filter_mode
= targetm
.eh_return_filter_mode ();
1258 rtx mem
, fc
, exc_ptr_reg
, filter_reg
;
1264 vec
<tree
> dispatch_labels
= vNULL
;
1266 fc
= crtl
->eh
.sjlj_fc
;
1270 emit_label (dispatch_label
);
1272 #ifndef DONT_USE_BUILTIN_SETJMP
1273 expand_builtin_setjmp_receiver (dispatch_label
);
1275 /* The caller of expand_builtin_setjmp_receiver is responsible for
1276 making sure that the label doesn't vanish. The only other caller
1277 is the expander for __builtin_setjmp_receiver, which places this
1278 label on the nonlocal_goto_label list. Since we're modeling these
1279 CFG edges more exactly, we can use the forced_labels list instead. */
1280 LABEL_PRESERVE_P (dispatch_label
) = 1;
1282 = gen_rtx_INSN_LIST (VOIDmode
, dispatch_label
, forced_labels
);
1285 /* Load up exc_ptr and filter values from the function context. */
1286 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1287 if (unwind_word_mode
!= ptr_mode
)
1289 #ifdef POINTERS_EXTEND_UNSIGNED
1290 mem
= convert_memory_address (ptr_mode
, mem
);
1292 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1295 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1297 mem
= adjust_address (fc
, unwind_word_mode
,
1298 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1299 if (unwind_word_mode
!= filter_mode
)
1300 mem
= convert_to_mode (filter_mode
, mem
, 0);
1301 filter_reg
= force_reg (filter_mode
, mem
);
1303 /* Jump to one of the directly reachable regions. */
1306 rtx_code_label
*first_reachable_label
= NULL
;
1308 /* If there's exactly one call site in the function, don't bother
1309 generating a switch statement. */
1310 if (num_dispatch
> 1)
1311 dispatch_labels
.create (num_dispatch
);
1313 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1314 if (lp
&& lp
->post_landing_pad
)
1317 rtx_code_label
*label
;
1321 lp
->landing_pad
= dispatch_label
;
1323 if (num_dispatch
> 1)
1325 tree t_label
, case_elt
, t
;
1327 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1328 t
= build_int_cst (integer_type_node
, disp_index
);
1329 case_elt
= build_case_label (t
, NULL
, t_label
);
1330 dispatch_labels
.quick_push (case_elt
);
1331 label
= jump_target_rtx (t_label
);
1334 label
= gen_label_rtx ();
1336 if (disp_index
== 0)
1337 first_reachable_label
= label
;
1342 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1344 emit_move_insn (r
->filter_reg
, filter_reg
);
1346 seq2
= get_insns ();
1349 rtx_insn
*before
= label_rtx (lp
->post_landing_pad
);
1350 bb
= emit_to_new_bb_before (seq2
, before
);
1351 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1352 e
->count
= bb
->count
;
1353 e
->probability
= REG_BR_PROB_BASE
;
1356 struct loop
*loop
= bb
->next_bb
->loop_father
;
1357 /* If we created a pre-header block, add the new block to the
1358 outer loop, otherwise to the loop itself. */
1359 if (bb
->next_bb
== loop
->header
)
1360 add_bb_to_loop (bb
, loop_outer (loop
));
1362 add_bb_to_loop (bb
, loop
);
1363 /* ??? For multiple dispatches we will end up with edges
1364 from the loop tree root into this loop, making it a
1365 multiple-entry loop. Discard all affected loops. */
1366 if (num_dispatch
> 1)
1368 for (loop
= bb
->loop_father
;
1369 loop_outer (loop
); loop
= loop_outer (loop
))
1370 mark_loop_for_removal (loop
);
1376 gcc_assert (disp_index
== num_dispatch
);
1378 if (num_dispatch
> 1)
1380 rtx disp
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1381 sjlj_fc_call_site_ofs
);
1382 expand_sjlj_dispatch_table (disp
, dispatch_labels
);
1388 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1389 if (num_dispatch
== 1)
1391 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1392 e
->count
= bb
->count
;
1393 e
->probability
= REG_BR_PROB_BASE
;
1396 struct loop
*loop
= bb
->next_bb
->loop_father
;
1397 /* If we created a pre-header block, add the new block to the
1398 outer loop, otherwise to the loop itself. */
1399 if (bb
->next_bb
== loop
->header
)
1400 add_bb_to_loop (bb
, loop_outer (loop
));
1402 add_bb_to_loop (bb
, loop
);
1407 /* We are not wiring up edges here, but as the dispatcher call
1408 is at function begin simply associate the block with the
1409 outermost (non-)loop. */
1411 add_bb_to_loop (bb
, current_loops
->tree_root
);
1416 sjlj_build_landing_pads (void)
1420 num_dispatch
= vec_safe_length (cfun
->eh
->lp_array
);
1421 if (num_dispatch
== 0)
1423 sjlj_lp_call_site_index
.safe_grow_cleared (num_dispatch
);
1425 num_dispatch
= sjlj_assign_call_site_values ();
1426 if (num_dispatch
> 0)
1428 rtx_code_label
*dispatch_label
= gen_label_rtx ();
1429 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1430 TYPE_MODE (sjlj_fc_type_node
),
1431 TYPE_ALIGN (sjlj_fc_type_node
));
1433 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1434 int_size_in_bytes (sjlj_fc_type_node
),
1437 sjlj_mark_call_sites ();
1438 sjlj_emit_function_enter (dispatch_label
);
1439 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1440 sjlj_emit_function_exit ();
1443 /* If we do not have any landing pads, we may still need to register a
1444 personality routine and (empty) LSDA to handle must-not-throw regions. */
1445 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
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 (NULL
);
1457 sjlj_emit_function_exit ();
1460 sjlj_lp_call_site_index
.release ();
1463 /* Update the sjlj function context. This function should be called
1464 whenever we allocate or deallocate dynamic stack space. */
1467 update_sjlj_context (void)
1469 if (!flag_exceptions
)
1472 emit_note (NOTE_INSN_UPDATE_SJLJ_CONTEXT
);
1475 /* After initial rtl generation, call back to finish generating
1476 exception support code. */
1479 finish_eh_generation (void)
1483 /* Construct the landing pads. */
1484 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1485 sjlj_build_landing_pads ();
1487 dw2_build_landing_pads ();
1488 break_superblocks ();
1490 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1491 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1492 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->insns
.r
)
1493 commit_edge_insertions ();
1495 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1496 FOR_EACH_BB_FN (bb
, cfun
)
1502 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1504 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1505 if (e
->flags
& EDGE_EH
)
1508 /* We should not have generated any new throwing insns during this
1509 pass, and we should not have lost any EH edges, so we only need
1510 to handle two cases here:
1511 (1) reachable handler and an existing edge to post-landing-pad,
1512 (2) no reachable handler and no edge. */
1513 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1516 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1518 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1519 e
->flags
|= (CALL_P (BB_END (bb
))
1520 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1526 /* This section handles removing dead code for flow. */
1529 remove_eh_landing_pad (eh_landing_pad lp
)
1533 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1537 if (lp
->post_landing_pad
)
1538 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1539 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1542 /* Splice the EH region at PP from the region tree. */
1545 remove_eh_handler_splicer (eh_region
*pp
)
1547 eh_region region
= *pp
;
1550 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1552 if (lp
->post_landing_pad
)
1553 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1554 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1560 outer
= region
->outer
;
1562 *pp
= p
= region
->inner
;
1571 *pp
= region
->next_peer
;
1573 (*cfun
->eh
->region_array
)[region
->index
] = NULL
;
1576 /* Splice a single EH region REGION from the region tree.
1578 To unlink REGION, we need to find the pointer to it with a relatively
1579 expensive search in REGION's outer region. If you are going to
1580 remove a number of handlers, using remove_unreachable_eh_regions may
1581 be a better option. */
1584 remove_eh_handler (eh_region region
)
1586 eh_region
*pp
, *pp_start
, p
, outer
;
1588 outer
= region
->outer
;
1590 pp_start
= &outer
->inner
;
1592 pp_start
= &cfun
->eh
->region_tree
;
1593 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1596 remove_eh_handler_splicer (pp
);
1599 /* Worker for remove_unreachable_eh_regions.
1600 PP is a pointer to the region to start a region tree depth-first
1601 search from. R_REACHABLE is the set of regions that have to be
1605 remove_unreachable_eh_regions_worker (eh_region
*pp
, sbitmap r_reachable
)
1609 eh_region region
= *pp
;
1610 remove_unreachable_eh_regions_worker (®ion
->inner
, r_reachable
);
1611 if (!bitmap_bit_p (r_reachable
, region
->index
))
1612 remove_eh_handler_splicer (pp
);
1614 pp
= ®ion
->next_peer
;
1618 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1619 Do this by traversing the EH tree top-down and splice out regions that
1620 are not marked. By removing regions from the leaves, we avoid costly
1621 searches in the region tree. */
1624 remove_unreachable_eh_regions (sbitmap r_reachable
)
1626 remove_unreachable_eh_regions_worker (&cfun
->eh
->region_tree
, r_reachable
);
1629 /* Invokes CALLBACK for every exception handler landing pad label.
1630 Only used by reload hackery; should not be used by new code. */
1633 for_each_eh_label (void (*callback
) (rtx
))
1638 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1642 rtx_code_label
*lab
= lp
->landing_pad
;
1643 if (lab
&& LABEL_P (lab
))
1649 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1652 At the gimple level, we use LP_NR
1653 > 0 : The statement transfers to landing pad LP_NR
1654 = 0 : The statement is outside any EH region
1655 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1657 At the rtl level, we use LP_NR
1658 > 0 : The insn transfers to landing pad LP_NR
1659 = 0 : The insn cannot throw
1660 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1661 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1662 missing note: The insn is outside any EH region.
1664 ??? This difference probably ought to be avoided. We could stand
1665 to record nothrow for arbitrary gimple statements, and so avoid
1666 some moderately complex lookups in stmt_could_throw_p. Perhaps
1667 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1668 no-nonlocal-goto property should be recorded elsewhere as a bit
1669 on the call_insn directly. Perhaps we should make more use of
1670 attaching the trees to call_insns (reachable via symbol_ref in
1671 direct call cases) and just pull the data out of the trees. */
1674 make_reg_eh_region_note (rtx_insn
*insn
, int ecf_flags
, int lp_nr
)
1677 if (ecf_flags
& ECF_NOTHROW
)
1679 else if (lp_nr
!= 0)
1680 value
= GEN_INT (lp_nr
);
1683 add_reg_note (insn
, REG_EH_REGION
, value
);
1686 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1687 nor perform a non-local goto. Replace the region note if it
1691 make_reg_eh_region_note_nothrow_nononlocal (rtx_insn
*insn
)
1693 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1694 rtx intmin
= GEN_INT (INT_MIN
);
1697 XEXP (note
, 0) = intmin
;
1699 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1702 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1706 insn_could_throw_p (const_rtx insn
)
1708 if (!flag_exceptions
)
1712 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1713 return may_trap_p (PATTERN (insn
));
1717 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1718 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1719 to look for a note, or the note itself. */
1722 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx_insn
*first
, rtx last
)
1725 rtx note
= note_or_insn
;
1727 if (INSN_P (note_or_insn
))
1729 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1733 note
= XEXP (note
, 0);
1735 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1736 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1737 && insn_could_throw_p (insn
))
1738 add_reg_note (insn
, REG_EH_REGION
, note
);
1741 /* Likewise, but iterate backward. */
1744 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx_insn
*last
, rtx first
)
1747 rtx note
= note_or_insn
;
1749 if (INSN_P (note_or_insn
))
1751 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1755 note
= XEXP (note
, 0);
1757 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1758 if (insn_could_throw_p (insn
))
1759 add_reg_note (insn
, REG_EH_REGION
, note
);
1763 /* Extract all EH information from INSN. Return true if the insn
1764 was marked NOTHROW. */
1767 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1768 eh_landing_pad
*plp
)
1770 eh_landing_pad lp
= NULL
;
1776 if (! INSN_P (insn
))
1779 if (NONJUMP_INSN_P (insn
)
1780 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1781 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1783 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1786 ret
= !insn_could_throw_p (insn
);
1790 lp_nr
= INTVAL (XEXP (note
, 0));
1791 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1798 r
= (*cfun
->eh
->region_array
)[-lp_nr
];
1801 lp
= (*cfun
->eh
->lp_array
)[lp_nr
];
1811 /* Return the landing pad to which INSN may go, or NULL if it does not
1812 have a reachable landing pad within this function. */
1815 get_eh_landing_pad_from_rtx (const_rtx insn
)
1820 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1824 /* Return the region to which INSN may go, or NULL if it does not
1825 have a reachable region within this function. */
1828 get_eh_region_from_rtx (const_rtx insn
)
1833 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1837 /* Return true if INSN throws and is caught by something in this function. */
1840 can_throw_internal (const_rtx insn
)
1842 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1845 /* Return true if INSN throws and escapes from the current function. */
1848 can_throw_external (const_rtx insn
)
1854 if (! INSN_P (insn
))
1857 if (NONJUMP_INSN_P (insn
)
1858 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1860 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1861 int i
, n
= seq
->len ();
1863 for (i
= 0; i
< n
; i
++)
1864 if (can_throw_external (seq
->element (i
)))
1870 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1872 /* If we can't throw, we obviously can't throw external. */
1876 /* If we have an internal landing pad, then we're not external. */
1880 /* If we're not within an EH region, then we are external. */
1884 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1885 which don't always have landing pads. */
1886 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1890 /* Return true if INSN cannot throw at all. */
1893 insn_nothrow_p (const_rtx insn
)
1898 if (! INSN_P (insn
))
1901 if (NONJUMP_INSN_P (insn
)
1902 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1904 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1905 int i
, n
= seq
->len ();
1907 for (i
= 0; i
< n
; i
++)
1908 if (!insn_nothrow_p (seq
->element (i
)))
1914 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1917 /* Return true if INSN can perform a non-local goto. */
1918 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1921 can_nonlocal_goto (const rtx_insn
*insn
)
1923 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1925 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1926 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1932 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1935 set_nothrow_function_flags (void)
1941 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1942 something that can throw an exception. We specifically exempt
1943 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1944 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1947 crtl
->all_throwers_are_sibcalls
= 1;
1949 /* If we don't know that this implementation of the function will
1950 actually be used, then we must not set TREE_NOTHROW, since
1951 callers must not assume that this function does not throw. */
1952 if (TREE_NOTHROW (current_function_decl
))
1955 if (! flag_exceptions
)
1958 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1959 if (can_throw_external (insn
))
1963 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1965 crtl
->all_throwers_are_sibcalls
= 0;
1971 && (cgraph_node::get (current_function_decl
)->get_availability ()
1972 >= AVAIL_AVAILABLE
))
1974 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1975 struct cgraph_edge
*e
;
1976 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1977 e
->can_throw_external
= false;
1978 node
->set_nothrow_flag (true);
1981 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
1982 current_function_name ());
1989 const pass_data pass_data_set_nothrow_function_flags
=
1991 RTL_PASS
, /* type */
1992 "nothrow", /* name */
1993 OPTGROUP_NONE
, /* optinfo_flags */
1994 TV_NONE
, /* tv_id */
1995 0, /* properties_required */
1996 0, /* properties_provided */
1997 0, /* properties_destroyed */
1998 0, /* todo_flags_start */
1999 0, /* todo_flags_finish */
2002 class pass_set_nothrow_function_flags
: public rtl_opt_pass
2005 pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2006 : rtl_opt_pass (pass_data_set_nothrow_function_flags
, ctxt
)
2009 /* opt_pass methods: */
2010 virtual unsigned int execute (function
*)
2012 return set_nothrow_function_flags ();
2015 }; // class pass_set_nothrow_function_flags
2020 make_pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2022 return new pass_set_nothrow_function_flags (ctxt
);
2026 /* Various hooks for unwind library. */
2028 /* Expand the EH support builtin functions:
2029 __builtin_eh_pointer and __builtin_eh_filter. */
2032 expand_builtin_eh_common (tree region_nr_t
)
2034 HOST_WIDE_INT region_nr
;
2037 gcc_assert (tree_fits_shwi_p (region_nr_t
));
2038 region_nr
= tree_to_shwi (region_nr_t
);
2040 region
= (*cfun
->eh
->region_array
)[region_nr
];
2042 /* ??? We shouldn't have been able to delete a eh region without
2043 deleting all the code that depended on it. */
2044 gcc_assert (region
!= NULL
);
2049 /* Expand to the exc_ptr value from the given eh region. */
2052 expand_builtin_eh_pointer (tree exp
)
2055 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2056 if (region
->exc_ptr_reg
== NULL
)
2057 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2058 return region
->exc_ptr_reg
;
2061 /* Expand to the filter value from the given eh region. */
2064 expand_builtin_eh_filter (tree exp
)
2067 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2068 if (region
->filter_reg
== NULL
)
2069 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
2070 return region
->filter_reg
;
2073 /* Copy the exc_ptr and filter values from one landing pad's registers
2074 to another. This is used to inline the resx statement. */
2077 expand_builtin_eh_copy_values (tree exp
)
2080 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2082 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
2083 machine_mode fmode
= targetm
.eh_return_filter_mode ();
2085 if (dst
->exc_ptr_reg
== NULL
)
2086 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2087 if (src
->exc_ptr_reg
== NULL
)
2088 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2090 if (dst
->filter_reg
== NULL
)
2091 dst
->filter_reg
= gen_reg_rtx (fmode
);
2092 if (src
->filter_reg
== NULL
)
2093 src
->filter_reg
= gen_reg_rtx (fmode
);
2095 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2096 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2101 /* Do any necessary initialization to access arbitrary stack frames.
2102 On the SPARC, this means flushing the register windows. */
2105 expand_builtin_unwind_init (void)
2107 /* Set this so all the registers get saved in our frame; we need to be
2108 able to copy the saved values for any registers from frames we unwind. */
2109 crtl
->saves_all_registers
= 1;
2111 SETUP_FRAME_ADDRESSES ();
2114 /* Map a non-negative number to an eh return data register number; expands
2115 to -1 if no return data register is associated with the input number.
2116 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2119 expand_builtin_eh_return_data_regno (tree exp
)
2121 tree which
= CALL_EXPR_ARG (exp
, 0);
2122 unsigned HOST_WIDE_INT iwhich
;
2124 if (TREE_CODE (which
) != INTEGER_CST
)
2126 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2130 iwhich
= tree_to_uhwi (which
);
2131 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2132 if (iwhich
== INVALID_REGNUM
)
2135 #ifdef DWARF_FRAME_REGNUM
2136 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2138 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2141 return GEN_INT (iwhich
);
2144 /* Given a value extracted from the return address register or stack slot,
2145 return the actual address encoded in that value. */
2148 expand_builtin_extract_return_addr (tree addr_tree
)
2150 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2152 if (GET_MODE (addr
) != Pmode
2153 && GET_MODE (addr
) != VOIDmode
)
2155 #ifdef POINTERS_EXTEND_UNSIGNED
2156 addr
= convert_memory_address (Pmode
, addr
);
2158 addr
= convert_to_mode (Pmode
, addr
, 0);
2162 /* First mask out any unwanted bits. */
2163 rtx mask
= MASK_RETURN_ADDR
;
2165 expand_and (Pmode
, addr
, mask
, addr
);
2167 /* Then adjust to find the real return address. */
2168 if (RETURN_ADDR_OFFSET
)
2169 addr
= plus_constant (Pmode
, addr
, RETURN_ADDR_OFFSET
);
2174 /* Given an actual address in addr_tree, do any necessary encoding
2175 and return the value to be stored in the return address register or
2176 stack slot so the epilogue will return to that address. */
2179 expand_builtin_frob_return_addr (tree addr_tree
)
2181 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2183 addr
= convert_memory_address (Pmode
, addr
);
2185 if (RETURN_ADDR_OFFSET
)
2187 addr
= force_reg (Pmode
, addr
);
2188 addr
= plus_constant (Pmode
, addr
, -RETURN_ADDR_OFFSET
);
2194 /* Set up the epilogue with the magic bits we'll need to return to the
2195 exception handler. */
2198 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2203 #ifdef EH_RETURN_STACKADJ_RTX
2204 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2205 VOIDmode
, EXPAND_NORMAL
);
2206 tmp
= convert_memory_address (Pmode
, tmp
);
2207 if (!crtl
->eh
.ehr_stackadj
)
2208 crtl
->eh
.ehr_stackadj
= copy_addr_to_reg (tmp
);
2209 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2210 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2213 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2214 VOIDmode
, EXPAND_NORMAL
);
2215 tmp
= convert_memory_address (Pmode
, tmp
);
2216 if (!crtl
->eh
.ehr_handler
)
2217 crtl
->eh
.ehr_handler
= copy_addr_to_reg (tmp
);
2218 else if (tmp
!= crtl
->eh
.ehr_handler
)
2219 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2221 if (!crtl
->eh
.ehr_label
)
2222 crtl
->eh
.ehr_label
= gen_label_rtx ();
2223 emit_jump (crtl
->eh
.ehr_label
);
2226 /* Expand __builtin_eh_return. This exit path from the function loads up
2227 the eh return data registers, adjusts the stack, and branches to a
2228 given PC other than the normal return address. */
2231 expand_eh_return (void)
2233 rtx_code_label
*around_label
;
2235 if (! crtl
->eh
.ehr_label
)
2238 crtl
->calls_eh_return
= 1;
2240 #ifdef EH_RETURN_STACKADJ_RTX
2241 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2244 around_label
= gen_label_rtx ();
2245 emit_jump (around_label
);
2247 emit_label (crtl
->eh
.ehr_label
);
2248 clobber_return_register ();
2250 #ifdef EH_RETURN_STACKADJ_RTX
2251 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2254 if (targetm
.have_eh_return ())
2255 emit_insn (targetm
.gen_eh_return (crtl
->eh
.ehr_handler
));
2258 #ifdef EH_RETURN_HANDLER_RTX
2259 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2261 error ("__builtin_eh_return not supported on this target");
2265 emit_label (around_label
);
2268 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2269 POINTERS_EXTEND_UNSIGNED and return it. */
2272 expand_builtin_extend_pointer (tree addr_tree
)
2274 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2277 #ifdef POINTERS_EXTEND_UNSIGNED
2278 extend
= POINTERS_EXTEND_UNSIGNED
;
2280 /* The previous EH code did an unsigned extend by default, so we do this also
2285 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2289 add_action_record (action_hash_type
*ar_hash
, int filter
, int next
)
2291 struct action_record
**slot
, *new_ar
, tmp
;
2293 tmp
.filter
= filter
;
2295 slot
= ar_hash
->find_slot (&tmp
, INSERT
);
2297 if ((new_ar
= *slot
) == NULL
)
2299 new_ar
= XNEW (struct action_record
);
2300 new_ar
->offset
= crtl
->eh
.action_record_data
->length () + 1;
2301 new_ar
->filter
= filter
;
2302 new_ar
->next
= next
;
2305 /* The filter value goes in untouched. The link to the next
2306 record is a "self-relative" byte offset, or zero to indicate
2307 that there is no next record. So convert the absolute 1 based
2308 indices we've been carrying around into a displacement. */
2310 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2312 next
-= crtl
->eh
.action_record_data
->length () + 1;
2313 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2316 return new_ar
->offset
;
2320 collect_one_action_chain (action_hash_type
*ar_hash
, eh_region region
)
2324 /* If we've reached the top of the region chain, then we have
2325 no actions, and require no landing pad. */
2329 switch (region
->type
)
2334 /* A cleanup adds a zero filter to the beginning of the chain, but
2335 there are special cases to look out for. If there are *only*
2336 cleanups along a path, then it compresses to a zero action.
2337 Further, if there are multiple cleanups along a path, we only
2338 need to represent one of them, as that is enough to trigger
2339 entry to the landing pad at runtime. */
2340 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2343 for (r
= region
->outer
; r
; r
= r
->outer
)
2344 if (r
->type
== ERT_CLEANUP
)
2346 return add_action_record (ar_hash
, 0, next
);
2353 /* Process the associated catch regions in reverse order.
2354 If there's a catch-all handler, then we don't need to
2355 search outer regions. Use a magic -3 value to record
2356 that we haven't done the outer search. */
2358 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2360 if (c
->type_list
== NULL
)
2362 /* Retrieve the filter from the head of the filter list
2363 where we have stored it (see assign_filter_values). */
2364 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2365 next
= add_action_record (ar_hash
, filter
, 0);
2369 /* Once the outer search is done, trigger an action record for
2370 each filter we have. */
2375 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2377 /* If there is no next action, terminate the chain. */
2380 /* If all outer actions are cleanups or must_not_throw,
2381 we'll have no action record for it, since we had wanted
2382 to encode these states in the call-site record directly.
2383 Add a cleanup action to the chain to catch these. */
2385 next
= add_action_record (ar_hash
, 0, 0);
2388 flt_node
= c
->filter_list
;
2389 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2391 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2392 next
= add_action_record (ar_hash
, filter
, next
);
2399 case ERT_ALLOWED_EXCEPTIONS
:
2400 /* An exception specification adds its filter to the
2401 beginning of the chain. */
2402 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2404 /* If there is no next action, terminate the chain. */
2407 /* If all outer actions are cleanups or must_not_throw,
2408 we'll have no action record for it, since we had wanted
2409 to encode these states in the call-site record directly.
2410 Add a cleanup action to the chain to catch these. */
2412 next
= add_action_record (ar_hash
, 0, 0);
2414 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2416 case ERT_MUST_NOT_THROW
:
2417 /* A must-not-throw region with no inner handlers or cleanups
2418 requires no call-site entry. Note that this differs from
2419 the no handler or cleanup case in that we do require an lsda
2420 to be generated. Return a magic -2 value to record this. */
2428 add_call_site (rtx landing_pad
, int action
, int section
)
2430 call_site_record record
;
2432 record
= ggc_alloc
<call_site_record_d
> ();
2433 record
->landing_pad
= landing_pad
;
2434 record
->action
= action
;
2436 vec_safe_push (crtl
->eh
.call_site_record_v
[section
], record
);
2438 return call_site_base
+ crtl
->eh
.call_site_record_v
[section
]->length () - 1;
2442 emit_note_eh_region_end (rtx_insn
*insn
)
2444 rtx_insn
*next
= NEXT_INSN (insn
);
2446 /* Make sure we do not split a call and its corresponding
2447 CALL_ARG_LOCATION note. */
2448 if (next
&& NOTE_P (next
)
2449 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
2452 return emit_note_after (NOTE_INSN_EH_REGION_END
, insn
);
2455 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2456 The new note numbers will not refer to region numbers, but
2457 instead to call site entries. */
2460 convert_to_eh_region_ranges (void)
2465 action_hash_type
ar_hash (31);
2466 int last_action
= -3;
2467 rtx_insn
*last_action_insn
= NULL
;
2468 rtx last_landing_pad
= NULL_RTX
;
2469 rtx_insn
*first_no_action_insn
= NULL
;
2472 rtx_insn
*section_switch_note
= NULL
;
2473 rtx_insn
*first_no_action_insn_before_switch
= NULL
;
2474 rtx_insn
*last_no_action_insn_before_switch
= NULL
;
2475 int saved_call_site_base
= call_site_base
;
2477 vec_alloc (crtl
->eh
.action_record_data
, 64);
2479 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2486 rtx_code_label
*this_landing_pad
;
2489 if (NONJUMP_INSN_P (insn
)
2490 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2491 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2493 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2497 this_action
= collect_one_action_chain (&ar_hash
, region
);
2501 /* Existence of catch handlers, or must-not-throw regions
2502 implies that an lsda is needed (even if empty). */
2503 if (this_action
!= -1)
2504 crtl
->uses_eh_lsda
= 1;
2506 /* Delay creation of region notes for no-action regions
2507 until we're sure that an lsda will be required. */
2508 else if (last_action
== -3)
2510 first_no_action_insn
= iter
;
2514 if (this_action
>= 0)
2515 this_landing_pad
= lp
->landing_pad
;
2517 this_landing_pad
= NULL
;
2519 /* Differing actions or landing pads implies a change in call-site
2520 info, which implies some EH_REGION note should be emitted. */
2521 if (last_action
!= this_action
2522 || last_landing_pad
!= this_landing_pad
)
2524 /* If there is a queued no-action region in the other section
2525 with hot/cold partitioning, emit it now. */
2526 if (first_no_action_insn_before_switch
)
2528 gcc_assert (this_action
!= -1
2529 && last_action
== (first_no_action_insn
2531 call_site
= add_call_site (NULL_RTX
, 0, 0);
2532 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2533 first_no_action_insn_before_switch
);
2534 NOTE_EH_HANDLER (note
) = call_site
;
2536 = emit_note_eh_region_end (last_no_action_insn_before_switch
);
2537 NOTE_EH_HANDLER (note
) = call_site
;
2538 gcc_assert (last_action
!= -3
2539 || (last_action_insn
2540 == last_no_action_insn_before_switch
));
2541 first_no_action_insn_before_switch
= NULL
;
2542 last_no_action_insn_before_switch
= NULL
;
2545 /* If we'd not seen a previous action (-3) or the previous
2546 action was must-not-throw (-2), then we do not need an
2548 if (last_action
>= -1)
2550 /* If we delayed the creation of the begin, do it now. */
2551 if (first_no_action_insn
)
2553 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2554 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2555 first_no_action_insn
);
2556 NOTE_EH_HANDLER (note
) = call_site
;
2557 first_no_action_insn
= NULL
;
2560 note
= emit_note_eh_region_end (last_action_insn
);
2561 NOTE_EH_HANDLER (note
) = call_site
;
2564 /* If the new action is must-not-throw, then no region notes
2566 if (this_action
>= -1)
2568 call_site
= add_call_site (this_landing_pad
,
2569 this_action
< 0 ? 0 : this_action
,
2571 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2572 NOTE_EH_HANDLER (note
) = call_site
;
2575 last_action
= this_action
;
2576 last_landing_pad
= this_landing_pad
;
2578 last_action_insn
= iter
;
2580 else if (NOTE_P (iter
)
2581 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2583 gcc_assert (section_switch_note
== NULL_RTX
);
2584 gcc_assert (flag_reorder_blocks_and_partition
);
2585 section_switch_note
= iter
;
2586 if (first_no_action_insn
)
2588 first_no_action_insn_before_switch
= first_no_action_insn
;
2589 last_no_action_insn_before_switch
= last_action_insn
;
2590 first_no_action_insn
= NULL
;
2591 gcc_assert (last_action
== -1);
2594 /* Force closing of current EH region before section switch and
2595 opening a new one afterwards. */
2596 else if (last_action
!= -3)
2597 last_landing_pad
= pc_rtx
;
2598 if (crtl
->eh
.call_site_record_v
[cur_sec
])
2599 call_site_base
+= crtl
->eh
.call_site_record_v
[cur_sec
]->length ();
2601 gcc_assert (crtl
->eh
.call_site_record_v
[cur_sec
] == NULL
);
2602 vec_alloc (crtl
->eh
.call_site_record_v
[cur_sec
], 10);
2605 if (last_action
>= -1 && ! first_no_action_insn
)
2607 note
= emit_note_eh_region_end (last_action_insn
);
2608 NOTE_EH_HANDLER (note
) = call_site
;
2611 call_site_base
= saved_call_site_base
;
2618 const pass_data pass_data_convert_to_eh_region_ranges
=
2620 RTL_PASS
, /* type */
2621 "eh_ranges", /* name */
2622 OPTGROUP_NONE
, /* optinfo_flags */
2623 TV_NONE
, /* tv_id */
2624 0, /* properties_required */
2625 0, /* properties_provided */
2626 0, /* properties_destroyed */
2627 0, /* todo_flags_start */
2628 0, /* todo_flags_finish */
2631 class pass_convert_to_eh_region_ranges
: public rtl_opt_pass
2634 pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2635 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges
, ctxt
)
2638 /* opt_pass methods: */
2639 virtual bool gate (function
*);
2640 virtual unsigned int execute (function
*)
2642 return convert_to_eh_region_ranges ();
2645 }; // class pass_convert_to_eh_region_ranges
2648 pass_convert_to_eh_region_ranges::gate (function
*)
2650 /* Nothing to do for SJLJ exceptions or if no regions created. */
2651 if (cfun
->eh
->region_tree
== NULL
)
2653 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2661 make_pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2663 return new pass_convert_to_eh_region_ranges (ctxt
);
2667 push_uleb128 (vec
<uchar
, va_gc
> **data_area
, unsigned int value
)
2671 unsigned char byte
= value
& 0x7f;
2675 vec_safe_push (*data_area
, byte
);
2681 push_sleb128 (vec
<uchar
, va_gc
> **data_area
, int value
)
2688 byte
= value
& 0x7f;
2690 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2691 || (value
== -1 && (byte
& 0x40) != 0));
2694 vec_safe_push (*data_area
, byte
);
2700 #ifndef HAVE_AS_LEB128
2702 dw2_size_of_call_site_table (int section
)
2704 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2705 int size
= n
* (4 + 4 + 4);
2708 for (i
= 0; i
< n
; ++i
)
2710 struct call_site_record_d
*cs
=
2711 (*crtl
->eh
.call_site_record_v
[section
])[i
];
2712 size
+= size_of_uleb128 (cs
->action
);
2719 sjlj_size_of_call_site_table (void)
2721 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2725 for (i
= 0; i
< n
; ++i
)
2727 struct call_site_record_d
*cs
=
2728 (*crtl
->eh
.call_site_record_v
[0])[i
];
2729 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2730 size
+= size_of_uleb128 (cs
->action
);
2738 dw2_output_call_site_table (int cs_format
, int section
)
2740 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2745 begin
= current_function_func_begin_label
;
2746 else if (first_function_block_is_cold
)
2747 begin
= crtl
->subsections
.hot_section_label
;
2749 begin
= crtl
->subsections
.cold_section_label
;
2751 for (i
= 0; i
< n
; ++i
)
2753 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[section
])[i
];
2754 char reg_start_lab
[32];
2755 char reg_end_lab
[32];
2756 char landing_pad_lab
[32];
2758 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2759 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2761 if (cs
->landing_pad
)
2762 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2763 CODE_LABEL_NUMBER (cs
->landing_pad
));
2765 /* ??? Perhaps use insn length scaling if the assembler supports
2766 generic arithmetic. */
2767 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2768 data4 if the function is small enough. */
2769 if (cs_format
== DW_EH_PE_uleb128
)
2771 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2772 "region %d start", i
);
2773 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2775 if (cs
->landing_pad
)
2776 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2779 dw2_asm_output_data_uleb128 (0, "landing pad");
2783 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2784 "region %d start", i
);
2785 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2786 if (cs
->landing_pad
)
2787 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2790 dw2_asm_output_data (4, 0, "landing pad");
2792 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2795 call_site_base
+= n
;
2799 sjlj_output_call_site_table (void)
2801 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2804 for (i
= 0; i
< n
; ++i
)
2806 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[0])[i
];
2808 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2809 "region %d landing pad", i
);
2810 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2813 call_site_base
+= n
;
2816 /* Switch to the section that should be used for exception tables. */
2819 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2823 if (exception_section
)
2824 s
= exception_section
;
2829 if (EH_TABLES_CAN_BE_READ_ONLY
)
2832 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2833 flags
= ((! flag_pic
2834 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2835 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2836 ? 0 : SECTION_WRITE
);
2839 flags
= SECTION_WRITE
;
2841 /* Compute the section and cache it into exception_section,
2842 unless it depends on the function name. */
2843 if (targetm_common
.have_named_sections
)
2845 #ifdef HAVE_LD_EH_GC_SECTIONS
2846 if (flag_function_sections
2847 || (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
))
2849 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2850 /* The EH table must match the code section, so only mark
2851 it linkonce if we have COMDAT groups to tie them together. */
2852 if (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
)
2853 flags
|= SECTION_LINKONCE
;
2854 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2855 s
= get_section (section_name
, flags
, current_function_decl
);
2856 free (section_name
);
2861 = s
= get_section (".gcc_except_table", flags
, NULL
);
2865 = s
= flags
== SECTION_WRITE
? data_section
: readonly_data_section
;
2868 switch_to_section (s
);
2872 /* Output a reference from an exception table to the type_info object TYPE.
2873 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2877 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2880 bool is_public
= true;
2882 if (type
== NULL_TREE
)
2886 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2887 runtime types so TYPE should already be a runtime type
2888 reference. When pass_ipa_free_lang data is made a default
2889 pass, we can then remove the call to lookup_type_for_runtime
2892 type
= lookup_type_for_runtime (type
);
2894 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2896 /* Let cgraph know that the rtti decl is used. Not all of the
2897 paths below go through assemble_integer, which would take
2898 care of this for us. */
2900 if (TREE_CODE (type
) == ADDR_EXPR
)
2902 type
= TREE_OPERAND (type
, 0);
2903 if (TREE_CODE (type
) == VAR_DECL
)
2904 is_public
= TREE_PUBLIC (type
);
2907 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2910 /* Allow the target to override the type table entry format. */
2911 if (targetm
.asm_out
.ttype (value
))
2914 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2915 assemble_integer (value
, tt_format_size
,
2916 tt_format_size
* BITS_PER_UNIT
, 1);
2918 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2922 output_one_function_exception_table (int section
)
2924 int tt_format
, cs_format
, lp_format
, i
;
2925 #ifdef HAVE_AS_LEB128
2926 char ttype_label
[32];
2927 char cs_after_size_label
[32];
2928 char cs_end_label
[32];
2933 int tt_format_size
= 0;
2935 have_tt_data
= (vec_safe_length (cfun
->eh
->ttype_data
)
2936 || (targetm
.arm_eabi_unwinder
2937 ? vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
)
2938 : vec_safe_length (cfun
->eh
->ehspec_data
.other
)));
2940 /* Indicate the format of the @TType entries. */
2942 tt_format
= DW_EH_PE_omit
;
2945 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2946 #ifdef HAVE_AS_LEB128
2947 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2948 section
? "LLSDATTC" : "LLSDATT",
2949 current_function_funcdef_no
);
2951 tt_format_size
= size_of_encoded_value (tt_format
);
2953 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2956 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2957 current_function_funcdef_no
);
2959 /* The LSDA header. */
2961 /* Indicate the format of the landing pad start pointer. An omitted
2962 field implies @LPStart == @Start. */
2963 /* Currently we always put @LPStart == @Start. This field would
2964 be most useful in moving the landing pads completely out of
2965 line to another section, but it could also be used to minimize
2966 the size of uleb128 landing pad offsets. */
2967 lp_format
= DW_EH_PE_omit
;
2968 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
2969 eh_data_format_name (lp_format
));
2971 /* @LPStart pointer would go here. */
2973 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
2974 eh_data_format_name (tt_format
));
2976 #ifndef HAVE_AS_LEB128
2977 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2978 call_site_len
= sjlj_size_of_call_site_table ();
2980 call_site_len
= dw2_size_of_call_site_table (section
);
2983 /* A pc-relative 4-byte displacement to the @TType data. */
2986 #ifdef HAVE_AS_LEB128
2987 char ttype_after_disp_label
[32];
2988 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
2989 section
? "LLSDATTDC" : "LLSDATTD",
2990 current_function_funcdef_no
);
2991 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
2992 "@TType base offset");
2993 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
2995 /* Ug. Alignment queers things. */
2996 unsigned int before_disp
, after_disp
, last_disp
, disp
;
2998 before_disp
= 1 + 1;
2999 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3001 + vec_safe_length (crtl
->eh
.action_record_data
)
3002 + (vec_safe_length (cfun
->eh
->ttype_data
)
3008 unsigned int disp_size
, pad
;
3011 disp_size
= size_of_uleb128 (disp
);
3012 pad
= before_disp
+ disp_size
+ after_disp
;
3013 if (pad
% tt_format_size
)
3014 pad
= tt_format_size
- (pad
% tt_format_size
);
3017 disp
= after_disp
+ pad
;
3019 while (disp
!= last_disp
);
3021 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3025 /* Indicate the format of the call-site offsets. */
3026 #ifdef HAVE_AS_LEB128
3027 cs_format
= DW_EH_PE_uleb128
;
3029 cs_format
= DW_EH_PE_udata4
;
3031 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3032 eh_data_format_name (cs_format
));
3034 #ifdef HAVE_AS_LEB128
3035 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3036 section
? "LLSDACSBC" : "LLSDACSB",
3037 current_function_funcdef_no
);
3038 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3039 section
? "LLSDACSEC" : "LLSDACSE",
3040 current_function_funcdef_no
);
3041 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3042 "Call-site table length");
3043 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3044 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3045 sjlj_output_call_site_table ();
3047 dw2_output_call_site_table (cs_format
, section
);
3048 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3050 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3051 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3052 sjlj_output_call_site_table ();
3054 dw2_output_call_site_table (cs_format
, section
);
3057 /* ??? Decode and interpret the data for flag_debug_asm. */
3060 FOR_EACH_VEC_ELT (*crtl
->eh
.action_record_data
, i
, uc
)
3061 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3065 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3067 i
= vec_safe_length (cfun
->eh
->ttype_data
);
3070 tree type
= (*cfun
->eh
->ttype_data
)[i
];
3071 output_ttype (type
, tt_format
, tt_format_size
);
3074 #ifdef HAVE_AS_LEB128
3076 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3079 /* ??? Decode and interpret the data for flag_debug_asm. */
3080 if (targetm
.arm_eabi_unwinder
)
3084 vec_safe_iterate (cfun
->eh
->ehspec_data
.arm_eabi
, i
, &type
); ++i
)
3085 output_ttype (type
, tt_format
, tt_format_size
);
3091 vec_safe_iterate (cfun
->eh
->ehspec_data
.other
, i
, &uc
); ++i
)
3092 dw2_asm_output_data (1, uc
,
3093 i
? NULL
: "Exception specification table");
3098 output_function_exception_table (const char *fnname
)
3100 rtx personality
= get_personality_function (current_function_decl
);
3102 /* Not all functions need anything. */
3103 if (! crtl
->uses_eh_lsda
)
3108 assemble_external_libcall (personality
);
3110 if (targetm
.asm_out
.emit_except_personality
)
3111 targetm
.asm_out
.emit_except_personality (personality
);
3114 switch_to_exception_section (fnname
);
3116 /* If the target wants a label to begin the table, emit it here. */
3117 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3119 output_one_function_exception_table (0);
3120 if (crtl
->eh
.call_site_record_v
[1])
3121 output_one_function_exception_table (1);
3123 switch_to_section (current_function_section ());
3127 set_eh_throw_stmt_table (function
*fun
, hash_map
<gimple
*, int> *table
)
3129 fun
->eh
->throw_stmt_table
= table
;
3132 hash_map
<gimple
*, int> *
3133 get_eh_throw_stmt_table (struct function
*fun
)
3135 return fun
->eh
->throw_stmt_table
;
3138 /* Determine if the function needs an EH personality function. */
3140 enum eh_personality_kind
3141 function_needs_eh_personality (struct function
*fn
)
3143 enum eh_personality_kind kind
= eh_personality_none
;
3146 FOR_ALL_EH_REGION_FN (i
, fn
)
3151 /* Can do with any personality including the generic C one. */
3152 kind
= eh_personality_any
;
3156 case ERT_ALLOWED_EXCEPTIONS
:
3157 /* Always needs a EH personality function. The generic C
3158 personality doesn't handle these even for empty type lists. */
3159 return eh_personality_lang
;
3161 case ERT_MUST_NOT_THROW
:
3162 /* Always needs a EH personality function. The language may specify
3163 what abort routine that must be used, e.g. std::terminate. */
3164 return eh_personality_lang
;
3171 /* Dump EH information to OUT. */
3174 dump_eh_tree (FILE * out
, struct function
*fun
)
3178 static const char *const type_name
[] = {
3179 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3182 i
= fun
->eh
->region_tree
;
3186 fprintf (out
, "Eh tree:\n");
3189 fprintf (out
, " %*s %i %s", depth
* 2, "",
3190 i
->index
, type_name
[(int) i
->type
]);
3192 if (i
->landing_pads
)
3196 fprintf (out
, " land:");
3197 if (current_ir_type () == IR_GIMPLE
)
3199 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3201 fprintf (out
, "{%i,", lp
->index
);
3202 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3210 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3212 fprintf (out
, "{%i,", lp
->index
);
3213 if (lp
->landing_pad
)
3214 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3215 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3217 fprintf (out
, "(nil),");
3218 if (lp
->post_landing_pad
)
3220 rtx_insn
*lab
= label_rtx (lp
->post_landing_pad
);
3221 fprintf (out
, "%i%s}", INSN_UID (lab
),
3222 NOTE_P (lab
) ? "(del)" : "");
3225 fprintf (out
, "(nil)}");
3235 case ERT_MUST_NOT_THROW
:
3241 fprintf (out
, " catch:");
3242 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3247 fprintf (out
, "lab:");
3248 print_generic_expr (out
, c
->label
, 0);
3251 print_generic_expr (out
, c
->type_list
, 0);
3259 case ERT_ALLOWED_EXCEPTIONS
:
3260 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3261 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3266 /* If there are sub-regions, process them. */
3268 i
= i
->inner
, depth
++;
3269 /* If there are peers, process them. */
3270 else if (i
->next_peer
)
3272 /* Otherwise, step back up the tree to the next peer. */
3282 while (i
->next_peer
== NULL
);
3288 /* Dump the EH tree for FN on stderr. */
3291 debug_eh_tree (struct function
*fn
)
3293 dump_eh_tree (stderr
, fn
);
3296 /* Verify invariants on EH datastructures. */
3299 verify_eh_tree (struct function
*fun
)
3302 int nvisited_lp
, nvisited_r
;
3303 int count_lp
, count_r
, depth
, i
;
3307 if (!fun
->eh
->region_tree
)
3311 for (i
= 1; vec_safe_iterate (fun
->eh
->region_array
, i
, &r
); ++i
)
3318 error ("region_array is corrupted for region %i", r
->index
);
3324 for (i
= 1; vec_safe_iterate (fun
->eh
->lp_array
, i
, &lp
); ++i
)
3331 error ("lp_array is corrupted for lp %i", lp
->index
);
3336 depth
= nvisited_lp
= nvisited_r
= 0;
3338 r
= fun
->eh
->region_tree
;
3341 if ((*fun
->eh
->region_array
)[r
->index
] != r
)
3343 error ("region_array is corrupted for region %i", r
->index
);
3346 if (r
->outer
!= outer
)
3348 error ("outer block of region %i is wrong", r
->index
);
3353 error ("negative nesting depth of region %i", r
->index
);
3358 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3360 if ((*fun
->eh
->lp_array
)[lp
->index
] != lp
)
3362 error ("lp_array is corrupted for lp %i", lp
->index
);
3365 if (lp
->region
!= r
)
3367 error ("region of lp %i is wrong", lp
->index
);
3374 outer
= r
, r
= r
->inner
, depth
++;
3375 else if (r
->next_peer
)
3387 while (r
->next_peer
== NULL
);
3394 error ("tree list ends on depth %i", depth
);
3397 if (count_r
!= nvisited_r
)
3399 error ("region_array does not match region_tree");
3402 if (count_lp
!= nvisited_lp
)
3404 error ("lp_array does not match region_tree");
3410 dump_eh_tree (stderr
, fun
);
3411 internal_error ("verify_eh_tree failed");
3415 #include "gt-except.h"