1 /* Implements exception handling.
2 Copyright (C) 1989-2014 Free Software Foundation, Inc.
3 Contributed by Mike Stump <mrs@cygnus.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* An exception is an event that can be "thrown" from within a
23 function. This event can then be "caught" by the callers of
26 The representation of exceptions changes several times during
27 the compilation process:
29 In the beginning, in the front end, we have the GENERIC trees
30 TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
31 CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
33 During initial gimplification (gimplify.c) these are lowered
34 to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
35 The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
36 into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
39 During pass_lower_eh (tree-eh.c) we record the nested structure
40 of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
41 We expand the eh_protect_cleanup_actions langhook into MUST_NOT_THROW
42 regions at this time. We can then flatten the statements within
43 the TRY nodes to straight-line code. Statements that had been within
44 TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,
45 so that we may remember what action is supposed to be taken if
46 a given statement does throw. During this lowering process,
47 we create an EH_LANDING_PAD node for each EH_REGION that has
48 some code within the function that needs to be executed if a
49 throw does happen. We also create RESX statements that are
50 used to transfer control from an inner EH_REGION to an outer
51 EH_REGION. We also create EH_DISPATCH statements as placeholders
52 for a runtime type comparison that should be made in order to
53 select the action to perform among different CATCH and EH_FILTER
56 During pass_lower_eh_dispatch (tree-eh.c), which is run after
57 all inlining is complete, we are able to run assign_filter_values,
58 which allows us to map the set of types manipulated by all of the
59 CATCH and EH_FILTER regions to a set of integers. This set of integers
60 will be how the exception runtime communicates with the code generated
61 within the function. We then expand the GIMPLE_EH_DISPATCH statements
62 to a switch or conditional branches that use the argument provided by
63 the runtime (__builtin_eh_filter) and the set of integers we computed
64 in assign_filter_values.
66 During pass_lower_resx (tree-eh.c), which is run near the end
67 of optimization, we expand RESX statements. If the eh region
68 that is outer to the RESX statement is a MUST_NOT_THROW, then
69 the RESX expands to some form of abort statement. If the eh
70 region that is outer to the RESX statement is within the current
71 function, then the RESX expands to a bookkeeping call
72 (__builtin_eh_copy_values) and a goto. Otherwise, the next
73 handler for the exception must be within a function somewhere
74 up the call chain, so we call back into the exception runtime
75 (__builtin_unwind_resume).
77 During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
78 that create an rtl to eh_region mapping that corresponds to the
79 gimple to eh_region mapping that had been recorded in the
82 Then, via finish_eh_generation, we generate the real landing pads
83 to which the runtime will actually transfer control. These new
84 landing pads perform whatever bookkeeping is needed by the target
85 backend in order to resume execution within the current function.
86 Each of these new landing pads falls through into the post_landing_pad
87 label which had been used within the CFG up to this point. All
88 exception edges within the CFG are redirected to the new landing pads.
89 If the target uses setjmp to implement exceptions, the various extra
90 calls into the runtime to register and unregister the current stack
91 frame are emitted at this time.
93 During pass_convert_to_eh_region_ranges (except.c), we transform
94 the REG_EH_REGION notes attached to individual insns into
95 non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG
96 and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the
97 same associated action within the exception region tree, meaning
98 that (1) the exception is caught by the same landing pad within the
99 current function, (2) the exception is blocked by the runtime with
100 a MUST_NOT_THROW region, or (3) the exception is not handled at all
101 within the current function.
103 Finally, during assembly generation, we call
104 output_function_exception_table (except.c) to emit the tables with
105 which the exception runtime can determine if a given stack frame
106 handles a given exception, and if so what filter value to provide
107 to the function when the non-local control transfer is effected.
108 If the target uses dwarf2 unwinding to implement exceptions, then
109 output_call_frame_info (dwarf2out.c) emits the required unwind data. */
114 #include "coretypes.h"
118 #include "stringpool.h"
119 #include "stor-layout.h"
121 #include "function.h"
123 #include "libfuncs.h"
124 #include "insn-config.h"
126 #include "hard-reg-set.h"
128 #include "dwarf2asm.h"
129 #include "dwarf2out.h"
132 #include "hash-table.h"
136 #include "common/common-target.h"
137 #include "langhooks.h"
139 #include "diagnostic.h"
140 #include "tree-pretty-print.h"
141 #include "tree-pass.h"
142 #include "pointer-set.h"
144 #include "builtins.h"
146 /* Provide defaults for stuff that may not be defined when using
148 #ifndef EH_RETURN_DATA_REGNO
149 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
152 static GTY(()) int call_site_base
;
153 static GTY ((param_is (union tree_node
)))
154 htab_t type_to_runtime_map
;
156 /* Describe the SjLj_Function_Context structure. */
157 static GTY(()) tree sjlj_fc_type_node
;
158 static int sjlj_fc_call_site_ofs
;
159 static int sjlj_fc_data_ofs
;
160 static int sjlj_fc_personality_ofs
;
161 static int sjlj_fc_lsda_ofs
;
162 static int sjlj_fc_jbuf_ofs
;
165 struct GTY(()) call_site_record_d
171 /* In the following structure and associated functions,
172 we represent entries in the action table as 1-based indices.
175 0: null action record, non-null landing pad; implies cleanups
176 -1: null action record, null landing pad; implies no action
177 -2: no call-site entry; implies must_not_throw
178 -3: we have yet to process outer regions
180 Further, no special cases apply to the "next" field of the record.
181 For next, 0 means end of list. */
190 /* Hashtable helpers. */
192 struct action_record_hasher
: typed_free_remove
<action_record
>
194 typedef action_record value_type
;
195 typedef action_record compare_type
;
196 static inline hashval_t
hash (const value_type
*);
197 static inline bool equal (const value_type
*, const compare_type
*);
201 action_record_hasher::hash (const value_type
*entry
)
203 return entry
->next
* 1009 + entry
->filter
;
207 action_record_hasher::equal (const value_type
*entry
, const compare_type
*data
)
209 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
212 typedef hash_table
<action_record_hasher
> action_hash_type
;
214 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
217 static int t2r_eq (const void *, const void *);
218 static hashval_t
t2r_hash (const void *);
220 static void dw2_build_landing_pads (void);
222 static int collect_one_action_chain (action_hash_type
*, eh_region
);
223 static int add_call_site (rtx
, int, int);
225 static void push_uleb128 (vec
<uchar
, va_gc
> **, unsigned int);
226 static void push_sleb128 (vec
<uchar
, va_gc
> **, int);
227 #ifndef HAVE_AS_LEB128
228 static int dw2_size_of_call_site_table (int);
229 static int sjlj_size_of_call_site_table (void);
231 static void dw2_output_call_site_table (int, int);
232 static void sjlj_output_call_site_table (void);
238 if (! flag_exceptions
)
241 type_to_runtime_map
= htab_create_ggc (31, t2r_hash
, t2r_eq
, NULL
);
243 /* Create the SjLj_Function_Context structure. This should match
244 the definition in unwind-sjlj.c. */
245 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
247 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
249 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
251 f_prev
= build_decl (BUILTINS_LOCATION
,
252 FIELD_DECL
, get_identifier ("__prev"),
253 build_pointer_type (sjlj_fc_type_node
));
254 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
256 f_cs
= build_decl (BUILTINS_LOCATION
,
257 FIELD_DECL
, get_identifier ("__call_site"),
259 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
261 tmp
= build_index_type (size_int (4 - 1));
262 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
263 (targetm
.unwind_word_mode (), 1),
265 f_data
= build_decl (BUILTINS_LOCATION
,
266 FIELD_DECL
, get_identifier ("__data"), tmp
);
267 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
269 f_per
= build_decl (BUILTINS_LOCATION
,
270 FIELD_DECL
, get_identifier ("__personality"),
272 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
274 f_lsda
= build_decl (BUILTINS_LOCATION
,
275 FIELD_DECL
, get_identifier ("__lsda"),
277 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
279 #ifdef DONT_USE_BUILTIN_SETJMP
281 tmp
= size_int (JMP_BUF_SIZE
- 1);
283 /* Should be large enough for most systems, if it is not,
284 JMP_BUF_SIZE should be defined with the proper value. It will
285 also tend to be larger than necessary for most systems, a more
286 optimal port will define JMP_BUF_SIZE. */
287 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
290 /* Compute a minimally sized jump buffer. We need room to store at
291 least 3 pointers - stack pointer, frame pointer and return address.
292 Plus for some targets we need room for an extra pointer - in the
293 case of MIPS this is the global pointer. This makes a total of four
294 pointers, but to be safe we actually allocate room for 5.
296 If pointers are smaller than words then we allocate enough room for
297 5 words, just in case the backend needs this much room. For more
298 discussion on this issue see:
299 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
300 if (POINTER_SIZE
> BITS_PER_WORD
)
301 tmp
= size_int (5 - 1);
303 tmp
= size_int ((5 * BITS_PER_WORD
/ POINTER_SIZE
) - 1);
306 tmp
= build_index_type (tmp
);
307 tmp
= build_array_type (ptr_type_node
, tmp
);
308 f_jbuf
= build_decl (BUILTINS_LOCATION
,
309 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
310 #ifdef DONT_USE_BUILTIN_SETJMP
311 /* We don't know what the alignment requirements of the
312 runtime's jmp_buf has. Overestimate. */
313 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
314 DECL_USER_ALIGN (f_jbuf
) = 1;
316 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
318 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
319 TREE_CHAIN (f_prev
) = f_cs
;
320 TREE_CHAIN (f_cs
) = f_data
;
321 TREE_CHAIN (f_data
) = f_per
;
322 TREE_CHAIN (f_per
) = f_lsda
;
323 TREE_CHAIN (f_lsda
) = f_jbuf
;
325 layout_type (sjlj_fc_type_node
);
327 /* Cache the interesting field offsets so that we have
328 easy access from rtl. */
329 sjlj_fc_call_site_ofs
330 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs
))
331 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs
)) / BITS_PER_UNIT
);
333 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data
))
334 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data
)) / BITS_PER_UNIT
);
335 sjlj_fc_personality_ofs
336 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per
))
337 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per
)) / BITS_PER_UNIT
);
339 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda
))
340 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda
)) / BITS_PER_UNIT
);
342 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf
))
343 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf
)) / BITS_PER_UNIT
);
348 init_eh_for_function (void)
350 cfun
->eh
= ggc_cleared_alloc
<eh_status
> ();
352 /* Make sure zero'th entries are used. */
353 vec_safe_push (cfun
->eh
->region_array
, (eh_region
)0);
354 vec_safe_push (cfun
->eh
->lp_array
, (eh_landing_pad
)0);
357 /* Routines to generate the exception tree somewhat directly.
358 These are used from tree-eh.c when processing exception related
359 nodes during tree optimization. */
362 gen_eh_region (enum eh_region_type type
, eh_region outer
)
366 /* Insert a new blank region as a leaf in the tree. */
367 new_eh
= ggc_cleared_alloc
<eh_region_d
> ();
369 new_eh
->outer
= outer
;
372 new_eh
->next_peer
= outer
->inner
;
373 outer
->inner
= new_eh
;
377 new_eh
->next_peer
= cfun
->eh
->region_tree
;
378 cfun
->eh
->region_tree
= new_eh
;
381 new_eh
->index
= vec_safe_length (cfun
->eh
->region_array
);
382 vec_safe_push (cfun
->eh
->region_array
, new_eh
);
384 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
385 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
386 new_eh
->use_cxa_end_cleanup
= true;
392 gen_eh_region_cleanup (eh_region outer
)
394 return gen_eh_region (ERT_CLEANUP
, outer
);
398 gen_eh_region_try (eh_region outer
)
400 return gen_eh_region (ERT_TRY
, outer
);
404 gen_eh_region_catch (eh_region t
, tree type_or_list
)
407 tree type_list
, type_node
;
409 gcc_assert (t
->type
== ERT_TRY
);
411 /* Ensure to always end up with a type list to normalize further
412 processing, then register each type against the runtime types map. */
413 type_list
= type_or_list
;
416 if (TREE_CODE (type_or_list
) != TREE_LIST
)
417 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
419 type_node
= type_list
;
420 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
421 add_type_for_runtime (TREE_VALUE (type_node
));
424 c
= ggc_cleared_alloc
<eh_catch_d
> ();
425 c
->type_list
= type_list
;
426 l
= t
->u
.eh_try
.last_catch
;
431 t
->u
.eh_try
.first_catch
= c
;
432 t
->u
.eh_try
.last_catch
= c
;
438 gen_eh_region_allowed (eh_region outer
, tree allowed
)
440 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
441 region
->u
.allowed
.type_list
= allowed
;
443 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
444 add_type_for_runtime (TREE_VALUE (allowed
));
450 gen_eh_region_must_not_throw (eh_region outer
)
452 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
456 gen_eh_landing_pad (eh_region region
)
458 eh_landing_pad lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
460 lp
->next_lp
= region
->landing_pads
;
462 lp
->index
= vec_safe_length (cfun
->eh
->lp_array
);
463 region
->landing_pads
= lp
;
465 vec_safe_push (cfun
->eh
->lp_array
, lp
);
471 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
473 return (*ifun
->eh
->region_array
)[i
];
477 get_eh_region_from_number (int i
)
479 return get_eh_region_from_number_fn (cfun
, i
);
483 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
485 return (*ifun
->eh
->lp_array
)[i
];
489 get_eh_landing_pad_from_number (int i
)
491 return get_eh_landing_pad_from_number_fn (cfun
, i
);
495 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
498 return (*ifun
->eh
->region_array
)[-i
];
504 lp
= (*ifun
->eh
->lp_array
)[i
];
510 get_eh_region_from_lp_number (int i
)
512 return get_eh_region_from_lp_number_fn (cfun
, i
);
515 /* Returns true if the current function has exception handling regions. */
518 current_function_has_exception_handlers (void)
520 return cfun
->eh
->region_tree
!= NULL
;
523 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
524 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
526 struct duplicate_eh_regions_data
528 duplicate_eh_regions_map label_map
;
529 void *label_map_data
;
530 hash_map
<void *, void *> *eh_map
;
534 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
535 eh_region old_r
, eh_region outer
)
537 eh_landing_pad old_lp
, new_lp
;
540 new_r
= gen_eh_region (old_r
->type
, outer
);
541 gcc_assert (!data
->eh_map
->put (old_r
, new_r
));
551 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
553 /* We should be doing all our region duplication before and
554 during inlining, which is before filter lists are created. */
555 gcc_assert (oc
->filter_list
== NULL
);
556 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
557 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
562 case ERT_ALLOWED_EXCEPTIONS
:
563 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
564 if (old_r
->u
.allowed
.label
)
565 new_r
->u
.allowed
.label
566 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
568 new_r
->u
.allowed
.label
= NULL_TREE
;
571 case ERT_MUST_NOT_THROW
:
572 new_r
->u
.must_not_throw
.failure_loc
=
573 LOCATION_LOCUS (old_r
->u
.must_not_throw
.failure_loc
);
574 new_r
->u
.must_not_throw
.failure_decl
=
575 old_r
->u
.must_not_throw
.failure_decl
;
579 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
581 /* Don't bother copying unused landing pads. */
582 if (old_lp
->post_landing_pad
== NULL
)
585 new_lp
= gen_eh_landing_pad (new_r
);
586 gcc_assert (!data
->eh_map
->put (old_lp
, new_lp
));
588 new_lp
->post_landing_pad
589 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
590 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
593 /* Make sure to preserve the original use of __cxa_end_cleanup. */
594 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
596 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
597 duplicate_eh_regions_1 (data
, old_r
, new_r
);
600 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
601 the current function and root the tree below OUTER_REGION.
602 The special case of COPY_REGION of NULL means all regions.
603 Remap labels using MAP/MAP_DATA callback. Return a pointer map
604 that allows the caller to remap uses of both EH regions and
607 hash_map
<void *, void *> *
608 duplicate_eh_regions (struct function
*ifun
,
609 eh_region copy_region
, int outer_lp
,
610 duplicate_eh_regions_map map
, void *map_data
)
612 struct duplicate_eh_regions_data data
;
613 eh_region outer_region
;
615 #ifdef ENABLE_CHECKING
616 verify_eh_tree (ifun
);
619 data
.label_map
= map
;
620 data
.label_map_data
= map_data
;
621 data
.eh_map
= new hash_map
<void *, void *>;
623 outer_region
= get_eh_region_from_lp_number (outer_lp
);
625 /* Copy all the regions in the subtree. */
627 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
631 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
632 duplicate_eh_regions_1 (&data
, r
, outer_region
);
635 #ifdef ENABLE_CHECKING
636 verify_eh_tree (cfun
);
642 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
645 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
650 gcc_assert (ifun
->eh
->region_array
);
651 gcc_assert (ifun
->eh
->region_tree
);
653 b_outer
= sbitmap_alloc (ifun
->eh
->region_array
->length ());
654 bitmap_clear (b_outer
);
658 bitmap_set_bit (b_outer
, region_b
->index
);
659 region_b
= region_b
->outer
;
665 if (bitmap_bit_p (b_outer
, region_a
->index
))
667 region_a
= region_a
->outer
;
671 sbitmap_free (b_outer
);
676 t2r_eq (const void *pentry
, const void *pdata
)
678 const_tree
const entry
= (const_tree
) pentry
;
679 const_tree
const data
= (const_tree
) pdata
;
681 return TREE_PURPOSE (entry
) == data
;
685 t2r_hash (const void *pentry
)
687 const_tree
const entry
= (const_tree
) pentry
;
688 return TREE_HASH (TREE_PURPOSE (entry
));
692 add_type_for_runtime (tree type
)
696 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
697 if (TREE_CODE (type
) == NOP_EXPR
)
700 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
701 TREE_HASH (type
), INSERT
);
704 tree runtime
= lang_hooks
.eh_runtime_type (type
);
705 *slot
= tree_cons (type
, runtime
, NULL_TREE
);
710 lookup_type_for_runtime (tree type
)
714 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
715 if (TREE_CODE (type
) == NOP_EXPR
)
718 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
719 TREE_HASH (type
), NO_INSERT
);
721 /* We should have always inserted the data earlier. */
722 return TREE_VALUE (*slot
);
726 /* Represent an entry in @TTypes for either catch actions
727 or exception filter actions. */
728 struct ttypes_filter
{
733 /* Helper for ttypes_filter hashing. */
735 struct ttypes_filter_hasher
: typed_free_remove
<ttypes_filter
>
737 typedef ttypes_filter value_type
;
738 typedef tree_node compare_type
;
739 static inline hashval_t
hash (const value_type
*);
740 static inline bool equal (const value_type
*, const compare_type
*);
743 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
744 (a tree) for a @TTypes type node we are thinking about adding. */
747 ttypes_filter_hasher::equal (const value_type
*entry
, const compare_type
*data
)
749 return entry
->t
== data
;
753 ttypes_filter_hasher::hash (const value_type
*entry
)
755 return TREE_HASH (entry
->t
);
758 typedef hash_table
<ttypes_filter_hasher
> ttypes_hash_type
;
761 /* Helper for ehspec hashing. */
763 struct ehspec_hasher
: typed_free_remove
<ttypes_filter
>
765 typedef ttypes_filter value_type
;
766 typedef ttypes_filter compare_type
;
767 static inline hashval_t
hash (const value_type
*);
768 static inline bool equal (const value_type
*, const compare_type
*);
771 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
772 exception specification list we are thinking about adding. */
773 /* ??? Currently we use the type lists in the order given. Someone
774 should put these in some canonical order. */
777 ehspec_hasher::equal (const value_type
*entry
, const compare_type
*data
)
779 return type_list_equal (entry
->t
, data
->t
);
782 /* Hash function for exception specification lists. */
785 ehspec_hasher::hash (const value_type
*entry
)
790 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
791 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
795 typedef hash_table
<ehspec_hasher
> ehspec_hash_type
;
798 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
799 to speed up the search. Return the filter value to be used. */
802 add_ttypes_entry (ttypes_hash_type
*ttypes_hash
, tree type
)
804 struct ttypes_filter
**slot
, *n
;
806 slot
= ttypes_hash
->find_slot_with_hash (type
, (hashval_t
) TREE_HASH (type
),
809 if ((n
= *slot
) == NULL
)
811 /* Filter value is a 1 based table index. */
813 n
= XNEW (struct ttypes_filter
);
815 n
->filter
= vec_safe_length (cfun
->eh
->ttype_data
) + 1;
818 vec_safe_push (cfun
->eh
->ttype_data
, type
);
824 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
825 to speed up the search. Return the filter value to be used. */
828 add_ehspec_entry (ehspec_hash_type
*ehspec_hash
, ttypes_hash_type
*ttypes_hash
,
831 struct ttypes_filter
**slot
, *n
;
832 struct ttypes_filter dummy
;
835 slot
= ehspec_hash
->find_slot (&dummy
, INSERT
);
837 if ((n
= *slot
) == NULL
)
841 if (targetm
.arm_eabi_unwinder
)
842 len
= vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
);
844 len
= vec_safe_length (cfun
->eh
->ehspec_data
.other
);
846 /* Filter value is a -1 based byte index into a uleb128 buffer. */
848 n
= XNEW (struct ttypes_filter
);
850 n
->filter
= -(len
+ 1);
853 /* Generate a 0 terminated list of filter values. */
854 for (; list
; list
= TREE_CHAIN (list
))
856 if (targetm
.arm_eabi_unwinder
)
857 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, TREE_VALUE (list
));
860 /* Look up each type in the list and encode its filter
861 value as a uleb128. */
862 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
863 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
866 if (targetm
.arm_eabi_unwinder
)
867 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
869 vec_safe_push (cfun
->eh
->ehspec_data
.other
, (uchar
)0);
875 /* Generate the action filter values to be used for CATCH and
876 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
877 we use lots of landing pads, and so every type or list can share
878 the same filter value, which saves table space. */
881 assign_filter_values (void)
887 vec_alloc (cfun
->eh
->ttype_data
, 16);
888 if (targetm
.arm_eabi_unwinder
)
889 vec_alloc (cfun
->eh
->ehspec_data
.arm_eabi
, 64);
891 vec_alloc (cfun
->eh
->ehspec_data
.other
, 64);
893 ehspec_hash_type
ehspec (31);
894 ttypes_hash_type
ttypes (31);
896 for (i
= 1; vec_safe_iterate (cfun
->eh
->region_array
, i
, &r
); ++i
)
904 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
906 /* Whatever type_list is (NULL or true list), we build a list
907 of filters for the region. */
908 c
->filter_list
= NULL_TREE
;
910 if (c
->type_list
!= NULL
)
912 /* Get a filter value for each of the types caught and store
913 them in the region's dedicated list. */
914 tree tp_node
= c
->type_list
;
916 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
919 = add_ttypes_entry (&ttypes
, TREE_VALUE (tp_node
));
920 tree flt_node
= build_int_cst (integer_type_node
, flt
);
923 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
928 /* Get a filter value for the NULL list also since it
929 will need an action record anyway. */
930 int flt
= add_ttypes_entry (&ttypes
, NULL
);
931 tree flt_node
= build_int_cst (integer_type_node
, flt
);
934 = tree_cons (NULL_TREE
, flt_node
, NULL
);
939 case ERT_ALLOWED_EXCEPTIONS
:
941 = add_ehspec_entry (&ehspec
, &ttypes
, r
->u
.allowed
.type_list
);
950 /* Emit SEQ into basic block just before INSN (that is assumed to be
951 first instruction of some existing BB and return the newly
954 emit_to_new_bb_before (rtx seq
, rtx insn
)
961 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
962 call), we don't want it to go into newly created landing pad or other EH
964 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
965 if (e
->flags
& EDGE_FALLTHRU
)
966 force_nonfallthru (e
);
969 last
= emit_insn_before (seq
, insn
);
970 if (BARRIER_P (last
))
971 last
= PREV_INSN (last
);
972 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
973 update_bb_for_insn (bb
);
974 bb
->flags
|= BB_SUPERBLOCK
;
978 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
979 at the rtl level. Emit the code required by the target at a landing
980 pad for the given region. */
983 expand_dw2_landing_pad_for_region (eh_region region
)
985 #ifdef HAVE_exception_receiver
986 if (HAVE_exception_receiver
)
987 emit_insn (gen_exception_receiver ());
990 #ifdef HAVE_nonlocal_goto_receiver
991 if (HAVE_nonlocal_goto_receiver
)
992 emit_insn (gen_nonlocal_goto_receiver ());
997 if (region
->exc_ptr_reg
)
998 emit_move_insn (region
->exc_ptr_reg
,
999 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
1000 if (region
->filter_reg
)
1001 emit_move_insn (region
->filter_reg
,
1002 gen_rtx_REG (targetm
.eh_return_filter_mode (),
1003 EH_RETURN_DATA_REGNO (1)));
1006 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
1009 dw2_build_landing_pads (void)
1013 int e_flags
= EDGE_FALLTHRU
;
1015 /* If we're going to partition blocks, we need to be able to add
1016 new landing pads later, which means that we need to hold on to
1017 the post-landing-pad block. Prevent it from being merged away.
1018 We'll remove this bit after partitioning. */
1019 if (flag_reorder_blocks_and_partition
)
1020 e_flags
|= EDGE_PRESERVE
;
1022 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1028 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
1033 lp
->landing_pad
= gen_label_rtx ();
1034 emit_label (lp
->landing_pad
);
1035 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
1037 expand_dw2_landing_pad_for_region (lp
->region
);
1042 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
1043 e
= make_edge (bb
, bb
->next_bb
, e_flags
);
1044 e
->count
= bb
->count
;
1045 e
->probability
= REG_BR_PROB_BASE
;
1048 struct loop
*loop
= bb
->next_bb
->loop_father
;
1049 /* If we created a pre-header block, add the new block to the
1050 outer loop, otherwise to the loop itself. */
1051 if (bb
->next_bb
== loop
->header
)
1052 add_bb_to_loop (bb
, loop_outer (loop
));
1054 add_bb_to_loop (bb
, loop
);
1060 static vec
<int> sjlj_lp_call_site_index
;
1062 /* Process all active landing pads. Assign each one a compact dispatch
1063 index, and a call-site index. */
1066 sjlj_assign_call_site_values (void)
1068 action_hash_type
ar_hash (31);
1072 vec_alloc (crtl
->eh
.action_record_data
, 64);
1076 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1077 if (lp
&& lp
->post_landing_pad
)
1079 int action
, call_site
;
1081 /* First: build the action table. */
1082 action
= collect_one_action_chain (&ar_hash
, lp
->region
);
1084 /* Next: assign call-site values. If dwarf2 terms, this would be
1085 the region number assigned by convert_to_eh_region_ranges, but
1086 handles no-action and must-not-throw differently. */
1087 /* Map must-not-throw to otherwise unused call-site index 0. */
1090 /* Map no-action to otherwise unused call-site index -1. */
1091 else if (action
== -1)
1093 /* Otherwise, look it up in the table. */
1095 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1096 sjlj_lp_call_site_index
[i
] = call_site
;
1104 /* Emit code to record the current call-site index before every
1105 insn that can throw. */
1108 sjlj_mark_call_sites (void)
1110 int last_call_site
= -2;
1113 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1121 /* Reset value tracking at extended basic block boundaries. */
1123 last_call_site
= -2;
1125 if (! INSN_P (insn
))
1128 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1132 this_call_site
= sjlj_lp_call_site_index
[lp
->index
];
1135 /* Calls (and trapping insns) without notes are outside any
1136 exception handling region in this function. Mark them as
1138 this_call_site
= -1;
1142 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1146 if (this_call_site
!= -1)
1147 crtl
->uses_eh_lsda
= 1;
1149 if (this_call_site
== last_call_site
)
1152 /* Don't separate a call from it's argument loads. */
1155 before
= find_first_parameter_load (insn
, NULL_RTX
);
1158 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1159 sjlj_fc_call_site_ofs
);
1160 emit_move_insn (mem
, gen_int_mode (this_call_site
, GET_MODE (mem
)));
1164 emit_insn_before (p
, before
);
1165 last_call_site
= this_call_site
;
1169 /* Construct the SjLj_Function_Context. */
1172 sjlj_emit_function_enter (rtx dispatch_label
)
1174 rtx fn_begin
, fc
, mem
, seq
;
1175 bool fn_begin_outside_block
;
1176 rtx personality
= get_personality_function (current_function_decl
);
1178 fc
= crtl
->eh
.sjlj_fc
;
1182 /* We're storing this libcall's address into memory instead of
1183 calling it directly. Thus, we must call assemble_external_libcall
1184 here, as we can not depend on emit_library_call to do it for us. */
1185 assemble_external_libcall (personality
);
1186 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1187 emit_move_insn (mem
, personality
);
1189 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1190 if (crtl
->uses_eh_lsda
)
1195 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1196 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1197 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1198 emit_move_insn (mem
, sym
);
1201 emit_move_insn (mem
, const0_rtx
);
1205 #ifdef DONT_USE_BUILTIN_SETJMP
1207 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1208 TYPE_MODE (integer_type_node
), 1,
1209 plus_constant (Pmode
, XEXP (fc
, 0),
1210 sjlj_fc_jbuf_ofs
), Pmode
);
1212 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1213 TYPE_MODE (integer_type_node
), 0,
1214 dispatch_label
, REG_BR_PROB_BASE
/ 100);
1216 expand_builtin_setjmp_setup (plus_constant (Pmode
, XEXP (fc
, 0),
1222 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1223 1, XEXP (fc
, 0), Pmode
);
1228 /* ??? Instead of doing this at the beginning of the function,
1229 do this in a block that is at loop level 0 and dominates all
1230 can_throw_internal instructions. */
1232 fn_begin_outside_block
= true;
1233 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1234 if (NOTE_P (fn_begin
))
1236 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1238 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1239 fn_begin_outside_block
= false;
1242 if (fn_begin_outside_block
)
1243 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1245 emit_insn_after (seq
, fn_begin
);
1248 /* Call back from expand_function_end to know where we should put
1249 the call to unwind_sjlj_unregister_libfunc if needed. */
1252 sjlj_emit_function_exit_after (rtx after
)
1254 crtl
->eh
.sjlj_exit_after
= after
;
1258 sjlj_emit_function_exit (void)
1264 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1265 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1270 /* ??? Really this can be done in any block at loop level 0 that
1271 post-dominates all can_throw_internal instructions. This is
1272 the last possible moment. */
1274 insn
= crtl
->eh
.sjlj_exit_after
;
1276 insn
= NEXT_INSN (insn
);
1278 emit_insn_after (seq
, insn
);
1282 sjlj_emit_dispatch_table (rtx dispatch_label
, int num_dispatch
)
1284 enum machine_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1285 enum machine_mode filter_mode
= targetm
.eh_return_filter_mode ();
1287 rtx mem
, seq
, fc
, before
, exc_ptr_reg
, filter_reg
;
1288 rtx first_reachable_label
;
1293 vec
<tree
> dispatch_labels
= vNULL
;
1295 fc
= crtl
->eh
.sjlj_fc
;
1299 emit_label (dispatch_label
);
1301 #ifndef DONT_USE_BUILTIN_SETJMP
1302 expand_builtin_setjmp_receiver (dispatch_label
);
1304 /* The caller of expand_builtin_setjmp_receiver is responsible for
1305 making sure that the label doesn't vanish. The only other caller
1306 is the expander for __builtin_setjmp_receiver, which places this
1307 label on the nonlocal_goto_label list. Since we're modeling these
1308 CFG edges more exactly, we can use the forced_labels list instead. */
1309 LABEL_PRESERVE_P (dispatch_label
) = 1;
1311 = gen_rtx_EXPR_LIST (VOIDmode
, dispatch_label
, forced_labels
);
1314 /* Load up exc_ptr and filter values from the function context. */
1315 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1316 if (unwind_word_mode
!= ptr_mode
)
1318 #ifdef POINTERS_EXTEND_UNSIGNED
1319 mem
= convert_memory_address (ptr_mode
, mem
);
1321 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1324 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1326 mem
= adjust_address (fc
, unwind_word_mode
,
1327 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1328 if (unwind_word_mode
!= filter_mode
)
1329 mem
= convert_to_mode (filter_mode
, mem
, 0);
1330 filter_reg
= force_reg (filter_mode
, mem
);
1332 /* Jump to one of the directly reachable regions. */
1335 first_reachable_label
= NULL
;
1337 /* If there's exactly one call site in the function, don't bother
1338 generating a switch statement. */
1339 if (num_dispatch
> 1)
1340 dispatch_labels
.create (num_dispatch
);
1342 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1343 if (lp
&& lp
->post_landing_pad
)
1349 lp
->landing_pad
= dispatch_label
;
1351 if (num_dispatch
> 1)
1353 tree t_label
, case_elt
, t
;
1355 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1356 t
= build_int_cst (integer_type_node
, disp_index
);
1357 case_elt
= build_case_label (t
, NULL
, t_label
);
1358 dispatch_labels
.quick_push (case_elt
);
1359 label
= label_rtx (t_label
);
1362 label
= gen_label_rtx ();
1364 if (disp_index
== 0)
1365 first_reachable_label
= label
;
1370 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1372 emit_move_insn (r
->filter_reg
, filter_reg
);
1374 seq2
= get_insns ();
1377 before
= label_rtx (lp
->post_landing_pad
);
1378 bb
= emit_to_new_bb_before (seq2
, before
);
1379 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1380 e
->count
= bb
->count
;
1381 e
->probability
= REG_BR_PROB_BASE
;
1384 struct loop
*loop
= bb
->next_bb
->loop_father
;
1385 /* If we created a pre-header block, add the new block to the
1386 outer loop, otherwise to the loop itself. */
1387 if (bb
->next_bb
== loop
->header
)
1388 add_bb_to_loop (bb
, loop_outer (loop
));
1390 add_bb_to_loop (bb
, loop
);
1391 /* ??? For multiple dispatches we will end up with edges
1392 from the loop tree root into this loop, making it a
1393 multiple-entry loop. Discard all affected loops. */
1394 if (num_dispatch
> 1)
1396 for (loop
= bb
->loop_father
;
1397 loop_outer (loop
); loop
= loop_outer (loop
))
1399 loop
->header
= NULL
;
1407 gcc_assert (disp_index
== num_dispatch
);
1409 if (num_dispatch
> 1)
1411 rtx disp
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1412 sjlj_fc_call_site_ofs
);
1413 expand_sjlj_dispatch_table (disp
, dispatch_labels
);
1419 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1420 if (num_dispatch
== 1)
1422 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1423 e
->count
= bb
->count
;
1424 e
->probability
= REG_BR_PROB_BASE
;
1427 struct loop
*loop
= bb
->next_bb
->loop_father
;
1428 /* If we created a pre-header block, add the new block to the
1429 outer loop, otherwise to the loop itself. */
1430 if (bb
->next_bb
== loop
->header
)
1431 add_bb_to_loop (bb
, loop_outer (loop
));
1433 add_bb_to_loop (bb
, loop
);
1438 /* We are not wiring up edges here, but as the dispatcher call
1439 is at function begin simply associate the block with the
1440 outermost (non-)loop. */
1442 add_bb_to_loop (bb
, current_loops
->tree_root
);
1447 sjlj_build_landing_pads (void)
1451 num_dispatch
= vec_safe_length (cfun
->eh
->lp_array
);
1452 if (num_dispatch
== 0)
1454 sjlj_lp_call_site_index
.safe_grow_cleared (num_dispatch
);
1456 num_dispatch
= sjlj_assign_call_site_values ();
1457 if (num_dispatch
> 0)
1459 rtx dispatch_label
= gen_label_rtx ();
1460 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1461 TYPE_MODE (sjlj_fc_type_node
),
1462 TYPE_ALIGN (sjlj_fc_type_node
));
1464 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1465 int_size_in_bytes (sjlj_fc_type_node
),
1468 sjlj_mark_call_sites ();
1469 sjlj_emit_function_enter (dispatch_label
);
1470 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1471 sjlj_emit_function_exit ();
1474 /* If we do not have any landing pads, we may still need to register a
1475 personality routine and (empty) LSDA to handle must-not-throw regions. */
1476 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
1478 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1479 TYPE_MODE (sjlj_fc_type_node
),
1480 TYPE_ALIGN (sjlj_fc_type_node
));
1482 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1483 int_size_in_bytes (sjlj_fc_type_node
),
1486 sjlj_mark_call_sites ();
1487 sjlj_emit_function_enter (NULL_RTX
);
1488 sjlj_emit_function_exit ();
1491 sjlj_lp_call_site_index
.release ();
1494 /* After initial rtl generation, call back to finish generating
1495 exception support code. */
1498 finish_eh_generation (void)
1502 /* Construct the landing pads. */
1503 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1504 sjlj_build_landing_pads ();
1506 dw2_build_landing_pads ();
1507 break_superblocks ();
1509 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1510 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1511 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->insns
.r
)
1512 commit_edge_insertions ();
1514 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1515 FOR_EACH_BB_FN (bb
, cfun
)
1521 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1523 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1524 if (e
->flags
& EDGE_EH
)
1527 /* We should not have generated any new throwing insns during this
1528 pass, and we should not have lost any EH edges, so we only need
1529 to handle two cases here:
1530 (1) reachable handler and an existing edge to post-landing-pad,
1531 (2) no reachable handler and no edge. */
1532 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1535 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1537 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1538 e
->flags
|= (CALL_P (BB_END (bb
))
1539 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1545 /* This section handles removing dead code for flow. */
1548 remove_eh_landing_pad (eh_landing_pad lp
)
1552 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1556 if (lp
->post_landing_pad
)
1557 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1558 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1561 /* Splice the EH region at PP from the region tree. */
1564 remove_eh_handler_splicer (eh_region
*pp
)
1566 eh_region region
= *pp
;
1569 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1571 if (lp
->post_landing_pad
)
1572 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1573 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1579 outer
= region
->outer
;
1581 *pp
= p
= region
->inner
;
1590 *pp
= region
->next_peer
;
1592 (*cfun
->eh
->region_array
)[region
->index
] = NULL
;
1595 /* Splice a single EH region REGION from the region tree.
1597 To unlink REGION, we need to find the pointer to it with a relatively
1598 expensive search in REGION's outer region. If you are going to
1599 remove a number of handlers, using remove_unreachable_eh_regions may
1600 be a better option. */
1603 remove_eh_handler (eh_region region
)
1605 eh_region
*pp
, *pp_start
, p
, outer
;
1607 outer
= region
->outer
;
1609 pp_start
= &outer
->inner
;
1611 pp_start
= &cfun
->eh
->region_tree
;
1612 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1615 remove_eh_handler_splicer (pp
);
1618 /* Worker for remove_unreachable_eh_regions.
1619 PP is a pointer to the region to start a region tree depth-first
1620 search from. R_REACHABLE is the set of regions that have to be
1624 remove_unreachable_eh_regions_worker (eh_region
*pp
, sbitmap r_reachable
)
1628 eh_region region
= *pp
;
1629 remove_unreachable_eh_regions_worker (®ion
->inner
, r_reachable
);
1630 if (!bitmap_bit_p (r_reachable
, region
->index
))
1631 remove_eh_handler_splicer (pp
);
1633 pp
= ®ion
->next_peer
;
1637 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1638 Do this by traversing the EH tree top-down and splice out regions that
1639 are not marked. By removing regions from the leaves, we avoid costly
1640 searches in the region tree. */
1643 remove_unreachable_eh_regions (sbitmap r_reachable
)
1645 remove_unreachable_eh_regions_worker (&cfun
->eh
->region_tree
, r_reachable
);
1648 /* Invokes CALLBACK for every exception handler landing pad label.
1649 Only used by reload hackery; should not be used by new code. */
1652 for_each_eh_label (void (*callback
) (rtx
))
1657 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1661 rtx lab
= lp
->landing_pad
;
1662 if (lab
&& LABEL_P (lab
))
1668 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1671 At the gimple level, we use LP_NR
1672 > 0 : The statement transfers to landing pad LP_NR
1673 = 0 : The statement is outside any EH region
1674 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1676 At the rtl level, we use LP_NR
1677 > 0 : The insn transfers to landing pad LP_NR
1678 = 0 : The insn cannot throw
1679 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1680 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1681 missing note: The insn is outside any EH region.
1683 ??? This difference probably ought to be avoided. We could stand
1684 to record nothrow for arbitrary gimple statements, and so avoid
1685 some moderately complex lookups in stmt_could_throw_p. Perhaps
1686 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1687 no-nonlocal-goto property should be recorded elsewhere as a bit
1688 on the call_insn directly. Perhaps we should make more use of
1689 attaching the trees to call_insns (reachable via symbol_ref in
1690 direct call cases) and just pull the data out of the trees. */
1693 make_reg_eh_region_note (rtx insn
, int ecf_flags
, int lp_nr
)
1696 if (ecf_flags
& ECF_NOTHROW
)
1698 else if (lp_nr
!= 0)
1699 value
= GEN_INT (lp_nr
);
1702 add_reg_note (insn
, REG_EH_REGION
, value
);
1705 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1706 nor perform a non-local goto. Replace the region note if it
1710 make_reg_eh_region_note_nothrow_nononlocal (rtx insn
)
1712 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1713 rtx intmin
= GEN_INT (INT_MIN
);
1716 XEXP (note
, 0) = intmin
;
1718 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1721 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1725 insn_could_throw_p (const_rtx insn
)
1727 if (!flag_exceptions
)
1731 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1732 return may_trap_p (PATTERN (insn
));
1736 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1737 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1738 to look for a note, or the note itself. */
1741 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx first
, rtx last
)
1743 rtx insn
, 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 last
, rtx first
)
1764 rtx insn
, note
= note_or_insn
;
1766 if (INSN_P (note_or_insn
))
1768 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1772 note
= XEXP (note
, 0);
1774 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1775 if (insn_could_throw_p (insn
))
1776 add_reg_note (insn
, REG_EH_REGION
, note
);
1780 /* Extract all EH information from INSN. Return true if the insn
1781 was marked NOTHROW. */
1784 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1785 eh_landing_pad
*plp
)
1787 eh_landing_pad lp
= NULL
;
1793 if (! INSN_P (insn
))
1796 if (NONJUMP_INSN_P (insn
)
1797 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1798 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1800 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1803 ret
= !insn_could_throw_p (insn
);
1807 lp_nr
= INTVAL (XEXP (note
, 0));
1808 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1815 r
= (*cfun
->eh
->region_array
)[-lp_nr
];
1818 lp
= (*cfun
->eh
->lp_array
)[lp_nr
];
1828 /* Return the landing pad to which INSN may go, or NULL if it does not
1829 have a reachable landing pad within this function. */
1832 get_eh_landing_pad_from_rtx (const_rtx insn
)
1837 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1841 /* Return the region to which INSN may go, or NULL if it does not
1842 have a reachable region within this function. */
1845 get_eh_region_from_rtx (const_rtx insn
)
1850 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1854 /* Return true if INSN throws and is caught by something in this function. */
1857 can_throw_internal (const_rtx insn
)
1859 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1862 /* Return true if INSN throws and escapes from the current function. */
1865 can_throw_external (const_rtx insn
)
1871 if (! INSN_P (insn
))
1874 if (NONJUMP_INSN_P (insn
)
1875 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1877 rtx seq
= PATTERN (insn
);
1878 int i
, n
= XVECLEN (seq
, 0);
1880 for (i
= 0; i
< n
; i
++)
1881 if (can_throw_external (XVECEXP (seq
, 0, i
)))
1887 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1889 /* If we can't throw, we obviously can't throw external. */
1893 /* If we have an internal landing pad, then we're not external. */
1897 /* If we're not within an EH region, then we are external. */
1901 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1902 which don't always have landing pads. */
1903 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1907 /* Return true if INSN cannot throw at all. */
1910 insn_nothrow_p (const_rtx insn
)
1915 if (! INSN_P (insn
))
1918 if (NONJUMP_INSN_P (insn
)
1919 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1921 rtx seq
= PATTERN (insn
);
1922 int i
, n
= XVECLEN (seq
, 0);
1924 for (i
= 0; i
< n
; i
++)
1925 if (!insn_nothrow_p (XVECEXP (seq
, 0, i
)))
1931 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1934 /* Return true if INSN can perform a non-local goto. */
1935 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1938 can_nonlocal_goto (const_rtx insn
)
1940 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1942 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1943 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1949 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1952 set_nothrow_function_flags (void)
1958 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1959 something that can throw an exception. We specifically exempt
1960 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1961 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1964 crtl
->all_throwers_are_sibcalls
= 1;
1966 /* If we don't know that this implementation of the function will
1967 actually be used, then we must not set TREE_NOTHROW, since
1968 callers must not assume that this function does not throw. */
1969 if (TREE_NOTHROW (current_function_decl
))
1972 if (! flag_exceptions
)
1975 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1976 if (can_throw_external (insn
))
1980 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1982 crtl
->all_throwers_are_sibcalls
= 0;
1988 && (cgraph_node::get (current_function_decl
)->get_availability ()
1989 >= AVAIL_AVAILABLE
))
1991 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1992 struct cgraph_edge
*e
;
1993 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1994 e
->can_throw_external
= false;
1995 node
->set_nothrow_flag (true);
1998 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
1999 current_function_name ());
2006 const pass_data pass_data_set_nothrow_function_flags
=
2008 RTL_PASS
, /* type */
2009 "nothrow", /* name */
2010 OPTGROUP_NONE
, /* optinfo_flags */
2011 TV_NONE
, /* tv_id */
2012 0, /* properties_required */
2013 0, /* properties_provided */
2014 0, /* properties_destroyed */
2015 0, /* todo_flags_start */
2016 0, /* todo_flags_finish */
2019 class pass_set_nothrow_function_flags
: public rtl_opt_pass
2022 pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2023 : rtl_opt_pass (pass_data_set_nothrow_function_flags
, ctxt
)
2026 /* opt_pass methods: */
2027 virtual unsigned int execute (function
*)
2029 return set_nothrow_function_flags ();
2032 }; // class pass_set_nothrow_function_flags
2037 make_pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2039 return new pass_set_nothrow_function_flags (ctxt
);
2043 /* Various hooks for unwind library. */
2045 /* Expand the EH support builtin functions:
2046 __builtin_eh_pointer and __builtin_eh_filter. */
2049 expand_builtin_eh_common (tree region_nr_t
)
2051 HOST_WIDE_INT region_nr
;
2054 gcc_assert (tree_fits_shwi_p (region_nr_t
));
2055 region_nr
= tree_to_shwi (region_nr_t
);
2057 region
= (*cfun
->eh
->region_array
)[region_nr
];
2059 /* ??? We shouldn't have been able to delete a eh region without
2060 deleting all the code that depended on it. */
2061 gcc_assert (region
!= NULL
);
2066 /* Expand to the exc_ptr value from the given eh region. */
2069 expand_builtin_eh_pointer (tree exp
)
2072 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2073 if (region
->exc_ptr_reg
== NULL
)
2074 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2075 return region
->exc_ptr_reg
;
2078 /* Expand to the filter value from the given eh region. */
2081 expand_builtin_eh_filter (tree exp
)
2084 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2085 if (region
->filter_reg
== NULL
)
2086 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
2087 return region
->filter_reg
;
2090 /* Copy the exc_ptr and filter values from one landing pad's registers
2091 to another. This is used to inline the resx statement. */
2094 expand_builtin_eh_copy_values (tree exp
)
2097 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2099 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
2100 enum machine_mode fmode
= targetm
.eh_return_filter_mode ();
2102 if (dst
->exc_ptr_reg
== NULL
)
2103 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2104 if (src
->exc_ptr_reg
== NULL
)
2105 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2107 if (dst
->filter_reg
== NULL
)
2108 dst
->filter_reg
= gen_reg_rtx (fmode
);
2109 if (src
->filter_reg
== NULL
)
2110 src
->filter_reg
= gen_reg_rtx (fmode
);
2112 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2113 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2118 /* Do any necessary initialization to access arbitrary stack frames.
2119 On the SPARC, this means flushing the register windows. */
2122 expand_builtin_unwind_init (void)
2124 /* Set this so all the registers get saved in our frame; we need to be
2125 able to copy the saved values for any registers from frames we unwind. */
2126 crtl
->saves_all_registers
= 1;
2128 #ifdef SETUP_FRAME_ADDRESSES
2129 SETUP_FRAME_ADDRESSES ();
2133 /* Map a non-negative number to an eh return data register number; expands
2134 to -1 if no return data register is associated with the input number.
2135 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2138 expand_builtin_eh_return_data_regno (tree exp
)
2140 tree which
= CALL_EXPR_ARG (exp
, 0);
2141 unsigned HOST_WIDE_INT iwhich
;
2143 if (TREE_CODE (which
) != INTEGER_CST
)
2145 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2149 iwhich
= tree_to_uhwi (which
);
2150 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2151 if (iwhich
== INVALID_REGNUM
)
2154 #ifdef DWARF_FRAME_REGNUM
2155 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2157 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2160 return GEN_INT (iwhich
);
2163 /* Given a value extracted from the return address register or stack slot,
2164 return the actual address encoded in that value. */
2167 expand_builtin_extract_return_addr (tree addr_tree
)
2169 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2171 if (GET_MODE (addr
) != Pmode
2172 && GET_MODE (addr
) != VOIDmode
)
2174 #ifdef POINTERS_EXTEND_UNSIGNED
2175 addr
= convert_memory_address (Pmode
, addr
);
2177 addr
= convert_to_mode (Pmode
, addr
, 0);
2181 /* First mask out any unwanted bits. */
2182 #ifdef MASK_RETURN_ADDR
2183 expand_and (Pmode
, addr
, MASK_RETURN_ADDR
, addr
);
2186 /* Then adjust to find the real return address. */
2187 #if defined (RETURN_ADDR_OFFSET)
2188 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 #ifdef RETURN_ADDR_OFFSET
2206 addr
= force_reg (Pmode
, addr
);
2207 addr
= plus_constant (Pmode
, addr
, -RETURN_ADDR_OFFSET
);
2213 /* Set up the epilogue with the magic bits we'll need to return to the
2214 exception handler. */
2217 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2222 #ifdef EH_RETURN_STACKADJ_RTX
2223 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2224 VOIDmode
, EXPAND_NORMAL
);
2225 tmp
= convert_memory_address (Pmode
, tmp
);
2226 if (!crtl
->eh
.ehr_stackadj
)
2227 crtl
->eh
.ehr_stackadj
= copy_to_reg (tmp
);
2228 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2229 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2232 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2233 VOIDmode
, EXPAND_NORMAL
);
2234 tmp
= convert_memory_address (Pmode
, tmp
);
2235 if (!crtl
->eh
.ehr_handler
)
2236 crtl
->eh
.ehr_handler
= copy_to_reg (tmp
);
2237 else if (tmp
!= crtl
->eh
.ehr_handler
)
2238 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2240 if (!crtl
->eh
.ehr_label
)
2241 crtl
->eh
.ehr_label
= gen_label_rtx ();
2242 emit_jump (crtl
->eh
.ehr_label
);
2245 /* Expand __builtin_eh_return. This exit path from the function loads up
2246 the eh return data registers, adjusts the stack, and branches to a
2247 given PC other than the normal return address. */
2250 expand_eh_return (void)
2254 if (! crtl
->eh
.ehr_label
)
2257 crtl
->calls_eh_return
= 1;
2259 #ifdef EH_RETURN_STACKADJ_RTX
2260 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2263 around_label
= gen_label_rtx ();
2264 emit_jump (around_label
);
2266 emit_label (crtl
->eh
.ehr_label
);
2267 clobber_return_register ();
2269 #ifdef EH_RETURN_STACKADJ_RTX
2270 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2273 #ifdef HAVE_eh_return
2275 emit_insn (gen_eh_return (crtl
->eh
.ehr_handler
));
2279 #ifdef EH_RETURN_HANDLER_RTX
2280 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2282 error ("__builtin_eh_return not supported on this target");
2286 emit_label (around_label
);
2289 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2290 POINTERS_EXTEND_UNSIGNED and return it. */
2293 expand_builtin_extend_pointer (tree addr_tree
)
2295 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2298 #ifdef POINTERS_EXTEND_UNSIGNED
2299 extend
= POINTERS_EXTEND_UNSIGNED
;
2301 /* The previous EH code did an unsigned extend by default, so we do this also
2306 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2310 add_action_record (action_hash_type
*ar_hash
, int filter
, int next
)
2312 struct action_record
**slot
, *new_ar
, tmp
;
2314 tmp
.filter
= filter
;
2316 slot
= ar_hash
->find_slot (&tmp
, INSERT
);
2318 if ((new_ar
= *slot
) == NULL
)
2320 new_ar
= XNEW (struct action_record
);
2321 new_ar
->offset
= crtl
->eh
.action_record_data
->length () + 1;
2322 new_ar
->filter
= filter
;
2323 new_ar
->next
= next
;
2326 /* The filter value goes in untouched. The link to the next
2327 record is a "self-relative" byte offset, or zero to indicate
2328 that there is no next record. So convert the absolute 1 based
2329 indices we've been carrying around into a displacement. */
2331 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2333 next
-= crtl
->eh
.action_record_data
->length () + 1;
2334 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2337 return new_ar
->offset
;
2341 collect_one_action_chain (action_hash_type
*ar_hash
, eh_region region
)
2345 /* If we've reached the top of the region chain, then we have
2346 no actions, and require no landing pad. */
2350 switch (region
->type
)
2355 /* A cleanup adds a zero filter to the beginning of the chain, but
2356 there are special cases to look out for. If there are *only*
2357 cleanups along a path, then it compresses to a zero action.
2358 Further, if there are multiple cleanups along a path, we only
2359 need to represent one of them, as that is enough to trigger
2360 entry to the landing pad at runtime. */
2361 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2364 for (r
= region
->outer
; r
; r
= r
->outer
)
2365 if (r
->type
== ERT_CLEANUP
)
2367 return add_action_record (ar_hash
, 0, next
);
2374 /* Process the associated catch regions in reverse order.
2375 If there's a catch-all handler, then we don't need to
2376 search outer regions. Use a magic -3 value to record
2377 that we haven't done the outer search. */
2379 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2381 if (c
->type_list
== NULL
)
2383 /* Retrieve the filter from the head of the filter list
2384 where we have stored it (see assign_filter_values). */
2385 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2386 next
= add_action_record (ar_hash
, filter
, 0);
2390 /* Once the outer search is done, trigger an action record for
2391 each filter we have. */
2396 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2398 /* If there is no next action, terminate the chain. */
2401 /* If all outer actions are cleanups or must_not_throw,
2402 we'll have no action record for it, since we had wanted
2403 to encode these states in the call-site record directly.
2404 Add a cleanup action to the chain to catch these. */
2406 next
= add_action_record (ar_hash
, 0, 0);
2409 flt_node
= c
->filter_list
;
2410 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2412 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2413 next
= add_action_record (ar_hash
, filter
, next
);
2420 case ERT_ALLOWED_EXCEPTIONS
:
2421 /* An exception specification adds its filter to the
2422 beginning of the chain. */
2423 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2425 /* If there is no next action, terminate the chain. */
2428 /* If all outer actions are cleanups or must_not_throw,
2429 we'll have no action record for it, since we had wanted
2430 to encode these states in the call-site record directly.
2431 Add a cleanup action to the chain to catch these. */
2433 next
= add_action_record (ar_hash
, 0, 0);
2435 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2437 case ERT_MUST_NOT_THROW
:
2438 /* A must-not-throw region with no inner handlers or cleanups
2439 requires no call-site entry. Note that this differs from
2440 the no handler or cleanup case in that we do require an lsda
2441 to be generated. Return a magic -2 value to record this. */
2449 add_call_site (rtx landing_pad
, int action
, int section
)
2451 call_site_record record
;
2453 record
= ggc_alloc
<call_site_record_d
> ();
2454 record
->landing_pad
= landing_pad
;
2455 record
->action
= action
;
2457 vec_safe_push (crtl
->eh
.call_site_record_v
[section
], record
);
2459 return call_site_base
+ crtl
->eh
.call_site_record_v
[section
]->length () - 1;
2463 emit_note_eh_region_end (rtx insn
)
2465 rtx next
= NEXT_INSN (insn
);
2467 /* Make sure we do not split a call and its corresponding
2468 CALL_ARG_LOCATION note. */
2469 if (next
&& NOTE_P (next
)
2470 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
2473 return emit_note_after (NOTE_INSN_EH_REGION_END
, insn
);
2476 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2477 The new note numbers will not refer to region numbers, but
2478 instead to call site entries. */
2481 convert_to_eh_region_ranges (void)
2483 rtx insn
, iter
, note
;
2484 action_hash_type
ar_hash (31);
2485 int last_action
= -3;
2486 rtx last_action_insn
= NULL_RTX
;
2487 rtx last_landing_pad
= NULL_RTX
;
2488 rtx first_no_action_insn
= NULL_RTX
;
2491 rtx section_switch_note
= NULL_RTX
;
2492 rtx first_no_action_insn_before_switch
= NULL_RTX
;
2493 rtx last_no_action_insn_before_switch
= NULL_RTX
;
2494 int saved_call_site_base
= call_site_base
;
2496 vec_alloc (crtl
->eh
.action_record_data
, 64);
2498 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2505 rtx this_landing_pad
;
2508 if (NONJUMP_INSN_P (insn
)
2509 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2510 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2512 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2516 this_action
= collect_one_action_chain (&ar_hash
, region
);
2520 /* Existence of catch handlers, or must-not-throw regions
2521 implies that an lsda is needed (even if empty). */
2522 if (this_action
!= -1)
2523 crtl
->uses_eh_lsda
= 1;
2525 /* Delay creation of region notes for no-action regions
2526 until we're sure that an lsda will be required. */
2527 else if (last_action
== -3)
2529 first_no_action_insn
= iter
;
2533 if (this_action
>= 0)
2534 this_landing_pad
= lp
->landing_pad
;
2536 this_landing_pad
= NULL_RTX
;
2538 /* Differing actions or landing pads implies a change in call-site
2539 info, which implies some EH_REGION note should be emitted. */
2540 if (last_action
!= this_action
2541 || last_landing_pad
!= this_landing_pad
)
2543 /* If there is a queued no-action region in the other section
2544 with hot/cold partitioning, emit it now. */
2545 if (first_no_action_insn_before_switch
)
2547 gcc_assert (this_action
!= -1
2548 && last_action
== (first_no_action_insn
2550 call_site
= add_call_site (NULL_RTX
, 0, 0);
2551 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2552 first_no_action_insn_before_switch
);
2553 NOTE_EH_HANDLER (note
) = call_site
;
2555 = emit_note_eh_region_end (last_no_action_insn_before_switch
);
2556 NOTE_EH_HANDLER (note
) = call_site
;
2557 gcc_assert (last_action
!= -3
2558 || (last_action_insn
2559 == last_no_action_insn_before_switch
));
2560 first_no_action_insn_before_switch
= NULL_RTX
;
2561 last_no_action_insn_before_switch
= NULL_RTX
;
2564 /* If we'd not seen a previous action (-3) or the previous
2565 action was must-not-throw (-2), then we do not need an
2567 if (last_action
>= -1)
2569 /* If we delayed the creation of the begin, do it now. */
2570 if (first_no_action_insn
)
2572 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2573 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2574 first_no_action_insn
);
2575 NOTE_EH_HANDLER (note
) = call_site
;
2576 first_no_action_insn
= NULL_RTX
;
2579 note
= emit_note_eh_region_end (last_action_insn
);
2580 NOTE_EH_HANDLER (note
) = call_site
;
2583 /* If the new action is must-not-throw, then no region notes
2585 if (this_action
>= -1)
2587 call_site
= add_call_site (this_landing_pad
,
2588 this_action
< 0 ? 0 : this_action
,
2590 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2591 NOTE_EH_HANDLER (note
) = call_site
;
2594 last_action
= this_action
;
2595 last_landing_pad
= this_landing_pad
;
2597 last_action_insn
= iter
;
2599 else if (NOTE_P (iter
)
2600 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2602 gcc_assert (section_switch_note
== NULL_RTX
);
2603 gcc_assert (flag_reorder_blocks_and_partition
);
2604 section_switch_note
= iter
;
2605 if (first_no_action_insn
)
2607 first_no_action_insn_before_switch
= first_no_action_insn
;
2608 last_no_action_insn_before_switch
= last_action_insn
;
2609 first_no_action_insn
= NULL_RTX
;
2610 gcc_assert (last_action
== -1);
2613 /* Force closing of current EH region before section switch and
2614 opening a new one afterwards. */
2615 else if (last_action
!= -3)
2616 last_landing_pad
= pc_rtx
;
2617 if (crtl
->eh
.call_site_record_v
[cur_sec
])
2618 call_site_base
+= crtl
->eh
.call_site_record_v
[cur_sec
]->length ();
2620 gcc_assert (crtl
->eh
.call_site_record_v
[cur_sec
] == NULL
);
2621 vec_alloc (crtl
->eh
.call_site_record_v
[cur_sec
], 10);
2624 if (last_action
>= -1 && ! first_no_action_insn
)
2626 note
= emit_note_eh_region_end (last_action_insn
);
2627 NOTE_EH_HANDLER (note
) = call_site
;
2630 call_site_base
= saved_call_site_base
;
2637 const pass_data pass_data_convert_to_eh_region_ranges
=
2639 RTL_PASS
, /* type */
2640 "eh_ranges", /* name */
2641 OPTGROUP_NONE
, /* optinfo_flags */
2642 TV_NONE
, /* tv_id */
2643 0, /* properties_required */
2644 0, /* properties_provided */
2645 0, /* properties_destroyed */
2646 0, /* todo_flags_start */
2647 0, /* todo_flags_finish */
2650 class pass_convert_to_eh_region_ranges
: public rtl_opt_pass
2653 pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2654 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges
, ctxt
)
2657 /* opt_pass methods: */
2658 virtual bool gate (function
*);
2659 virtual unsigned int execute (function
*)
2661 return convert_to_eh_region_ranges ();
2664 }; // class pass_convert_to_eh_region_ranges
2667 pass_convert_to_eh_region_ranges::gate (function
*)
2669 /* Nothing to do for SJLJ exceptions or if no regions created. */
2670 if (cfun
->eh
->region_tree
== NULL
)
2672 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2680 make_pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2682 return new pass_convert_to_eh_region_ranges (ctxt
);
2686 push_uleb128 (vec
<uchar
, va_gc
> **data_area
, unsigned int value
)
2690 unsigned char byte
= value
& 0x7f;
2694 vec_safe_push (*data_area
, byte
);
2700 push_sleb128 (vec
<uchar
, va_gc
> **data_area
, int value
)
2707 byte
= value
& 0x7f;
2709 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2710 || (value
== -1 && (byte
& 0x40) != 0));
2713 vec_safe_push (*data_area
, byte
);
2719 #ifndef HAVE_AS_LEB128
2721 dw2_size_of_call_site_table (int section
)
2723 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2724 int size
= n
* (4 + 4 + 4);
2727 for (i
= 0; i
< n
; ++i
)
2729 struct call_site_record_d
*cs
=
2730 (*crtl
->eh
.call_site_record_v
[section
])[i
];
2731 size
+= size_of_uleb128 (cs
->action
);
2738 sjlj_size_of_call_site_table (void)
2740 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2744 for (i
= 0; i
< n
; ++i
)
2746 struct call_site_record_d
*cs
=
2747 (*crtl
->eh
.call_site_record_v
[0])[i
];
2748 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2749 size
+= size_of_uleb128 (cs
->action
);
2757 dw2_output_call_site_table (int cs_format
, int section
)
2759 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2764 begin
= current_function_func_begin_label
;
2765 else if (first_function_block_is_cold
)
2766 begin
= crtl
->subsections
.hot_section_label
;
2768 begin
= crtl
->subsections
.cold_section_label
;
2770 for (i
= 0; i
< n
; ++i
)
2772 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[section
])[i
];
2773 char reg_start_lab
[32];
2774 char reg_end_lab
[32];
2775 char landing_pad_lab
[32];
2777 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2778 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2780 if (cs
->landing_pad
)
2781 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2782 CODE_LABEL_NUMBER (cs
->landing_pad
));
2784 /* ??? Perhaps use insn length scaling if the assembler supports
2785 generic arithmetic. */
2786 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2787 data4 if the function is small enough. */
2788 if (cs_format
== DW_EH_PE_uleb128
)
2790 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2791 "region %d start", i
);
2792 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2794 if (cs
->landing_pad
)
2795 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2798 dw2_asm_output_data_uleb128 (0, "landing pad");
2802 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2803 "region %d start", i
);
2804 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2805 if (cs
->landing_pad
)
2806 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2809 dw2_asm_output_data (4, 0, "landing pad");
2811 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2814 call_site_base
+= n
;
2818 sjlj_output_call_site_table (void)
2820 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2823 for (i
= 0; i
< n
; ++i
)
2825 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[0])[i
];
2827 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2828 "region %d landing pad", i
);
2829 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2832 call_site_base
+= n
;
2835 /* Switch to the section that should be used for exception tables. */
2838 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2842 if (exception_section
)
2843 s
= exception_section
;
2846 /* Compute the section and cache it into exception_section,
2847 unless it depends on the function name. */
2848 if (targetm_common
.have_named_sections
)
2852 if (EH_TABLES_CAN_BE_READ_ONLY
)
2855 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2856 flags
= ((! flag_pic
2857 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2858 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2859 ? 0 : SECTION_WRITE
);
2862 flags
= SECTION_WRITE
;
2864 #ifdef HAVE_LD_EH_GC_SECTIONS
2865 if (flag_function_sections
2866 || (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
))
2868 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2869 /* The EH table must match the code section, so only mark
2870 it linkonce if we have COMDAT groups to tie them together. */
2871 if (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
)
2872 flags
|= SECTION_LINKONCE
;
2873 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2874 s
= get_section (section_name
, flags
, current_function_decl
);
2875 free (section_name
);
2880 = s
= get_section (".gcc_except_table", flags
, NULL
);
2884 = s
= flag_pic
? data_section
: readonly_data_section
;
2887 switch_to_section (s
);
2891 /* Output a reference from an exception table to the type_info object TYPE.
2892 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2896 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2899 bool is_public
= true;
2901 if (type
== NULL_TREE
)
2905 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2906 runtime types so TYPE should already be a runtime type
2907 reference. When pass_ipa_free_lang data is made a default
2908 pass, we can then remove the call to lookup_type_for_runtime
2911 type
= lookup_type_for_runtime (type
);
2913 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2915 /* Let cgraph know that the rtti decl is used. Not all of the
2916 paths below go through assemble_integer, which would take
2917 care of this for us. */
2919 if (TREE_CODE (type
) == ADDR_EXPR
)
2921 type
= TREE_OPERAND (type
, 0);
2922 if (TREE_CODE (type
) == VAR_DECL
)
2923 is_public
= TREE_PUBLIC (type
);
2926 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2929 /* Allow the target to override the type table entry format. */
2930 if (targetm
.asm_out
.ttype (value
))
2933 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2934 assemble_integer (value
, tt_format_size
,
2935 tt_format_size
* BITS_PER_UNIT
, 1);
2937 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2941 output_one_function_exception_table (int section
)
2943 int tt_format
, cs_format
, lp_format
, i
;
2944 #ifdef HAVE_AS_LEB128
2945 char ttype_label
[32];
2946 char cs_after_size_label
[32];
2947 char cs_end_label
[32];
2952 int tt_format_size
= 0;
2954 have_tt_data
= (vec_safe_length (cfun
->eh
->ttype_data
)
2955 || (targetm
.arm_eabi_unwinder
2956 ? vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
)
2957 : vec_safe_length (cfun
->eh
->ehspec_data
.other
)));
2959 /* Indicate the format of the @TType entries. */
2961 tt_format
= DW_EH_PE_omit
;
2964 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2965 #ifdef HAVE_AS_LEB128
2966 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2967 section
? "LLSDATTC" : "LLSDATT",
2968 current_function_funcdef_no
);
2970 tt_format_size
= size_of_encoded_value (tt_format
);
2972 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2975 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2976 current_function_funcdef_no
);
2978 /* The LSDA header. */
2980 /* Indicate the format of the landing pad start pointer. An omitted
2981 field implies @LPStart == @Start. */
2982 /* Currently we always put @LPStart == @Start. This field would
2983 be most useful in moving the landing pads completely out of
2984 line to another section, but it could also be used to minimize
2985 the size of uleb128 landing pad offsets. */
2986 lp_format
= DW_EH_PE_omit
;
2987 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
2988 eh_data_format_name (lp_format
));
2990 /* @LPStart pointer would go here. */
2992 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
2993 eh_data_format_name (tt_format
));
2995 #ifndef HAVE_AS_LEB128
2996 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2997 call_site_len
= sjlj_size_of_call_site_table ();
2999 call_site_len
= dw2_size_of_call_site_table (section
);
3002 /* A pc-relative 4-byte displacement to the @TType data. */
3005 #ifdef HAVE_AS_LEB128
3006 char ttype_after_disp_label
[32];
3007 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
3008 section
? "LLSDATTDC" : "LLSDATTD",
3009 current_function_funcdef_no
);
3010 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3011 "@TType base offset");
3012 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3014 /* Ug. Alignment queers things. */
3015 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3017 before_disp
= 1 + 1;
3018 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3020 + vec_safe_length (crtl
->eh
.action_record_data
)
3021 + (vec_safe_length (cfun
->eh
->ttype_data
)
3027 unsigned int disp_size
, pad
;
3030 disp_size
= size_of_uleb128 (disp
);
3031 pad
= before_disp
+ disp_size
+ after_disp
;
3032 if (pad
% tt_format_size
)
3033 pad
= tt_format_size
- (pad
% tt_format_size
);
3036 disp
= after_disp
+ pad
;
3038 while (disp
!= last_disp
);
3040 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3044 /* Indicate the format of the call-site offsets. */
3045 #ifdef HAVE_AS_LEB128
3046 cs_format
= DW_EH_PE_uleb128
;
3048 cs_format
= DW_EH_PE_udata4
;
3050 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3051 eh_data_format_name (cs_format
));
3053 #ifdef HAVE_AS_LEB128
3054 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3055 section
? "LLSDACSBC" : "LLSDACSB",
3056 current_function_funcdef_no
);
3057 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3058 section
? "LLSDACSEC" : "LLSDACSE",
3059 current_function_funcdef_no
);
3060 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3061 "Call-site table length");
3062 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3063 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3064 sjlj_output_call_site_table ();
3066 dw2_output_call_site_table (cs_format
, section
);
3067 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3069 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3070 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3071 sjlj_output_call_site_table ();
3073 dw2_output_call_site_table (cs_format
, section
);
3076 /* ??? Decode and interpret the data for flag_debug_asm. */
3079 FOR_EACH_VEC_ELT (*crtl
->eh
.action_record_data
, i
, uc
)
3080 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3084 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3086 i
= vec_safe_length (cfun
->eh
->ttype_data
);
3089 tree type
= (*cfun
->eh
->ttype_data
)[i
];
3090 output_ttype (type
, tt_format
, tt_format_size
);
3093 #ifdef HAVE_AS_LEB128
3095 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3098 /* ??? Decode and interpret the data for flag_debug_asm. */
3099 if (targetm
.arm_eabi_unwinder
)
3103 vec_safe_iterate (cfun
->eh
->ehspec_data
.arm_eabi
, i
, &type
); ++i
)
3104 output_ttype (type
, tt_format
, tt_format_size
);
3110 vec_safe_iterate (cfun
->eh
->ehspec_data
.other
, i
, &uc
); ++i
)
3111 dw2_asm_output_data (1, uc
,
3112 i
? NULL
: "Exception specification table");
3117 output_function_exception_table (const char *fnname
)
3119 rtx personality
= get_personality_function (current_function_decl
);
3121 /* Not all functions need anything. */
3122 if (! crtl
->uses_eh_lsda
)
3127 assemble_external_libcall (personality
);
3129 if (targetm
.asm_out
.emit_except_personality
)
3130 targetm
.asm_out
.emit_except_personality (personality
);
3133 switch_to_exception_section (fnname
);
3135 /* If the target wants a label to begin the table, emit it here. */
3136 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3138 output_one_function_exception_table (0);
3139 if (crtl
->eh
.call_site_record_v
[1])
3140 output_one_function_exception_table (1);
3142 switch_to_section (current_function_section ());
3146 set_eh_throw_stmt_table (struct function
*fun
, struct htab
*table
)
3148 fun
->eh
->throw_stmt_table
= table
;
3152 get_eh_throw_stmt_table (struct function
*fun
)
3154 return fun
->eh
->throw_stmt_table
;
3157 /* Determine if the function needs an EH personality function. */
3159 enum eh_personality_kind
3160 function_needs_eh_personality (struct function
*fn
)
3162 enum eh_personality_kind kind
= eh_personality_none
;
3165 FOR_ALL_EH_REGION_FN (i
, fn
)
3170 /* Can do with any personality including the generic C one. */
3171 kind
= eh_personality_any
;
3175 case ERT_ALLOWED_EXCEPTIONS
:
3176 /* Always needs a EH personality function. The generic C
3177 personality doesn't handle these even for empty type lists. */
3178 return eh_personality_lang
;
3180 case ERT_MUST_NOT_THROW
:
3181 /* Always needs a EH personality function. The language may specify
3182 what abort routine that must be used, e.g. std::terminate. */
3183 return eh_personality_lang
;
3190 /* Dump EH information to OUT. */
3193 dump_eh_tree (FILE * out
, struct function
*fun
)
3197 static const char *const type_name
[] = {
3198 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3201 i
= fun
->eh
->region_tree
;
3205 fprintf (out
, "Eh tree:\n");
3208 fprintf (out
, " %*s %i %s", depth
* 2, "",
3209 i
->index
, type_name
[(int) i
->type
]);
3211 if (i
->landing_pads
)
3215 fprintf (out
, " land:");
3216 if (current_ir_type () == IR_GIMPLE
)
3218 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3220 fprintf (out
, "{%i,", lp
->index
);
3221 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3229 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3231 fprintf (out
, "{%i,", lp
->index
);
3232 if (lp
->landing_pad
)
3233 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3234 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3236 fprintf (out
, "(nil),");
3237 if (lp
->post_landing_pad
)
3239 rtx lab
= label_rtx (lp
->post_landing_pad
);
3240 fprintf (out
, "%i%s}", INSN_UID (lab
),
3241 NOTE_P (lab
) ? "(del)" : "");
3244 fprintf (out
, "(nil)}");
3254 case ERT_MUST_NOT_THROW
:
3260 fprintf (out
, " catch:");
3261 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3266 fprintf (out
, "lab:");
3267 print_generic_expr (out
, c
->label
, 0);
3270 print_generic_expr (out
, c
->type_list
, 0);
3278 case ERT_ALLOWED_EXCEPTIONS
:
3279 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3280 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3285 /* If there are sub-regions, process them. */
3287 i
= i
->inner
, depth
++;
3288 /* If there are peers, process them. */
3289 else if (i
->next_peer
)
3291 /* Otherwise, step back up the tree to the next peer. */
3301 while (i
->next_peer
== NULL
);
3307 /* Dump the EH tree for FN on stderr. */
3310 debug_eh_tree (struct function
*fn
)
3312 dump_eh_tree (stderr
, fn
);
3315 /* Verify invariants on EH datastructures. */
3318 verify_eh_tree (struct function
*fun
)
3321 int nvisited_lp
, nvisited_r
;
3322 int count_lp
, count_r
, depth
, i
;
3326 if (!fun
->eh
->region_tree
)
3330 for (i
= 1; vec_safe_iterate (fun
->eh
->region_array
, i
, &r
); ++i
)
3337 error ("region_array is corrupted for region %i", r
->index
);
3343 for (i
= 1; vec_safe_iterate (fun
->eh
->lp_array
, i
, &lp
); ++i
)
3350 error ("lp_array is corrupted for lp %i", lp
->index
);
3355 depth
= nvisited_lp
= nvisited_r
= 0;
3357 r
= fun
->eh
->region_tree
;
3360 if ((*fun
->eh
->region_array
)[r
->index
] != r
)
3362 error ("region_array is corrupted for region %i", r
->index
);
3365 if (r
->outer
!= outer
)
3367 error ("outer block of region %i is wrong", r
->index
);
3372 error ("negative nesting depth of region %i", r
->index
);
3377 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3379 if ((*fun
->eh
->lp_array
)[lp
->index
] != lp
)
3381 error ("lp_array is corrupted for lp %i", lp
->index
);
3384 if (lp
->region
!= r
)
3386 error ("region of lp %i is wrong", lp
->index
);
3393 outer
= r
, r
= r
->inner
, depth
++;
3394 else if (r
->next_peer
)
3406 while (r
->next_peer
== NULL
);
3413 error ("tree list ends on depth %i", depth
);
3416 if (count_r
!= nvisited_r
)
3418 error ("region_array does not match region_tree");
3421 if (count_lp
!= nvisited_lp
)
3423 error ("lp_array does not match region_tree");
3429 dump_eh_tree (stderr
, fun
);
3430 internal_error ("verify_eh_tree failed");
3434 #include "gt-except.h"