1 /* Implements exception handling.
2 Copyright (C) 1989-2015 Free Software Foundation, Inc.
3 Contributed by Mike Stump <mrs@cygnus.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* An exception is an event that can be "thrown" from within a
23 function. This event can then be "caught" by the callers of
26 The representation of exceptions changes several times during
27 the compilation process:
29 In the beginning, in the front end, we have the GENERIC trees
30 TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
31 CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
33 During initial gimplification (gimplify.c) these are lowered
34 to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
35 The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
36 into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
39 During pass_lower_eh (tree-eh.c) we record the nested structure
40 of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
41 We expand the eh_protect_cleanup_actions langhook into MUST_NOT_THROW
42 regions at this time. We can then flatten the statements within
43 the TRY nodes to straight-line code. Statements that had been within
44 TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,
45 so that we may remember what action is supposed to be taken if
46 a given statement does throw. During this lowering process,
47 we create an EH_LANDING_PAD node for each EH_REGION that has
48 some code within the function that needs to be executed if a
49 throw does happen. We also create RESX statements that are
50 used to transfer control from an inner EH_REGION to an outer
51 EH_REGION. We also create EH_DISPATCH statements as placeholders
52 for a runtime type comparison that should be made in order to
53 select the action to perform among different CATCH and EH_FILTER
56 During pass_lower_eh_dispatch (tree-eh.c), which is run after
57 all inlining is complete, we are able to run assign_filter_values,
58 which allows us to map the set of types manipulated by all of the
59 CATCH and EH_FILTER regions to a set of integers. This set of integers
60 will be how the exception runtime communicates with the code generated
61 within the function. We then expand the GIMPLE_EH_DISPATCH statements
62 to a switch or conditional branches that use the argument provided by
63 the runtime (__builtin_eh_filter) and the set of integers we computed
64 in assign_filter_values.
66 During pass_lower_resx (tree-eh.c), which is run near the end
67 of optimization, we expand RESX statements. If the eh region
68 that is outer to the RESX statement is a MUST_NOT_THROW, then
69 the RESX expands to some form of abort statement. If the eh
70 region that is outer to the RESX statement is within the current
71 function, then the RESX expands to a bookkeeping call
72 (__builtin_eh_copy_values) and a goto. Otherwise, the next
73 handler for the exception must be within a function somewhere
74 up the call chain, so we call back into the exception runtime
75 (__builtin_unwind_resume).
77 During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
78 that create an rtl to eh_region mapping that corresponds to the
79 gimple to eh_region mapping that had been recorded in the
82 Then, via finish_eh_generation, we generate the real landing pads
83 to which the runtime will actually transfer control. These new
84 landing pads perform whatever bookkeeping is needed by the target
85 backend in order to resume execution within the current function.
86 Each of these new landing pads falls through into the post_landing_pad
87 label which had been used within the CFG up to this point. All
88 exception edges within the CFG are redirected to the new landing pads.
89 If the target uses setjmp to implement exceptions, the various extra
90 calls into the runtime to register and unregister the current stack
91 frame are emitted at this time.
93 During pass_convert_to_eh_region_ranges (except.c), we transform
94 the REG_EH_REGION notes attached to individual insns into
95 non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG
96 and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the
97 same associated action within the exception region tree, meaning
98 that (1) the exception is caught by the same landing pad within the
99 current function, (2) the exception is blocked by the runtime with
100 a MUST_NOT_THROW region, or (3) the exception is not handled at all
101 within the current function.
103 Finally, during assembly generation, we call
104 output_function_exception_table (except.c) to emit the tables with
105 which the exception runtime can determine if a given stack frame
106 handles a given exception, and if so what filter value to provide
107 to the function when the non-local control transfer is effected.
108 If the target uses dwarf2 unwinding to implement exceptions, then
109 output_call_frame_info (dwarf2out.c) emits the required unwind data. */
114 #include "coretypes.h"
120 #include "fold-const.h"
121 #include "stringpool.h"
122 #include "stor-layout.h"
124 #include "hard-reg-set.h"
125 #include "function.h"
126 #include "insn-codes.h"
128 #include "insn-config.h"
133 #include "emit-rtl.h"
137 #include "libfuncs.h"
140 #include "dwarf2asm.h"
141 #include "dwarf2out.h"
147 #include "common/common-target.h"
148 #include "langhooks.h"
150 #include "dominance.h"
153 #include "basic-block.h"
154 #include "plugin-api.h"
157 #include "diagnostic.h"
158 #include "tree-pretty-print.h"
159 #include "tree-pass.h"
161 #include "builtins.h"
163 static GTY(()) int call_site_base
;
165 struct tree_hash_traits
: default_hashmap_traits
167 static hashval_t
hash (tree t
) { return TREE_HASH (t
); }
170 static GTY (()) hash_map
<tree
, tree
, tree_hash_traits
> *type_to_runtime_map
;
172 /* Describe the SjLj_Function_Context structure. */
173 static GTY(()) tree sjlj_fc_type_node
;
174 static int sjlj_fc_call_site_ofs
;
175 static int sjlj_fc_data_ofs
;
176 static int sjlj_fc_personality_ofs
;
177 static int sjlj_fc_lsda_ofs
;
178 static int sjlj_fc_jbuf_ofs
;
181 struct GTY(()) call_site_record_d
187 /* In the following structure and associated functions,
188 we represent entries in the action table as 1-based indices.
191 0: null action record, non-null landing pad; implies cleanups
192 -1: null action record, null landing pad; implies no action
193 -2: no call-site entry; implies must_not_throw
194 -3: we have yet to process outer regions
196 Further, no special cases apply to the "next" field of the record.
197 For next, 0 means end of list. */
206 /* Hashtable helpers. */
208 struct action_record_hasher
: free_ptr_hash
<action_record
>
210 static inline hashval_t
hash (const action_record
*);
211 static inline bool equal (const action_record
*, const action_record
*);
215 action_record_hasher::hash (const action_record
*entry
)
217 return entry
->next
* 1009 + entry
->filter
;
221 action_record_hasher::equal (const action_record
*entry
,
222 const action_record
*data
)
224 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
227 typedef hash_table
<action_record_hasher
> action_hash_type
;
229 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
232 static void dw2_build_landing_pads (void);
234 static int collect_one_action_chain (action_hash_type
*, eh_region
);
235 static int add_call_site (rtx
, int, int);
237 static void push_uleb128 (vec
<uchar
, va_gc
> **, unsigned int);
238 static void push_sleb128 (vec
<uchar
, va_gc
> **, int);
239 #ifndef HAVE_AS_LEB128
240 static int dw2_size_of_call_site_table (int);
241 static int sjlj_size_of_call_site_table (void);
243 static void dw2_output_call_site_table (int, int);
244 static void sjlj_output_call_site_table (void);
250 if (! flag_exceptions
)
254 = hash_map
<tree
, tree
, tree_hash_traits
>::create_ggc (31);
256 /* Create the SjLj_Function_Context structure. This should match
257 the definition in unwind-sjlj.c. */
258 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
260 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
262 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
264 f_prev
= build_decl (BUILTINS_LOCATION
,
265 FIELD_DECL
, get_identifier ("__prev"),
266 build_pointer_type (sjlj_fc_type_node
));
267 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
269 f_cs
= build_decl (BUILTINS_LOCATION
,
270 FIELD_DECL
, get_identifier ("__call_site"),
272 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
274 tmp
= build_index_type (size_int (4 - 1));
275 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
276 (targetm
.unwind_word_mode (), 1),
278 f_data
= build_decl (BUILTINS_LOCATION
,
279 FIELD_DECL
, get_identifier ("__data"), tmp
);
280 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
282 f_per
= build_decl (BUILTINS_LOCATION
,
283 FIELD_DECL
, get_identifier ("__personality"),
285 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
287 f_lsda
= build_decl (BUILTINS_LOCATION
,
288 FIELD_DECL
, get_identifier ("__lsda"),
290 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
292 #ifdef DONT_USE_BUILTIN_SETJMP
294 tmp
= size_int (JMP_BUF_SIZE
- 1);
296 /* Should be large enough for most systems, if it is not,
297 JMP_BUF_SIZE should be defined with the proper value. It will
298 also tend to be larger than necessary for most systems, a more
299 optimal port will define JMP_BUF_SIZE. */
300 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
303 /* Compute a minimally sized jump buffer. We need room to store at
304 least 3 pointers - stack pointer, frame pointer and return address.
305 Plus for some targets we need room for an extra pointer - in the
306 case of MIPS this is the global pointer. This makes a total of four
307 pointers, but to be safe we actually allocate room for 5.
309 If pointers are smaller than words then we allocate enough room for
310 5 words, just in case the backend needs this much room. For more
311 discussion on this issue see:
312 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
313 if (POINTER_SIZE
> BITS_PER_WORD
)
314 tmp
= size_int (5 - 1);
316 tmp
= size_int ((5 * BITS_PER_WORD
/ POINTER_SIZE
) - 1);
319 tmp
= build_index_type (tmp
);
320 tmp
= build_array_type (ptr_type_node
, tmp
);
321 f_jbuf
= build_decl (BUILTINS_LOCATION
,
322 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
323 #ifdef DONT_USE_BUILTIN_SETJMP
324 /* We don't know what the alignment requirements of the
325 runtime's jmp_buf has. Overestimate. */
326 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
327 DECL_USER_ALIGN (f_jbuf
) = 1;
329 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
331 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
332 TREE_CHAIN (f_prev
) = f_cs
;
333 TREE_CHAIN (f_cs
) = f_data
;
334 TREE_CHAIN (f_data
) = f_per
;
335 TREE_CHAIN (f_per
) = f_lsda
;
336 TREE_CHAIN (f_lsda
) = f_jbuf
;
338 layout_type (sjlj_fc_type_node
);
340 /* Cache the interesting field offsets so that we have
341 easy access from rtl. */
342 sjlj_fc_call_site_ofs
343 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs
))
344 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs
)) / BITS_PER_UNIT
);
346 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data
))
347 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data
)) / BITS_PER_UNIT
);
348 sjlj_fc_personality_ofs
349 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per
))
350 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per
)) / BITS_PER_UNIT
);
352 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda
))
353 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda
)) / BITS_PER_UNIT
);
355 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf
))
356 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf
)) / BITS_PER_UNIT
);
361 init_eh_for_function (void)
363 cfun
->eh
= ggc_cleared_alloc
<eh_status
> ();
365 /* Make sure zero'th entries are used. */
366 vec_safe_push (cfun
->eh
->region_array
, (eh_region
)0);
367 vec_safe_push (cfun
->eh
->lp_array
, (eh_landing_pad
)0);
370 /* Routines to generate the exception tree somewhat directly.
371 These are used from tree-eh.c when processing exception related
372 nodes during tree optimization. */
375 gen_eh_region (enum eh_region_type type
, eh_region outer
)
379 /* Insert a new blank region as a leaf in the tree. */
380 new_eh
= ggc_cleared_alloc
<eh_region_d
> ();
382 new_eh
->outer
= outer
;
385 new_eh
->next_peer
= outer
->inner
;
386 outer
->inner
= new_eh
;
390 new_eh
->next_peer
= cfun
->eh
->region_tree
;
391 cfun
->eh
->region_tree
= new_eh
;
394 new_eh
->index
= vec_safe_length (cfun
->eh
->region_array
);
395 vec_safe_push (cfun
->eh
->region_array
, new_eh
);
397 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
398 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
399 new_eh
->use_cxa_end_cleanup
= true;
405 gen_eh_region_cleanup (eh_region outer
)
407 return gen_eh_region (ERT_CLEANUP
, outer
);
411 gen_eh_region_try (eh_region outer
)
413 return gen_eh_region (ERT_TRY
, outer
);
417 gen_eh_region_catch (eh_region t
, tree type_or_list
)
420 tree type_list
, type_node
;
422 gcc_assert (t
->type
== ERT_TRY
);
424 /* Ensure to always end up with a type list to normalize further
425 processing, then register each type against the runtime types map. */
426 type_list
= type_or_list
;
429 if (TREE_CODE (type_or_list
) != TREE_LIST
)
430 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
432 type_node
= type_list
;
433 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
434 add_type_for_runtime (TREE_VALUE (type_node
));
437 c
= ggc_cleared_alloc
<eh_catch_d
> ();
438 c
->type_list
= type_list
;
439 l
= t
->u
.eh_try
.last_catch
;
444 t
->u
.eh_try
.first_catch
= c
;
445 t
->u
.eh_try
.last_catch
= c
;
451 gen_eh_region_allowed (eh_region outer
, tree allowed
)
453 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
454 region
->u
.allowed
.type_list
= allowed
;
456 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
457 add_type_for_runtime (TREE_VALUE (allowed
));
463 gen_eh_region_must_not_throw (eh_region outer
)
465 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
469 gen_eh_landing_pad (eh_region region
)
471 eh_landing_pad lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
473 lp
->next_lp
= region
->landing_pads
;
475 lp
->index
= vec_safe_length (cfun
->eh
->lp_array
);
476 region
->landing_pads
= lp
;
478 vec_safe_push (cfun
->eh
->lp_array
, lp
);
484 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
486 return (*ifun
->eh
->region_array
)[i
];
490 get_eh_region_from_number (int i
)
492 return get_eh_region_from_number_fn (cfun
, i
);
496 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
498 return (*ifun
->eh
->lp_array
)[i
];
502 get_eh_landing_pad_from_number (int i
)
504 return get_eh_landing_pad_from_number_fn (cfun
, i
);
508 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
511 return (*ifun
->eh
->region_array
)[-i
];
517 lp
= (*ifun
->eh
->lp_array
)[i
];
523 get_eh_region_from_lp_number (int i
)
525 return get_eh_region_from_lp_number_fn (cfun
, i
);
528 /* Returns true if the current function has exception handling regions. */
531 current_function_has_exception_handlers (void)
533 return cfun
->eh
->region_tree
!= NULL
;
536 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
537 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
539 struct duplicate_eh_regions_data
541 duplicate_eh_regions_map label_map
;
542 void *label_map_data
;
543 hash_map
<void *, void *> *eh_map
;
547 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
548 eh_region old_r
, eh_region outer
)
550 eh_landing_pad old_lp
, new_lp
;
553 new_r
= gen_eh_region (old_r
->type
, outer
);
554 gcc_assert (!data
->eh_map
->put (old_r
, new_r
));
564 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
566 /* We should be doing all our region duplication before and
567 during inlining, which is before filter lists are created. */
568 gcc_assert (oc
->filter_list
== NULL
);
569 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
570 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
575 case ERT_ALLOWED_EXCEPTIONS
:
576 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
577 if (old_r
->u
.allowed
.label
)
578 new_r
->u
.allowed
.label
579 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
581 new_r
->u
.allowed
.label
= NULL_TREE
;
584 case ERT_MUST_NOT_THROW
:
585 new_r
->u
.must_not_throw
.failure_loc
=
586 LOCATION_LOCUS (old_r
->u
.must_not_throw
.failure_loc
);
587 new_r
->u
.must_not_throw
.failure_decl
=
588 old_r
->u
.must_not_throw
.failure_decl
;
592 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
594 /* Don't bother copying unused landing pads. */
595 if (old_lp
->post_landing_pad
== NULL
)
598 new_lp
= gen_eh_landing_pad (new_r
);
599 gcc_assert (!data
->eh_map
->put (old_lp
, new_lp
));
601 new_lp
->post_landing_pad
602 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
603 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
606 /* Make sure to preserve the original use of __cxa_end_cleanup. */
607 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
609 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
610 duplicate_eh_regions_1 (data
, old_r
, new_r
);
613 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
614 the current function and root the tree below OUTER_REGION.
615 The special case of COPY_REGION of NULL means all regions.
616 Remap labels using MAP/MAP_DATA callback. Return a pointer map
617 that allows the caller to remap uses of both EH regions and
620 hash_map
<void *, void *> *
621 duplicate_eh_regions (struct function
*ifun
,
622 eh_region copy_region
, int outer_lp
,
623 duplicate_eh_regions_map map
, void *map_data
)
625 struct duplicate_eh_regions_data data
;
626 eh_region outer_region
;
628 #ifdef ENABLE_CHECKING
629 verify_eh_tree (ifun
);
632 data
.label_map
= map
;
633 data
.label_map_data
= map_data
;
634 data
.eh_map
= new hash_map
<void *, void *>;
636 outer_region
= get_eh_region_from_lp_number_fn (cfun
, outer_lp
);
638 /* Copy all the regions in the subtree. */
640 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
644 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
645 duplicate_eh_regions_1 (&data
, r
, outer_region
);
648 #ifdef ENABLE_CHECKING
649 verify_eh_tree (cfun
);
655 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
658 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
663 gcc_assert (ifun
->eh
->region_array
);
664 gcc_assert (ifun
->eh
->region_tree
);
666 b_outer
= sbitmap_alloc (ifun
->eh
->region_array
->length ());
667 bitmap_clear (b_outer
);
671 bitmap_set_bit (b_outer
, region_b
->index
);
672 region_b
= region_b
->outer
;
678 if (bitmap_bit_p (b_outer
, region_a
->index
))
680 region_a
= region_a
->outer
;
684 sbitmap_free (b_outer
);
689 add_type_for_runtime (tree type
)
691 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
692 if (TREE_CODE (type
) == NOP_EXPR
)
695 bool existed
= false;
696 tree
*slot
= &type_to_runtime_map
->get_or_insert (type
, &existed
);
698 *slot
= lang_hooks
.eh_runtime_type (type
);
702 lookup_type_for_runtime (tree type
)
704 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
705 if (TREE_CODE (type
) == NOP_EXPR
)
708 /* We should have always inserted the data earlier. */
709 return *type_to_runtime_map
->get (type
);
713 /* Represent an entry in @TTypes for either catch actions
714 or exception filter actions. */
715 struct ttypes_filter
{
720 /* Helper for ttypes_filter hashing. */
722 struct ttypes_filter_hasher
: free_ptr_hash
<ttypes_filter
>
724 typedef tree_node
*compare_type
;
725 static inline hashval_t
hash (const ttypes_filter
*);
726 static inline bool equal (const ttypes_filter
*, const tree_node
*);
729 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
730 (a tree) for a @TTypes type node we are thinking about adding. */
733 ttypes_filter_hasher::equal (const ttypes_filter
*entry
, const tree_node
*data
)
735 return entry
->t
== data
;
739 ttypes_filter_hasher::hash (const ttypes_filter
*entry
)
741 return TREE_HASH (entry
->t
);
744 typedef hash_table
<ttypes_filter_hasher
> ttypes_hash_type
;
747 /* Helper for ehspec hashing. */
749 struct ehspec_hasher
: free_ptr_hash
<ttypes_filter
>
751 static inline hashval_t
hash (const ttypes_filter
*);
752 static inline bool equal (const ttypes_filter
*, const ttypes_filter
*);
755 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
756 exception specification list we are thinking about adding. */
757 /* ??? Currently we use the type lists in the order given. Someone
758 should put these in some canonical order. */
761 ehspec_hasher::equal (const ttypes_filter
*entry
, const ttypes_filter
*data
)
763 return type_list_equal (entry
->t
, data
->t
);
766 /* Hash function for exception specification lists. */
769 ehspec_hasher::hash (const ttypes_filter
*entry
)
774 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
775 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
779 typedef hash_table
<ehspec_hasher
> ehspec_hash_type
;
782 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
783 to speed up the search. Return the filter value to be used. */
786 add_ttypes_entry (ttypes_hash_type
*ttypes_hash
, tree type
)
788 struct ttypes_filter
**slot
, *n
;
790 slot
= ttypes_hash
->find_slot_with_hash (type
, (hashval_t
) TREE_HASH (type
),
793 if ((n
= *slot
) == NULL
)
795 /* Filter value is a 1 based table index. */
797 n
= XNEW (struct ttypes_filter
);
799 n
->filter
= vec_safe_length (cfun
->eh
->ttype_data
) + 1;
802 vec_safe_push (cfun
->eh
->ttype_data
, type
);
808 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
809 to speed up the search. Return the filter value to be used. */
812 add_ehspec_entry (ehspec_hash_type
*ehspec_hash
, ttypes_hash_type
*ttypes_hash
,
815 struct ttypes_filter
**slot
, *n
;
816 struct ttypes_filter dummy
;
819 slot
= ehspec_hash
->find_slot (&dummy
, INSERT
);
821 if ((n
= *slot
) == NULL
)
825 if (targetm
.arm_eabi_unwinder
)
826 len
= vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
);
828 len
= vec_safe_length (cfun
->eh
->ehspec_data
.other
);
830 /* Filter value is a -1 based byte index into a uleb128 buffer. */
832 n
= XNEW (struct ttypes_filter
);
834 n
->filter
= -(len
+ 1);
837 /* Generate a 0 terminated list of filter values. */
838 for (; list
; list
= TREE_CHAIN (list
))
840 if (targetm
.arm_eabi_unwinder
)
841 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, TREE_VALUE (list
));
844 /* Look up each type in the list and encode its filter
845 value as a uleb128. */
846 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
847 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
850 if (targetm
.arm_eabi_unwinder
)
851 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
853 vec_safe_push (cfun
->eh
->ehspec_data
.other
, (uchar
)0);
859 /* Generate the action filter values to be used for CATCH and
860 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
861 we use lots of landing pads, and so every type or list can share
862 the same filter value, which saves table space. */
865 assign_filter_values (void)
871 vec_alloc (cfun
->eh
->ttype_data
, 16);
872 if (targetm
.arm_eabi_unwinder
)
873 vec_alloc (cfun
->eh
->ehspec_data
.arm_eabi
, 64);
875 vec_alloc (cfun
->eh
->ehspec_data
.other
, 64);
877 ehspec_hash_type
ehspec (31);
878 ttypes_hash_type
ttypes (31);
880 for (i
= 1; vec_safe_iterate (cfun
->eh
->region_array
, i
, &r
); ++i
)
888 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
890 /* Whatever type_list is (NULL or true list), we build a list
891 of filters for the region. */
892 c
->filter_list
= NULL_TREE
;
894 if (c
->type_list
!= NULL
)
896 /* Get a filter value for each of the types caught and store
897 them in the region's dedicated list. */
898 tree tp_node
= c
->type_list
;
900 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
903 = add_ttypes_entry (&ttypes
, TREE_VALUE (tp_node
));
904 tree flt_node
= build_int_cst (integer_type_node
, flt
);
907 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
912 /* Get a filter value for the NULL list also since it
913 will need an action record anyway. */
914 int flt
= add_ttypes_entry (&ttypes
, NULL
);
915 tree flt_node
= build_int_cst (integer_type_node
, flt
);
918 = tree_cons (NULL_TREE
, flt_node
, NULL
);
923 case ERT_ALLOWED_EXCEPTIONS
:
925 = add_ehspec_entry (&ehspec
, &ttypes
, r
->u
.allowed
.type_list
);
934 /* Emit SEQ into basic block just before INSN (that is assumed to be
935 first instruction of some existing BB and return the newly
938 emit_to_new_bb_before (rtx_insn
*seq
, rtx insn
)
945 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
946 call), we don't want it to go into newly created landing pad or other EH
948 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
949 if (e
->flags
& EDGE_FALLTHRU
)
950 force_nonfallthru (e
);
953 last
= emit_insn_before (seq
, insn
);
954 if (BARRIER_P (last
))
955 last
= PREV_INSN (last
);
956 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
957 update_bb_for_insn (bb
);
958 bb
->flags
|= BB_SUPERBLOCK
;
962 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
963 at the rtl level. Emit the code required by the target at a landing
964 pad for the given region. */
967 expand_dw2_landing_pad_for_region (eh_region region
)
969 #ifdef HAVE_exception_receiver
970 if (HAVE_exception_receiver
)
971 emit_insn (gen_exception_receiver ());
974 #ifdef HAVE_nonlocal_goto_receiver
975 if (HAVE_nonlocal_goto_receiver
)
976 emit_insn (gen_nonlocal_goto_receiver ());
981 if (region
->exc_ptr_reg
)
982 emit_move_insn (region
->exc_ptr_reg
,
983 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
984 if (region
->filter_reg
)
985 emit_move_insn (region
->filter_reg
,
986 gen_rtx_REG (targetm
.eh_return_filter_mode (),
987 EH_RETURN_DATA_REGNO (1)));
990 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
993 dw2_build_landing_pads (void)
997 int e_flags
= EDGE_FALLTHRU
;
999 /* If we're going to partition blocks, we need to be able to add
1000 new landing pads later, which means that we need to hold on to
1001 the post-landing-pad block. Prevent it from being merged away.
1002 We'll remove this bit after partitioning. */
1003 if (flag_reorder_blocks_and_partition
)
1004 e_flags
|= EDGE_PRESERVE
;
1006 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1012 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
1017 lp
->landing_pad
= gen_label_rtx ();
1018 emit_label (lp
->landing_pad
);
1019 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
1021 expand_dw2_landing_pad_for_region (lp
->region
);
1026 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
1027 e
= make_edge (bb
, bb
->next_bb
, e_flags
);
1028 e
->count
= bb
->count
;
1029 e
->probability
= REG_BR_PROB_BASE
;
1032 struct loop
*loop
= bb
->next_bb
->loop_father
;
1033 /* If we created a pre-header block, add the new block to the
1034 outer loop, otherwise to the loop itself. */
1035 if (bb
->next_bb
== loop
->header
)
1036 add_bb_to_loop (bb
, loop_outer (loop
));
1038 add_bb_to_loop (bb
, loop
);
1044 static vec
<int> sjlj_lp_call_site_index
;
1046 /* Process all active landing pads. Assign each one a compact dispatch
1047 index, and a call-site index. */
1050 sjlj_assign_call_site_values (void)
1052 action_hash_type
ar_hash (31);
1056 vec_alloc (crtl
->eh
.action_record_data
, 64);
1060 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1061 if (lp
&& lp
->post_landing_pad
)
1063 int action
, call_site
;
1065 /* First: build the action table. */
1066 action
= collect_one_action_chain (&ar_hash
, lp
->region
);
1068 /* Next: assign call-site values. If dwarf2 terms, this would be
1069 the region number assigned by convert_to_eh_region_ranges, but
1070 handles no-action and must-not-throw differently. */
1071 /* Map must-not-throw to otherwise unused call-site index 0. */
1074 /* Map no-action to otherwise unused call-site index -1. */
1075 else if (action
== -1)
1077 /* Otherwise, look it up in the table. */
1079 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1080 sjlj_lp_call_site_index
[i
] = call_site
;
1088 /* Emit code to record the current call-site index before every
1089 insn that can throw. */
1092 sjlj_mark_call_sites (void)
1094 int last_call_site
= -2;
1098 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1104 rtx_insn
*before
, *p
;
1106 /* Reset value tracking at extended basic block boundaries. */
1108 last_call_site
= -2;
1110 /* If the function allocates dynamic stack space, the context must
1111 be updated after every allocation/deallocation accordingly. */
1112 if (NOTE_P (insn
) && NOTE_KIND (insn
) == NOTE_INSN_UPDATE_SJLJ_CONTEXT
)
1117 buf_addr
= plus_constant (Pmode
, XEXP (crtl
->eh
.sjlj_fc
, 0),
1119 expand_builtin_update_setjmp_buf (buf_addr
);
1122 emit_insn_before (p
, insn
);
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
);
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_code_label
*dispatch_label
)
1174 rtx_insn
*fn_begin
, *seq
;
1176 bool fn_begin_outside_block
;
1177 rtx personality
= get_personality_function (current_function_decl
);
1179 fc
= crtl
->eh
.sjlj_fc
;
1183 /* We're storing this libcall's address into memory instead of
1184 calling it directly. Thus, we must call assemble_external_libcall
1185 here, as we can not depend on emit_library_call to do it for us. */
1186 assemble_external_libcall (personality
);
1187 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1188 emit_move_insn (mem
, personality
);
1190 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1191 if (crtl
->uses_eh_lsda
)
1196 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1197 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1198 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1199 emit_move_insn (mem
, sym
);
1202 emit_move_insn (mem
, const0_rtx
);
1206 #ifdef DONT_USE_BUILTIN_SETJMP
1208 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1209 TYPE_MODE (integer_type_node
), 1,
1210 plus_constant (Pmode
, XEXP (fc
, 0),
1211 sjlj_fc_jbuf_ofs
), Pmode
);
1213 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1214 TYPE_MODE (integer_type_node
), 0,
1215 dispatch_label
, REG_BR_PROB_BASE
/ 100);
1217 expand_builtin_setjmp_setup (plus_constant (Pmode
, XEXP (fc
, 0),
1223 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1224 1, XEXP (fc
, 0), Pmode
);
1229 /* ??? Instead of doing this at the beginning of the function,
1230 do this in a block that is at loop level 0 and dominates all
1231 can_throw_internal instructions. */
1233 fn_begin_outside_block
= true;
1234 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1235 if (NOTE_P (fn_begin
))
1237 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1239 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1240 fn_begin_outside_block
= false;
1243 if (fn_begin_outside_block
)
1244 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1246 emit_insn_after (seq
, fn_begin
);
1249 /* Call back from expand_function_end to know where we should put
1250 the call to unwind_sjlj_unregister_libfunc if needed. */
1253 sjlj_emit_function_exit_after (rtx_insn
*after
)
1255 crtl
->eh
.sjlj_exit_after
= after
;
1259 sjlj_emit_function_exit (void)
1261 rtx_insn
*seq
, *insn
;
1265 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1266 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1271 /* ??? Really this can be done in any block at loop level 0 that
1272 post-dominates all can_throw_internal instructions. This is
1273 the last possible moment. */
1275 insn
= crtl
->eh
.sjlj_exit_after
;
1277 insn
= NEXT_INSN (insn
);
1279 emit_insn_after (seq
, insn
);
1283 sjlj_emit_dispatch_table (rtx_code_label
*dispatch_label
, int num_dispatch
)
1285 machine_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1286 machine_mode filter_mode
= targetm
.eh_return_filter_mode ();
1288 rtx mem
, fc
, exc_ptr_reg
, filter_reg
;
1294 vec
<tree
> dispatch_labels
= vNULL
;
1296 fc
= crtl
->eh
.sjlj_fc
;
1300 emit_label (dispatch_label
);
1302 #ifndef DONT_USE_BUILTIN_SETJMP
1303 expand_builtin_setjmp_receiver (dispatch_label
);
1305 /* The caller of expand_builtin_setjmp_receiver is responsible for
1306 making sure that the label doesn't vanish. The only other caller
1307 is the expander for __builtin_setjmp_receiver, which places this
1308 label on the nonlocal_goto_label list. Since we're modeling these
1309 CFG edges more exactly, we can use the forced_labels list instead. */
1310 LABEL_PRESERVE_P (dispatch_label
) = 1;
1312 = gen_rtx_INSN_LIST (VOIDmode
, dispatch_label
, forced_labels
);
1315 /* Load up exc_ptr and filter values from the function context. */
1316 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1317 if (unwind_word_mode
!= ptr_mode
)
1319 #ifdef POINTERS_EXTEND_UNSIGNED
1320 mem
= convert_memory_address (ptr_mode
, mem
);
1322 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1325 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1327 mem
= adjust_address (fc
, unwind_word_mode
,
1328 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1329 if (unwind_word_mode
!= filter_mode
)
1330 mem
= convert_to_mode (filter_mode
, mem
, 0);
1331 filter_reg
= force_reg (filter_mode
, mem
);
1333 /* Jump to one of the directly reachable regions. */
1336 rtx_code_label
*first_reachable_label
= NULL
;
1338 /* If there's exactly one call site in the function, don't bother
1339 generating a switch statement. */
1340 if (num_dispatch
> 1)
1341 dispatch_labels
.create (num_dispatch
);
1343 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1344 if (lp
&& lp
->post_landing_pad
)
1347 rtx_code_label
*label
;
1351 lp
->landing_pad
= dispatch_label
;
1353 if (num_dispatch
> 1)
1355 tree t_label
, case_elt
, t
;
1357 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1358 t
= build_int_cst (integer_type_node
, disp_index
);
1359 case_elt
= build_case_label (t
, NULL
, t_label
);
1360 dispatch_labels
.quick_push (case_elt
);
1361 label
= jump_target_rtx (t_label
);
1364 label
= gen_label_rtx ();
1366 if (disp_index
== 0)
1367 first_reachable_label
= label
;
1372 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1374 emit_move_insn (r
->filter_reg
, filter_reg
);
1376 seq2
= get_insns ();
1379 rtx_insn
*before
= label_rtx (lp
->post_landing_pad
);
1380 bb
= emit_to_new_bb_before (seq2
, before
);
1381 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1382 e
->count
= bb
->count
;
1383 e
->probability
= REG_BR_PROB_BASE
;
1386 struct loop
*loop
= bb
->next_bb
->loop_father
;
1387 /* If we created a pre-header block, add the new block to the
1388 outer loop, otherwise to the loop itself. */
1389 if (bb
->next_bb
== loop
->header
)
1390 add_bb_to_loop (bb
, loop_outer (loop
));
1392 add_bb_to_loop (bb
, loop
);
1393 /* ??? For multiple dispatches we will end up with edges
1394 from the loop tree root into this loop, making it a
1395 multiple-entry loop. Discard all affected loops. */
1396 if (num_dispatch
> 1)
1398 for (loop
= bb
->loop_father
;
1399 loop_outer (loop
); loop
= loop_outer (loop
))
1400 mark_loop_for_removal (loop
);
1406 gcc_assert (disp_index
== num_dispatch
);
1408 if (num_dispatch
> 1)
1410 rtx disp
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1411 sjlj_fc_call_site_ofs
);
1412 expand_sjlj_dispatch_table (disp
, dispatch_labels
);
1418 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1419 if (num_dispatch
== 1)
1421 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1422 e
->count
= bb
->count
;
1423 e
->probability
= REG_BR_PROB_BASE
;
1426 struct loop
*loop
= bb
->next_bb
->loop_father
;
1427 /* If we created a pre-header block, add the new block to the
1428 outer loop, otherwise to the loop itself. */
1429 if (bb
->next_bb
== loop
->header
)
1430 add_bb_to_loop (bb
, loop_outer (loop
));
1432 add_bb_to_loop (bb
, loop
);
1437 /* We are not wiring up edges here, but as the dispatcher call
1438 is at function begin simply associate the block with the
1439 outermost (non-)loop. */
1441 add_bb_to_loop (bb
, current_loops
->tree_root
);
1446 sjlj_build_landing_pads (void)
1450 num_dispatch
= vec_safe_length (cfun
->eh
->lp_array
);
1451 if (num_dispatch
== 0)
1453 sjlj_lp_call_site_index
.safe_grow_cleared (num_dispatch
);
1455 num_dispatch
= sjlj_assign_call_site_values ();
1456 if (num_dispatch
> 0)
1458 rtx_code_label
*dispatch_label
= gen_label_rtx ();
1459 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1460 TYPE_MODE (sjlj_fc_type_node
),
1461 TYPE_ALIGN (sjlj_fc_type_node
));
1463 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1464 int_size_in_bytes (sjlj_fc_type_node
),
1467 sjlj_mark_call_sites ();
1468 sjlj_emit_function_enter (dispatch_label
);
1469 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1470 sjlj_emit_function_exit ();
1473 /* If we do not have any landing pads, we may still need to register a
1474 personality routine and (empty) LSDA to handle must-not-throw regions. */
1475 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
1477 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1478 TYPE_MODE (sjlj_fc_type_node
),
1479 TYPE_ALIGN (sjlj_fc_type_node
));
1481 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1482 int_size_in_bytes (sjlj_fc_type_node
),
1485 sjlj_mark_call_sites ();
1486 sjlj_emit_function_enter (NULL
);
1487 sjlj_emit_function_exit ();
1490 sjlj_lp_call_site_index
.release ();
1493 /* Update the sjlj function context. This function should be called
1494 whenever we allocate or deallocate dynamic stack space. */
1497 update_sjlj_context (void)
1499 if (!flag_exceptions
)
1502 emit_note (NOTE_INSN_UPDATE_SJLJ_CONTEXT
);
1505 /* After initial rtl generation, call back to finish generating
1506 exception support code. */
1509 finish_eh_generation (void)
1513 /* Construct the landing pads. */
1514 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1515 sjlj_build_landing_pads ();
1517 dw2_build_landing_pads ();
1518 break_superblocks ();
1520 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1521 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1522 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->insns
.r
)
1523 commit_edge_insertions ();
1525 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1526 FOR_EACH_BB_FN (bb
, cfun
)
1532 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1534 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1535 if (e
->flags
& EDGE_EH
)
1538 /* We should not have generated any new throwing insns during this
1539 pass, and we should not have lost any EH edges, so we only need
1540 to handle two cases here:
1541 (1) reachable handler and an existing edge to post-landing-pad,
1542 (2) no reachable handler and no edge. */
1543 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1546 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1548 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1549 e
->flags
|= (CALL_P (BB_END (bb
))
1550 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1556 /* This section handles removing dead code for flow. */
1559 remove_eh_landing_pad (eh_landing_pad lp
)
1563 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1567 if (lp
->post_landing_pad
)
1568 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1569 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1572 /* Splice the EH region at PP from the region tree. */
1575 remove_eh_handler_splicer (eh_region
*pp
)
1577 eh_region region
= *pp
;
1580 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1582 if (lp
->post_landing_pad
)
1583 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1584 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1590 outer
= region
->outer
;
1592 *pp
= p
= region
->inner
;
1601 *pp
= region
->next_peer
;
1603 (*cfun
->eh
->region_array
)[region
->index
] = NULL
;
1606 /* Splice a single EH region REGION from the region tree.
1608 To unlink REGION, we need to find the pointer to it with a relatively
1609 expensive search in REGION's outer region. If you are going to
1610 remove a number of handlers, using remove_unreachable_eh_regions may
1611 be a better option. */
1614 remove_eh_handler (eh_region region
)
1616 eh_region
*pp
, *pp_start
, p
, outer
;
1618 outer
= region
->outer
;
1620 pp_start
= &outer
->inner
;
1622 pp_start
= &cfun
->eh
->region_tree
;
1623 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1626 remove_eh_handler_splicer (pp
);
1629 /* Worker for remove_unreachable_eh_regions.
1630 PP is a pointer to the region to start a region tree depth-first
1631 search from. R_REACHABLE is the set of regions that have to be
1635 remove_unreachable_eh_regions_worker (eh_region
*pp
, sbitmap r_reachable
)
1639 eh_region region
= *pp
;
1640 remove_unreachable_eh_regions_worker (®ion
->inner
, r_reachable
);
1641 if (!bitmap_bit_p (r_reachable
, region
->index
))
1642 remove_eh_handler_splicer (pp
);
1644 pp
= ®ion
->next_peer
;
1648 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1649 Do this by traversing the EH tree top-down and splice out regions that
1650 are not marked. By removing regions from the leaves, we avoid costly
1651 searches in the region tree. */
1654 remove_unreachable_eh_regions (sbitmap r_reachable
)
1656 remove_unreachable_eh_regions_worker (&cfun
->eh
->region_tree
, r_reachable
);
1659 /* Invokes CALLBACK for every exception handler landing pad label.
1660 Only used by reload hackery; should not be used by new code. */
1663 for_each_eh_label (void (*callback
) (rtx
))
1668 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1672 rtx_code_label
*lab
= lp
->landing_pad
;
1673 if (lab
&& LABEL_P (lab
))
1679 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1682 At the gimple level, we use LP_NR
1683 > 0 : The statement transfers to landing pad LP_NR
1684 = 0 : The statement is outside any EH region
1685 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1687 At the rtl level, we use LP_NR
1688 > 0 : The insn transfers to landing pad LP_NR
1689 = 0 : The insn cannot throw
1690 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1691 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1692 missing note: The insn is outside any EH region.
1694 ??? This difference probably ought to be avoided. We could stand
1695 to record nothrow for arbitrary gimple statements, and so avoid
1696 some moderately complex lookups in stmt_could_throw_p. Perhaps
1697 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1698 no-nonlocal-goto property should be recorded elsewhere as a bit
1699 on the call_insn directly. Perhaps we should make more use of
1700 attaching the trees to call_insns (reachable via symbol_ref in
1701 direct call cases) and just pull the data out of the trees. */
1704 make_reg_eh_region_note (rtx_insn
*insn
, int ecf_flags
, int lp_nr
)
1707 if (ecf_flags
& ECF_NOTHROW
)
1709 else if (lp_nr
!= 0)
1710 value
= GEN_INT (lp_nr
);
1713 add_reg_note (insn
, REG_EH_REGION
, value
);
1716 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1717 nor perform a non-local goto. Replace the region note if it
1721 make_reg_eh_region_note_nothrow_nononlocal (rtx_insn
*insn
)
1723 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1724 rtx intmin
= GEN_INT (INT_MIN
);
1727 XEXP (note
, 0) = intmin
;
1729 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1732 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1736 insn_could_throw_p (const_rtx insn
)
1738 if (!flag_exceptions
)
1742 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1743 return may_trap_p (PATTERN (insn
));
1747 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1748 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1749 to look for a note, or the note itself. */
1752 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx_insn
*first
, rtx last
)
1755 rtx note
= note_or_insn
;
1757 if (INSN_P (note_or_insn
))
1759 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1763 note
= XEXP (note
, 0);
1765 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1766 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1767 && insn_could_throw_p (insn
))
1768 add_reg_note (insn
, REG_EH_REGION
, note
);
1771 /* Likewise, but iterate backward. */
1774 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx_insn
*last
, rtx first
)
1777 rtx note
= note_or_insn
;
1779 if (INSN_P (note_or_insn
))
1781 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1785 note
= XEXP (note
, 0);
1787 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1788 if (insn_could_throw_p (insn
))
1789 add_reg_note (insn
, REG_EH_REGION
, note
);
1793 /* Extract all EH information from INSN. Return true if the insn
1794 was marked NOTHROW. */
1797 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1798 eh_landing_pad
*plp
)
1800 eh_landing_pad lp
= NULL
;
1806 if (! INSN_P (insn
))
1809 if (NONJUMP_INSN_P (insn
)
1810 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1811 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1813 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1816 ret
= !insn_could_throw_p (insn
);
1820 lp_nr
= INTVAL (XEXP (note
, 0));
1821 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1828 r
= (*cfun
->eh
->region_array
)[-lp_nr
];
1831 lp
= (*cfun
->eh
->lp_array
)[lp_nr
];
1841 /* Return the landing pad to which INSN may go, or NULL if it does not
1842 have a reachable landing pad within this function. */
1845 get_eh_landing_pad_from_rtx (const_rtx insn
)
1850 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1854 /* Return the region to which INSN may go, or NULL if it does not
1855 have a reachable region within this function. */
1858 get_eh_region_from_rtx (const_rtx insn
)
1863 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1867 /* Return true if INSN throws and is caught by something in this function. */
1870 can_throw_internal (const_rtx insn
)
1872 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1875 /* Return true if INSN throws and escapes from the current function. */
1878 can_throw_external (const_rtx insn
)
1884 if (! INSN_P (insn
))
1887 if (NONJUMP_INSN_P (insn
)
1888 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1890 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1891 int i
, n
= seq
->len ();
1893 for (i
= 0; i
< n
; i
++)
1894 if (can_throw_external (seq
->element (i
)))
1900 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1902 /* If we can't throw, we obviously can't throw external. */
1906 /* If we have an internal landing pad, then we're not external. */
1910 /* If we're not within an EH region, then we are external. */
1914 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1915 which don't always have landing pads. */
1916 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1920 /* Return true if INSN cannot throw at all. */
1923 insn_nothrow_p (const_rtx insn
)
1928 if (! INSN_P (insn
))
1931 if (NONJUMP_INSN_P (insn
)
1932 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1934 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1935 int i
, n
= seq
->len ();
1937 for (i
= 0; i
< n
; i
++)
1938 if (!insn_nothrow_p (seq
->element (i
)))
1944 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1947 /* Return true if INSN can perform a non-local goto. */
1948 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1951 can_nonlocal_goto (const rtx_insn
*insn
)
1953 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1955 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1956 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1962 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1965 set_nothrow_function_flags (void)
1971 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1972 something that can throw an exception. We specifically exempt
1973 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1974 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1977 crtl
->all_throwers_are_sibcalls
= 1;
1979 /* If we don't know that this implementation of the function will
1980 actually be used, then we must not set TREE_NOTHROW, since
1981 callers must not assume that this function does not throw. */
1982 if (TREE_NOTHROW (current_function_decl
))
1985 if (! flag_exceptions
)
1988 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1989 if (can_throw_external (insn
))
1993 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1995 crtl
->all_throwers_are_sibcalls
= 0;
2001 && (cgraph_node::get (current_function_decl
)->get_availability ()
2002 >= AVAIL_AVAILABLE
))
2004 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
2005 struct cgraph_edge
*e
;
2006 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2007 e
->can_throw_external
= false;
2008 node
->set_nothrow_flag (true);
2011 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
2012 current_function_name ());
2019 const pass_data pass_data_set_nothrow_function_flags
=
2021 RTL_PASS
, /* type */
2022 "nothrow", /* name */
2023 OPTGROUP_NONE
, /* optinfo_flags */
2024 TV_NONE
, /* tv_id */
2025 0, /* properties_required */
2026 0, /* properties_provided */
2027 0, /* properties_destroyed */
2028 0, /* todo_flags_start */
2029 0, /* todo_flags_finish */
2032 class pass_set_nothrow_function_flags
: public rtl_opt_pass
2035 pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2036 : rtl_opt_pass (pass_data_set_nothrow_function_flags
, ctxt
)
2039 /* opt_pass methods: */
2040 virtual unsigned int execute (function
*)
2042 return set_nothrow_function_flags ();
2045 }; // class pass_set_nothrow_function_flags
2050 make_pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2052 return new pass_set_nothrow_function_flags (ctxt
);
2056 /* Various hooks for unwind library. */
2058 /* Expand the EH support builtin functions:
2059 __builtin_eh_pointer and __builtin_eh_filter. */
2062 expand_builtin_eh_common (tree region_nr_t
)
2064 HOST_WIDE_INT region_nr
;
2067 gcc_assert (tree_fits_shwi_p (region_nr_t
));
2068 region_nr
= tree_to_shwi (region_nr_t
);
2070 region
= (*cfun
->eh
->region_array
)[region_nr
];
2072 /* ??? We shouldn't have been able to delete a eh region without
2073 deleting all the code that depended on it. */
2074 gcc_assert (region
!= NULL
);
2079 /* Expand to the exc_ptr value from the given eh region. */
2082 expand_builtin_eh_pointer (tree exp
)
2085 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2086 if (region
->exc_ptr_reg
== NULL
)
2087 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2088 return region
->exc_ptr_reg
;
2091 /* Expand to the filter value from the given eh region. */
2094 expand_builtin_eh_filter (tree exp
)
2097 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2098 if (region
->filter_reg
== NULL
)
2099 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
2100 return region
->filter_reg
;
2103 /* Copy the exc_ptr and filter values from one landing pad's registers
2104 to another. This is used to inline the resx statement. */
2107 expand_builtin_eh_copy_values (tree exp
)
2110 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2112 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
2113 machine_mode fmode
= targetm
.eh_return_filter_mode ();
2115 if (dst
->exc_ptr_reg
== NULL
)
2116 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2117 if (src
->exc_ptr_reg
== NULL
)
2118 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2120 if (dst
->filter_reg
== NULL
)
2121 dst
->filter_reg
= gen_reg_rtx (fmode
);
2122 if (src
->filter_reg
== NULL
)
2123 src
->filter_reg
= gen_reg_rtx (fmode
);
2125 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2126 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2131 /* Do any necessary initialization to access arbitrary stack frames.
2132 On the SPARC, this means flushing the register windows. */
2135 expand_builtin_unwind_init (void)
2137 /* Set this so all the registers get saved in our frame; we need to be
2138 able to copy the saved values for any registers from frames we unwind. */
2139 crtl
->saves_all_registers
= 1;
2141 #ifdef SETUP_FRAME_ADDRESSES
2142 SETUP_FRAME_ADDRESSES ();
2146 /* Map a non-negative number to an eh return data register number; expands
2147 to -1 if no return data register is associated with the input number.
2148 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2151 expand_builtin_eh_return_data_regno (tree exp
)
2153 tree which
= CALL_EXPR_ARG (exp
, 0);
2154 unsigned HOST_WIDE_INT iwhich
;
2156 if (TREE_CODE (which
) != INTEGER_CST
)
2158 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2162 iwhich
= tree_to_uhwi (which
);
2163 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2164 if (iwhich
== INVALID_REGNUM
)
2167 #ifdef DWARF_FRAME_REGNUM
2168 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2170 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2173 return GEN_INT (iwhich
);
2176 /* Given a value extracted from the return address register or stack slot,
2177 return the actual address encoded in that value. */
2180 expand_builtin_extract_return_addr (tree addr_tree
)
2182 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2184 if (GET_MODE (addr
) != Pmode
2185 && GET_MODE (addr
) != VOIDmode
)
2187 #ifdef POINTERS_EXTEND_UNSIGNED
2188 addr
= convert_memory_address (Pmode
, addr
);
2190 addr
= convert_to_mode (Pmode
, addr
, 0);
2194 /* First mask out any unwanted bits. */
2195 rtx mask
= MASK_RETURN_ADDR
;
2197 expand_and (Pmode
, addr
, mask
, addr
);
2199 /* Then adjust to find the real return address. */
2200 if (RETURN_ADDR_OFFSET
)
2201 addr
= plus_constant (Pmode
, addr
, RETURN_ADDR_OFFSET
);
2206 /* Given an actual address in addr_tree, do any necessary encoding
2207 and return the value to be stored in the return address register or
2208 stack slot so the epilogue will return to that address. */
2211 expand_builtin_frob_return_addr (tree addr_tree
)
2213 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2215 addr
= convert_memory_address (Pmode
, addr
);
2217 if (RETURN_ADDR_OFFSET
)
2219 addr
= force_reg (Pmode
, addr
);
2220 addr
= plus_constant (Pmode
, addr
, -RETURN_ADDR_OFFSET
);
2226 /* Set up the epilogue with the magic bits we'll need to return to the
2227 exception handler. */
2230 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2235 #ifdef EH_RETURN_STACKADJ_RTX
2236 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2237 VOIDmode
, EXPAND_NORMAL
);
2238 tmp
= convert_memory_address (Pmode
, tmp
);
2239 if (!crtl
->eh
.ehr_stackadj
)
2240 crtl
->eh
.ehr_stackadj
= copy_to_reg (tmp
);
2241 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2242 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2245 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2246 VOIDmode
, EXPAND_NORMAL
);
2247 tmp
= convert_memory_address (Pmode
, tmp
);
2248 if (!crtl
->eh
.ehr_handler
)
2249 crtl
->eh
.ehr_handler
= copy_to_reg (tmp
);
2250 else if (tmp
!= crtl
->eh
.ehr_handler
)
2251 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2253 if (!crtl
->eh
.ehr_label
)
2254 crtl
->eh
.ehr_label
= gen_label_rtx ();
2255 emit_jump (crtl
->eh
.ehr_label
);
2258 /* Expand __builtin_eh_return. This exit path from the function loads up
2259 the eh return data registers, adjusts the stack, and branches to a
2260 given PC other than the normal return address. */
2263 expand_eh_return (void)
2265 rtx_code_label
*around_label
;
2267 if (! crtl
->eh
.ehr_label
)
2270 crtl
->calls_eh_return
= 1;
2272 #ifdef EH_RETURN_STACKADJ_RTX
2273 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2276 around_label
= gen_label_rtx ();
2277 emit_jump (around_label
);
2279 emit_label (crtl
->eh
.ehr_label
);
2280 clobber_return_register ();
2282 #ifdef EH_RETURN_STACKADJ_RTX
2283 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2286 #ifdef HAVE_eh_return
2288 emit_insn (gen_eh_return (crtl
->eh
.ehr_handler
));
2292 #ifdef EH_RETURN_HANDLER_RTX
2293 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2295 error ("__builtin_eh_return not supported on this target");
2299 emit_label (around_label
);
2302 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2303 POINTERS_EXTEND_UNSIGNED and return it. */
2306 expand_builtin_extend_pointer (tree addr_tree
)
2308 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2311 #ifdef POINTERS_EXTEND_UNSIGNED
2312 extend
= POINTERS_EXTEND_UNSIGNED
;
2314 /* The previous EH code did an unsigned extend by default, so we do this also
2319 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2323 add_action_record (action_hash_type
*ar_hash
, int filter
, int next
)
2325 struct action_record
**slot
, *new_ar
, tmp
;
2327 tmp
.filter
= filter
;
2329 slot
= ar_hash
->find_slot (&tmp
, INSERT
);
2331 if ((new_ar
= *slot
) == NULL
)
2333 new_ar
= XNEW (struct action_record
);
2334 new_ar
->offset
= crtl
->eh
.action_record_data
->length () + 1;
2335 new_ar
->filter
= filter
;
2336 new_ar
->next
= next
;
2339 /* The filter value goes in untouched. The link to the next
2340 record is a "self-relative" byte offset, or zero to indicate
2341 that there is no next record. So convert the absolute 1 based
2342 indices we've been carrying around into a displacement. */
2344 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2346 next
-= crtl
->eh
.action_record_data
->length () + 1;
2347 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2350 return new_ar
->offset
;
2354 collect_one_action_chain (action_hash_type
*ar_hash
, eh_region region
)
2358 /* If we've reached the top of the region chain, then we have
2359 no actions, and require no landing pad. */
2363 switch (region
->type
)
2368 /* A cleanup adds a zero filter to the beginning of the chain, but
2369 there are special cases to look out for. If there are *only*
2370 cleanups along a path, then it compresses to a zero action.
2371 Further, if there are multiple cleanups along a path, we only
2372 need to represent one of them, as that is enough to trigger
2373 entry to the landing pad at runtime. */
2374 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2377 for (r
= region
->outer
; r
; r
= r
->outer
)
2378 if (r
->type
== ERT_CLEANUP
)
2380 return add_action_record (ar_hash
, 0, next
);
2387 /* Process the associated catch regions in reverse order.
2388 If there's a catch-all handler, then we don't need to
2389 search outer regions. Use a magic -3 value to record
2390 that we haven't done the outer search. */
2392 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2394 if (c
->type_list
== NULL
)
2396 /* Retrieve the filter from the head of the filter list
2397 where we have stored it (see assign_filter_values). */
2398 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2399 next
= add_action_record (ar_hash
, filter
, 0);
2403 /* Once the outer search is done, trigger an action record for
2404 each filter we have. */
2409 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2411 /* If there is no next action, terminate the chain. */
2414 /* If all outer actions are cleanups or must_not_throw,
2415 we'll have no action record for it, since we had wanted
2416 to encode these states in the call-site record directly.
2417 Add a cleanup action to the chain to catch these. */
2419 next
= add_action_record (ar_hash
, 0, 0);
2422 flt_node
= c
->filter_list
;
2423 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2425 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2426 next
= add_action_record (ar_hash
, filter
, next
);
2433 case ERT_ALLOWED_EXCEPTIONS
:
2434 /* An exception specification adds its filter to the
2435 beginning of the chain. */
2436 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2438 /* If there is no next action, terminate the chain. */
2441 /* If all outer actions are cleanups or must_not_throw,
2442 we'll have no action record for it, since we had wanted
2443 to encode these states in the call-site record directly.
2444 Add a cleanup action to the chain to catch these. */
2446 next
= add_action_record (ar_hash
, 0, 0);
2448 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2450 case ERT_MUST_NOT_THROW
:
2451 /* A must-not-throw region with no inner handlers or cleanups
2452 requires no call-site entry. Note that this differs from
2453 the no handler or cleanup case in that we do require an lsda
2454 to be generated. Return a magic -2 value to record this. */
2462 add_call_site (rtx landing_pad
, int action
, int section
)
2464 call_site_record record
;
2466 record
= ggc_alloc
<call_site_record_d
> ();
2467 record
->landing_pad
= landing_pad
;
2468 record
->action
= action
;
2470 vec_safe_push (crtl
->eh
.call_site_record_v
[section
], record
);
2472 return call_site_base
+ crtl
->eh
.call_site_record_v
[section
]->length () - 1;
2476 emit_note_eh_region_end (rtx_insn
*insn
)
2478 rtx_insn
*next
= NEXT_INSN (insn
);
2480 /* Make sure we do not split a call and its corresponding
2481 CALL_ARG_LOCATION note. */
2482 if (next
&& NOTE_P (next
)
2483 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
2486 return emit_note_after (NOTE_INSN_EH_REGION_END
, insn
);
2489 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2490 The new note numbers will not refer to region numbers, but
2491 instead to call site entries. */
2494 convert_to_eh_region_ranges (void)
2499 action_hash_type
ar_hash (31);
2500 int last_action
= -3;
2501 rtx_insn
*last_action_insn
= NULL
;
2502 rtx last_landing_pad
= NULL_RTX
;
2503 rtx_insn
*first_no_action_insn
= NULL
;
2506 rtx_insn
*section_switch_note
= NULL
;
2507 rtx_insn
*first_no_action_insn_before_switch
= NULL
;
2508 rtx_insn
*last_no_action_insn_before_switch
= NULL
;
2509 int saved_call_site_base
= call_site_base
;
2511 vec_alloc (crtl
->eh
.action_record_data
, 64);
2513 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2520 rtx_code_label
*this_landing_pad
;
2523 if (NONJUMP_INSN_P (insn
)
2524 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2525 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2527 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2531 this_action
= collect_one_action_chain (&ar_hash
, region
);
2535 /* Existence of catch handlers, or must-not-throw regions
2536 implies that an lsda is needed (even if empty). */
2537 if (this_action
!= -1)
2538 crtl
->uses_eh_lsda
= 1;
2540 /* Delay creation of region notes for no-action regions
2541 until we're sure that an lsda will be required. */
2542 else if (last_action
== -3)
2544 first_no_action_insn
= iter
;
2548 if (this_action
>= 0)
2549 this_landing_pad
= lp
->landing_pad
;
2551 this_landing_pad
= NULL
;
2553 /* Differing actions or landing pads implies a change in call-site
2554 info, which implies some EH_REGION note should be emitted. */
2555 if (last_action
!= this_action
2556 || last_landing_pad
!= this_landing_pad
)
2558 /* If there is a queued no-action region in the other section
2559 with hot/cold partitioning, emit it now. */
2560 if (first_no_action_insn_before_switch
)
2562 gcc_assert (this_action
!= -1
2563 && last_action
== (first_no_action_insn
2565 call_site
= add_call_site (NULL_RTX
, 0, 0);
2566 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2567 first_no_action_insn_before_switch
);
2568 NOTE_EH_HANDLER (note
) = call_site
;
2570 = emit_note_eh_region_end (last_no_action_insn_before_switch
);
2571 NOTE_EH_HANDLER (note
) = call_site
;
2572 gcc_assert (last_action
!= -3
2573 || (last_action_insn
2574 == last_no_action_insn_before_switch
));
2575 first_no_action_insn_before_switch
= NULL
;
2576 last_no_action_insn_before_switch
= NULL
;
2579 /* If we'd not seen a previous action (-3) or the previous
2580 action was must-not-throw (-2), then we do not need an
2582 if (last_action
>= -1)
2584 /* If we delayed the creation of the begin, do it now. */
2585 if (first_no_action_insn
)
2587 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2588 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2589 first_no_action_insn
);
2590 NOTE_EH_HANDLER (note
) = call_site
;
2591 first_no_action_insn
= NULL
;
2594 note
= emit_note_eh_region_end (last_action_insn
);
2595 NOTE_EH_HANDLER (note
) = call_site
;
2598 /* If the new action is must-not-throw, then no region notes
2600 if (this_action
>= -1)
2602 call_site
= add_call_site (this_landing_pad
,
2603 this_action
< 0 ? 0 : this_action
,
2605 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2606 NOTE_EH_HANDLER (note
) = call_site
;
2609 last_action
= this_action
;
2610 last_landing_pad
= this_landing_pad
;
2612 last_action_insn
= iter
;
2614 else if (NOTE_P (iter
)
2615 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2617 gcc_assert (section_switch_note
== NULL_RTX
);
2618 gcc_assert (flag_reorder_blocks_and_partition
);
2619 section_switch_note
= iter
;
2620 if (first_no_action_insn
)
2622 first_no_action_insn_before_switch
= first_no_action_insn
;
2623 last_no_action_insn_before_switch
= last_action_insn
;
2624 first_no_action_insn
= NULL
;
2625 gcc_assert (last_action
== -1);
2628 /* Force closing of current EH region before section switch and
2629 opening a new one afterwards. */
2630 else if (last_action
!= -3)
2631 last_landing_pad
= pc_rtx
;
2632 if (crtl
->eh
.call_site_record_v
[cur_sec
])
2633 call_site_base
+= crtl
->eh
.call_site_record_v
[cur_sec
]->length ();
2635 gcc_assert (crtl
->eh
.call_site_record_v
[cur_sec
] == NULL
);
2636 vec_alloc (crtl
->eh
.call_site_record_v
[cur_sec
], 10);
2639 if (last_action
>= -1 && ! first_no_action_insn
)
2641 note
= emit_note_eh_region_end (last_action_insn
);
2642 NOTE_EH_HANDLER (note
) = call_site
;
2645 call_site_base
= saved_call_site_base
;
2652 const pass_data pass_data_convert_to_eh_region_ranges
=
2654 RTL_PASS
, /* type */
2655 "eh_ranges", /* name */
2656 OPTGROUP_NONE
, /* optinfo_flags */
2657 TV_NONE
, /* tv_id */
2658 0, /* properties_required */
2659 0, /* properties_provided */
2660 0, /* properties_destroyed */
2661 0, /* todo_flags_start */
2662 0, /* todo_flags_finish */
2665 class pass_convert_to_eh_region_ranges
: public rtl_opt_pass
2668 pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2669 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges
, ctxt
)
2672 /* opt_pass methods: */
2673 virtual bool gate (function
*);
2674 virtual unsigned int execute (function
*)
2676 return convert_to_eh_region_ranges ();
2679 }; // class pass_convert_to_eh_region_ranges
2682 pass_convert_to_eh_region_ranges::gate (function
*)
2684 /* Nothing to do for SJLJ exceptions or if no regions created. */
2685 if (cfun
->eh
->region_tree
== NULL
)
2687 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2695 make_pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2697 return new pass_convert_to_eh_region_ranges (ctxt
);
2701 push_uleb128 (vec
<uchar
, va_gc
> **data_area
, unsigned int value
)
2705 unsigned char byte
= value
& 0x7f;
2709 vec_safe_push (*data_area
, byte
);
2715 push_sleb128 (vec
<uchar
, va_gc
> **data_area
, int value
)
2722 byte
= value
& 0x7f;
2724 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2725 || (value
== -1 && (byte
& 0x40) != 0));
2728 vec_safe_push (*data_area
, byte
);
2734 #ifndef HAVE_AS_LEB128
2736 dw2_size_of_call_site_table (int section
)
2738 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2739 int size
= n
* (4 + 4 + 4);
2742 for (i
= 0; i
< n
; ++i
)
2744 struct call_site_record_d
*cs
=
2745 (*crtl
->eh
.call_site_record_v
[section
])[i
];
2746 size
+= size_of_uleb128 (cs
->action
);
2753 sjlj_size_of_call_site_table (void)
2755 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2759 for (i
= 0; i
< n
; ++i
)
2761 struct call_site_record_d
*cs
=
2762 (*crtl
->eh
.call_site_record_v
[0])[i
];
2763 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2764 size
+= size_of_uleb128 (cs
->action
);
2772 dw2_output_call_site_table (int cs_format
, int section
)
2774 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2779 begin
= current_function_func_begin_label
;
2780 else if (first_function_block_is_cold
)
2781 begin
= crtl
->subsections
.hot_section_label
;
2783 begin
= crtl
->subsections
.cold_section_label
;
2785 for (i
= 0; i
< n
; ++i
)
2787 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[section
])[i
];
2788 char reg_start_lab
[32];
2789 char reg_end_lab
[32];
2790 char landing_pad_lab
[32];
2792 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2793 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2795 if (cs
->landing_pad
)
2796 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2797 CODE_LABEL_NUMBER (cs
->landing_pad
));
2799 /* ??? Perhaps use insn length scaling if the assembler supports
2800 generic arithmetic. */
2801 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2802 data4 if the function is small enough. */
2803 if (cs_format
== DW_EH_PE_uleb128
)
2805 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2806 "region %d start", i
);
2807 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2809 if (cs
->landing_pad
)
2810 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2813 dw2_asm_output_data_uleb128 (0, "landing pad");
2817 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2818 "region %d start", i
);
2819 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2820 if (cs
->landing_pad
)
2821 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2824 dw2_asm_output_data (4, 0, "landing pad");
2826 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2829 call_site_base
+= n
;
2833 sjlj_output_call_site_table (void)
2835 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2838 for (i
= 0; i
< n
; ++i
)
2840 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[0])[i
];
2842 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2843 "region %d landing pad", i
);
2844 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2847 call_site_base
+= n
;
2850 /* Switch to the section that should be used for exception tables. */
2853 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2857 if (exception_section
)
2858 s
= exception_section
;
2861 /* Compute the section and cache it into exception_section,
2862 unless it depends on the function name. */
2863 if (targetm_common
.have_named_sections
)
2867 if (EH_TABLES_CAN_BE_READ_ONLY
)
2870 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2871 flags
= ((! flag_pic
2872 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2873 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2874 ? 0 : SECTION_WRITE
);
2877 flags
= SECTION_WRITE
;
2879 #ifdef HAVE_LD_EH_GC_SECTIONS
2880 if (flag_function_sections
2881 || (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
))
2883 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2884 /* The EH table must match the code section, so only mark
2885 it linkonce if we have COMDAT groups to tie them together. */
2886 if (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
)
2887 flags
|= SECTION_LINKONCE
;
2888 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2889 s
= get_section (section_name
, flags
, current_function_decl
);
2890 free (section_name
);
2895 = s
= get_section (".gcc_except_table", flags
, NULL
);
2899 = s
= flag_pic
? data_section
: readonly_data_section
;
2902 switch_to_section (s
);
2906 /* Output a reference from an exception table to the type_info object TYPE.
2907 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2911 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2914 bool is_public
= true;
2916 if (type
== NULL_TREE
)
2920 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2921 runtime types so TYPE should already be a runtime type
2922 reference. When pass_ipa_free_lang data is made a default
2923 pass, we can then remove the call to lookup_type_for_runtime
2926 type
= lookup_type_for_runtime (type
);
2928 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2930 /* Let cgraph know that the rtti decl is used. Not all of the
2931 paths below go through assemble_integer, which would take
2932 care of this for us. */
2934 if (TREE_CODE (type
) == ADDR_EXPR
)
2936 type
= TREE_OPERAND (type
, 0);
2937 if (TREE_CODE (type
) == VAR_DECL
)
2938 is_public
= TREE_PUBLIC (type
);
2941 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2944 /* Allow the target to override the type table entry format. */
2945 if (targetm
.asm_out
.ttype (value
))
2948 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2949 assemble_integer (value
, tt_format_size
,
2950 tt_format_size
* BITS_PER_UNIT
, 1);
2952 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2956 output_one_function_exception_table (int section
)
2958 int tt_format
, cs_format
, lp_format
, i
;
2959 #ifdef HAVE_AS_LEB128
2960 char ttype_label
[32];
2961 char cs_after_size_label
[32];
2962 char cs_end_label
[32];
2967 int tt_format_size
= 0;
2969 have_tt_data
= (vec_safe_length (cfun
->eh
->ttype_data
)
2970 || (targetm
.arm_eabi_unwinder
2971 ? vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
)
2972 : vec_safe_length (cfun
->eh
->ehspec_data
.other
)));
2974 /* Indicate the format of the @TType entries. */
2976 tt_format
= DW_EH_PE_omit
;
2979 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2980 #ifdef HAVE_AS_LEB128
2981 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2982 section
? "LLSDATTC" : "LLSDATT",
2983 current_function_funcdef_no
);
2985 tt_format_size
= size_of_encoded_value (tt_format
);
2987 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2990 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2991 current_function_funcdef_no
);
2993 /* The LSDA header. */
2995 /* Indicate the format of the landing pad start pointer. An omitted
2996 field implies @LPStart == @Start. */
2997 /* Currently we always put @LPStart == @Start. This field would
2998 be most useful in moving the landing pads completely out of
2999 line to another section, but it could also be used to minimize
3000 the size of uleb128 landing pad offsets. */
3001 lp_format
= DW_EH_PE_omit
;
3002 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
3003 eh_data_format_name (lp_format
));
3005 /* @LPStart pointer would go here. */
3007 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
3008 eh_data_format_name (tt_format
));
3010 #ifndef HAVE_AS_LEB128
3011 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3012 call_site_len
= sjlj_size_of_call_site_table ();
3014 call_site_len
= dw2_size_of_call_site_table (section
);
3017 /* A pc-relative 4-byte displacement to the @TType data. */
3020 #ifdef HAVE_AS_LEB128
3021 char ttype_after_disp_label
[32];
3022 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
3023 section
? "LLSDATTDC" : "LLSDATTD",
3024 current_function_funcdef_no
);
3025 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3026 "@TType base offset");
3027 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3029 /* Ug. Alignment queers things. */
3030 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3032 before_disp
= 1 + 1;
3033 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3035 + vec_safe_length (crtl
->eh
.action_record_data
)
3036 + (vec_safe_length (cfun
->eh
->ttype_data
)
3042 unsigned int disp_size
, pad
;
3045 disp_size
= size_of_uleb128 (disp
);
3046 pad
= before_disp
+ disp_size
+ after_disp
;
3047 if (pad
% tt_format_size
)
3048 pad
= tt_format_size
- (pad
% tt_format_size
);
3051 disp
= after_disp
+ pad
;
3053 while (disp
!= last_disp
);
3055 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3059 /* Indicate the format of the call-site offsets. */
3060 #ifdef HAVE_AS_LEB128
3061 cs_format
= DW_EH_PE_uleb128
;
3063 cs_format
= DW_EH_PE_udata4
;
3065 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3066 eh_data_format_name (cs_format
));
3068 #ifdef HAVE_AS_LEB128
3069 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3070 section
? "LLSDACSBC" : "LLSDACSB",
3071 current_function_funcdef_no
);
3072 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3073 section
? "LLSDACSEC" : "LLSDACSE",
3074 current_function_funcdef_no
);
3075 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3076 "Call-site table length");
3077 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3078 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3079 sjlj_output_call_site_table ();
3081 dw2_output_call_site_table (cs_format
, section
);
3082 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3084 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3085 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3086 sjlj_output_call_site_table ();
3088 dw2_output_call_site_table (cs_format
, section
);
3091 /* ??? Decode and interpret the data for flag_debug_asm. */
3094 FOR_EACH_VEC_ELT (*crtl
->eh
.action_record_data
, i
, uc
)
3095 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3099 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3101 i
= vec_safe_length (cfun
->eh
->ttype_data
);
3104 tree type
= (*cfun
->eh
->ttype_data
)[i
];
3105 output_ttype (type
, tt_format
, tt_format_size
);
3108 #ifdef HAVE_AS_LEB128
3110 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3113 /* ??? Decode and interpret the data for flag_debug_asm. */
3114 if (targetm
.arm_eabi_unwinder
)
3118 vec_safe_iterate (cfun
->eh
->ehspec_data
.arm_eabi
, i
, &type
); ++i
)
3119 output_ttype (type
, tt_format
, tt_format_size
);
3125 vec_safe_iterate (cfun
->eh
->ehspec_data
.other
, i
, &uc
); ++i
)
3126 dw2_asm_output_data (1, uc
,
3127 i
? NULL
: "Exception specification table");
3132 output_function_exception_table (const char *fnname
)
3134 rtx personality
= get_personality_function (current_function_decl
);
3136 /* Not all functions need anything. */
3137 if (! crtl
->uses_eh_lsda
)
3142 assemble_external_libcall (personality
);
3144 if (targetm
.asm_out
.emit_except_personality
)
3145 targetm
.asm_out
.emit_except_personality (personality
);
3148 switch_to_exception_section (fnname
);
3150 /* If the target wants a label to begin the table, emit it here. */
3151 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3153 output_one_function_exception_table (0);
3154 if (crtl
->eh
.call_site_record_v
[1])
3155 output_one_function_exception_table (1);
3157 switch_to_section (current_function_section ());
3161 set_eh_throw_stmt_table (function
*fun
, hash_map
<gimple
, int> *table
)
3163 fun
->eh
->throw_stmt_table
= table
;
3166 hash_map
<gimple
, int> *
3167 get_eh_throw_stmt_table (struct function
*fun
)
3169 return fun
->eh
->throw_stmt_table
;
3172 /* Determine if the function needs an EH personality function. */
3174 enum eh_personality_kind
3175 function_needs_eh_personality (struct function
*fn
)
3177 enum eh_personality_kind kind
= eh_personality_none
;
3180 FOR_ALL_EH_REGION_FN (i
, fn
)
3185 /* Can do with any personality including the generic C one. */
3186 kind
= eh_personality_any
;
3190 case ERT_ALLOWED_EXCEPTIONS
:
3191 /* Always needs a EH personality function. The generic C
3192 personality doesn't handle these even for empty type lists. */
3193 return eh_personality_lang
;
3195 case ERT_MUST_NOT_THROW
:
3196 /* Always needs a EH personality function. The language may specify
3197 what abort routine that must be used, e.g. std::terminate. */
3198 return eh_personality_lang
;
3205 /* Dump EH information to OUT. */
3208 dump_eh_tree (FILE * out
, struct function
*fun
)
3212 static const char *const type_name
[] = {
3213 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3216 i
= fun
->eh
->region_tree
;
3220 fprintf (out
, "Eh tree:\n");
3223 fprintf (out
, " %*s %i %s", depth
* 2, "",
3224 i
->index
, type_name
[(int) i
->type
]);
3226 if (i
->landing_pads
)
3230 fprintf (out
, " land:");
3231 if (current_ir_type () == IR_GIMPLE
)
3233 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3235 fprintf (out
, "{%i,", lp
->index
);
3236 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3244 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3246 fprintf (out
, "{%i,", lp
->index
);
3247 if (lp
->landing_pad
)
3248 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3249 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3251 fprintf (out
, "(nil),");
3252 if (lp
->post_landing_pad
)
3254 rtx_insn
*lab
= label_rtx (lp
->post_landing_pad
);
3255 fprintf (out
, "%i%s}", INSN_UID (lab
),
3256 NOTE_P (lab
) ? "(del)" : "");
3259 fprintf (out
, "(nil)}");
3269 case ERT_MUST_NOT_THROW
:
3275 fprintf (out
, " catch:");
3276 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3281 fprintf (out
, "lab:");
3282 print_generic_expr (out
, c
->label
, 0);
3285 print_generic_expr (out
, c
->type_list
, 0);
3293 case ERT_ALLOWED_EXCEPTIONS
:
3294 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3295 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3300 /* If there are sub-regions, process them. */
3302 i
= i
->inner
, depth
++;
3303 /* If there are peers, process them. */
3304 else if (i
->next_peer
)
3306 /* Otherwise, step back up the tree to the next peer. */
3316 while (i
->next_peer
== NULL
);
3322 /* Dump the EH tree for FN on stderr. */
3325 debug_eh_tree (struct function
*fn
)
3327 dump_eh_tree (stderr
, fn
);
3330 /* Verify invariants on EH datastructures. */
3333 verify_eh_tree (struct function
*fun
)
3336 int nvisited_lp
, nvisited_r
;
3337 int count_lp
, count_r
, depth
, i
;
3341 if (!fun
->eh
->region_tree
)
3345 for (i
= 1; vec_safe_iterate (fun
->eh
->region_array
, i
, &r
); ++i
)
3352 error ("region_array is corrupted for region %i", r
->index
);
3358 for (i
= 1; vec_safe_iterate (fun
->eh
->lp_array
, i
, &lp
); ++i
)
3365 error ("lp_array is corrupted for lp %i", lp
->index
);
3370 depth
= nvisited_lp
= nvisited_r
= 0;
3372 r
= fun
->eh
->region_tree
;
3375 if ((*fun
->eh
->region_array
)[r
->index
] != r
)
3377 error ("region_array is corrupted for region %i", r
->index
);
3380 if (r
->outer
!= outer
)
3382 error ("outer block of region %i is wrong", r
->index
);
3387 error ("negative nesting depth of region %i", r
->index
);
3392 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3394 if ((*fun
->eh
->lp_array
)[lp
->index
] != lp
)
3396 error ("lp_array is corrupted for lp %i", lp
->index
);
3399 if (lp
->region
!= r
)
3401 error ("region of lp %i is wrong", lp
->index
);
3408 outer
= r
, r
= r
->inner
, depth
++;
3409 else if (r
->next_peer
)
3421 while (r
->next_peer
== NULL
);
3428 error ("tree list ends on depth %i", depth
);
3431 if (count_r
!= nvisited_r
)
3433 error ("region_array does not match region_tree");
3436 if (count_lp
!= nvisited_lp
)
3438 error ("lp_array does not match region_tree");
3444 dump_eh_tree (stderr
, fun
);
3445 internal_error ("verify_eh_tree failed");
3449 #include "gt-except.h"