1 /* Implements exception handling.
2 Copyright (C) 1989-2016 Free Software Foundation, Inc.
3 Contributed by Mike Stump <mrs@cygnus.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* An exception is an event that can be "thrown" from within a
23 function. This event can then be "caught" by the callers of
26 The representation of exceptions changes several times during
27 the compilation process:
29 In the beginning, in the front end, we have the GENERIC trees
30 TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
31 CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
33 During initial gimplification (gimplify.c) these are lowered
34 to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
35 The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
36 into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
39 During pass_lower_eh (tree-eh.c) we record the nested structure
40 of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
41 We expand the eh_protect_cleanup_actions langhook into MUST_NOT_THROW
42 regions at this time. We can then flatten the statements within
43 the TRY nodes to straight-line code. Statements that had been within
44 TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,
45 so that we may remember what action is supposed to be taken if
46 a given statement does throw. During this lowering process,
47 we create an EH_LANDING_PAD node for each EH_REGION that has
48 some code within the function that needs to be executed if a
49 throw does happen. We also create RESX statements that are
50 used to transfer control from an inner EH_REGION to an outer
51 EH_REGION. We also create EH_DISPATCH statements as placeholders
52 for a runtime type comparison that should be made in order to
53 select the action to perform among different CATCH and EH_FILTER
56 During pass_lower_eh_dispatch (tree-eh.c), which is run after
57 all inlining is complete, we are able to run assign_filter_values,
58 which allows us to map the set of types manipulated by all of the
59 CATCH and EH_FILTER regions to a set of integers. This set of integers
60 will be how the exception runtime communicates with the code generated
61 within the function. We then expand the GIMPLE_EH_DISPATCH statements
62 to a switch or conditional branches that use the argument provided by
63 the runtime (__builtin_eh_filter) and the set of integers we computed
64 in assign_filter_values.
66 During pass_lower_resx (tree-eh.c), which is run near the end
67 of optimization, we expand RESX statements. If the eh region
68 that is outer to the RESX statement is a MUST_NOT_THROW, then
69 the RESX expands to some form of abort statement. If the eh
70 region that is outer to the RESX statement is within the current
71 function, then the RESX expands to a bookkeeping call
72 (__builtin_eh_copy_values) and a goto. Otherwise, the next
73 handler for the exception must be within a function somewhere
74 up the call chain, so we call back into the exception runtime
75 (__builtin_unwind_resume).
77 During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
78 that create an rtl to eh_region mapping that corresponds to the
79 gimple to eh_region mapping that had been recorded in the
82 Then, via finish_eh_generation, we generate the real landing pads
83 to which the runtime will actually transfer control. These new
84 landing pads perform whatever bookkeeping is needed by the target
85 backend in order to resume execution within the current function.
86 Each of these new landing pads falls through into the post_landing_pad
87 label which had been used within the CFG up to this point. All
88 exception edges within the CFG are redirected to the new landing pads.
89 If the target uses setjmp to implement exceptions, the various extra
90 calls into the runtime to register and unregister the current stack
91 frame are emitted at this time.
93 During pass_convert_to_eh_region_ranges (except.c), we transform
94 the REG_EH_REGION notes attached to individual insns into
95 non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG
96 and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the
97 same associated action within the exception region tree, meaning
98 that (1) the exception is caught by the same landing pad within the
99 current function, (2) the exception is blocked by the runtime with
100 a MUST_NOT_THROW region, or (3) the exception is not handled at all
101 within the current function.
103 Finally, during assembly generation, we call
104 output_function_exception_table (except.c) to emit the tables with
105 which the exception runtime can determine if a given stack frame
106 handles a given exception, and if so what filter value to provide
107 to the function when the non-local control transfer is effected.
108 If the target uses dwarf2 unwinding to implement exceptions, then
109 output_call_frame_info (dwarf2out.c) emits the required unwind data. */
114 #include "coretypes.h"
119 #include "cfghooks.h"
120 #include "tree-pass.h"
122 #include "stringpool.h"
125 #include "emit-rtl.h"
127 #include "diagnostic.h"
128 #include "fold-const.h"
129 #include "stor-layout.h"
134 #include "libfuncs.h"
137 #include "dwarf2asm.h"
138 #include "dwarf2out.h"
139 #include "common/common-target.h"
140 #include "langhooks.h"
142 #include "tree-pretty-print.h"
144 #include "builtins.h"
145 #include "tree-hash-traits.h"
147 static GTY(()) int call_site_base
;
149 static GTY (()) hash_map
<tree_hash
, tree
> *type_to_runtime_map
;
151 /* Describe the SjLj_Function_Context structure. */
152 static GTY(()) tree sjlj_fc_type_node
;
153 static int sjlj_fc_call_site_ofs
;
154 static int sjlj_fc_data_ofs
;
155 static int sjlj_fc_personality_ofs
;
156 static int sjlj_fc_lsda_ofs
;
157 static int sjlj_fc_jbuf_ofs
;
160 struct GTY(()) call_site_record_d
166 /* In the following structure and associated functions,
167 we represent entries in the action table as 1-based indices.
170 0: null action record, non-null landing pad; implies cleanups
171 -1: null action record, null landing pad; implies no action
172 -2: no call-site entry; implies must_not_throw
173 -3: we have yet to process outer regions
175 Further, no special cases apply to the "next" field of the record.
176 For next, 0 means end of list. */
185 /* Hashtable helpers. */
187 struct action_record_hasher
: free_ptr_hash
<action_record
>
189 static inline hashval_t
hash (const action_record
*);
190 static inline bool equal (const action_record
*, const action_record
*);
194 action_record_hasher::hash (const action_record
*entry
)
196 return entry
->next
* 1009 + entry
->filter
;
200 action_record_hasher::equal (const action_record
*entry
,
201 const action_record
*data
)
203 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
206 typedef hash_table
<action_record_hasher
> action_hash_type
;
208 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
211 static void dw2_build_landing_pads (void);
213 static int collect_one_action_chain (action_hash_type
*, eh_region
);
214 static int add_call_site (rtx
, int, int);
216 static void push_uleb128 (vec
<uchar
, va_gc
> **, unsigned int);
217 static void push_sleb128 (vec
<uchar
, va_gc
> **, int);
218 #ifndef HAVE_AS_LEB128
219 static int dw2_size_of_call_site_table (int);
220 static int sjlj_size_of_call_site_table (void);
222 static void dw2_output_call_site_table (int, int);
223 static void sjlj_output_call_site_table (void);
229 if (! flag_exceptions
)
232 type_to_runtime_map
= hash_map
<tree_hash
, tree
>::create_ggc (31);
234 /* Create the SjLj_Function_Context structure. This should match
235 the definition in unwind-sjlj.c. */
236 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
238 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
240 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
242 f_prev
= build_decl (BUILTINS_LOCATION
,
243 FIELD_DECL
, get_identifier ("__prev"),
244 build_pointer_type (sjlj_fc_type_node
));
245 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
247 f_cs
= build_decl (BUILTINS_LOCATION
,
248 FIELD_DECL
, get_identifier ("__call_site"),
250 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
252 tmp
= build_index_type (size_int (4 - 1));
253 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
254 (targetm
.unwind_word_mode (), 1),
256 f_data
= build_decl (BUILTINS_LOCATION
,
257 FIELD_DECL
, get_identifier ("__data"), tmp
);
258 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
260 f_per
= build_decl (BUILTINS_LOCATION
,
261 FIELD_DECL
, get_identifier ("__personality"),
263 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
265 f_lsda
= build_decl (BUILTINS_LOCATION
,
266 FIELD_DECL
, get_identifier ("__lsda"),
268 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
270 #ifdef DONT_USE_BUILTIN_SETJMP
272 tmp
= size_int (JMP_BUF_SIZE
- 1);
274 /* Should be large enough for most systems, if it is not,
275 JMP_BUF_SIZE should be defined with the proper value. It will
276 also tend to be larger than necessary for most systems, a more
277 optimal port will define JMP_BUF_SIZE. */
278 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
281 /* Compute a minimally sized jump buffer. We need room to store at
282 least 3 pointers - stack pointer, frame pointer and return address.
283 Plus for some targets we need room for an extra pointer - in the
284 case of MIPS this is the global pointer. This makes a total of four
285 pointers, but to be safe we actually allocate room for 5.
287 If pointers are smaller than words then we allocate enough room for
288 5 words, just in case the backend needs this much room. For more
289 discussion on this issue see:
290 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
291 if (POINTER_SIZE
> BITS_PER_WORD
)
292 tmp
= size_int (5 - 1);
294 tmp
= size_int ((5 * BITS_PER_WORD
/ POINTER_SIZE
) - 1);
297 tmp
= build_index_type (tmp
);
298 tmp
= build_array_type (ptr_type_node
, tmp
);
299 f_jbuf
= build_decl (BUILTINS_LOCATION
,
300 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
301 #ifdef DONT_USE_BUILTIN_SETJMP
302 /* We don't know what the alignment requirements of the
303 runtime's jmp_buf has. Overestimate. */
304 SET_DECL_ALIGN (f_jbuf
, BIGGEST_ALIGNMENT
);
305 DECL_USER_ALIGN (f_jbuf
) = 1;
307 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
309 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
310 TREE_CHAIN (f_prev
) = f_cs
;
311 TREE_CHAIN (f_cs
) = f_data
;
312 TREE_CHAIN (f_data
) = f_per
;
313 TREE_CHAIN (f_per
) = f_lsda
;
314 TREE_CHAIN (f_lsda
) = f_jbuf
;
316 layout_type (sjlj_fc_type_node
);
318 /* Cache the interesting field offsets so that we have
319 easy access from rtl. */
320 sjlj_fc_call_site_ofs
321 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs
))
322 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs
)) / BITS_PER_UNIT
);
324 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data
))
325 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data
)) / BITS_PER_UNIT
);
326 sjlj_fc_personality_ofs
327 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per
))
328 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per
)) / BITS_PER_UNIT
);
330 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda
))
331 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda
)) / BITS_PER_UNIT
);
333 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf
))
334 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf
)) / BITS_PER_UNIT
);
339 init_eh_for_function (void)
341 cfun
->eh
= ggc_cleared_alloc
<eh_status
> ();
343 /* Make sure zero'th entries are used. */
344 vec_safe_push (cfun
->eh
->region_array
, (eh_region
)0);
345 vec_safe_push (cfun
->eh
->lp_array
, (eh_landing_pad
)0);
348 /* Routines to generate the exception tree somewhat directly.
349 These are used from tree-eh.c when processing exception related
350 nodes during tree optimization. */
353 gen_eh_region (enum eh_region_type type
, eh_region outer
)
357 /* Insert a new blank region as a leaf in the tree. */
358 new_eh
= ggc_cleared_alloc
<eh_region_d
> ();
360 new_eh
->outer
= outer
;
363 new_eh
->next_peer
= outer
->inner
;
364 outer
->inner
= new_eh
;
368 new_eh
->next_peer
= cfun
->eh
->region_tree
;
369 cfun
->eh
->region_tree
= new_eh
;
372 new_eh
->index
= vec_safe_length (cfun
->eh
->region_array
);
373 vec_safe_push (cfun
->eh
->region_array
, new_eh
);
375 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
376 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
377 new_eh
->use_cxa_end_cleanup
= true;
383 gen_eh_region_cleanup (eh_region outer
)
385 return gen_eh_region (ERT_CLEANUP
, outer
);
389 gen_eh_region_try (eh_region outer
)
391 return gen_eh_region (ERT_TRY
, outer
);
395 gen_eh_region_catch (eh_region t
, tree type_or_list
)
398 tree type_list
, type_node
;
400 gcc_assert (t
->type
== ERT_TRY
);
402 /* Ensure to always end up with a type list to normalize further
403 processing, then register each type against the runtime types map. */
404 type_list
= type_or_list
;
407 if (TREE_CODE (type_or_list
) != TREE_LIST
)
408 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
410 type_node
= type_list
;
411 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
412 add_type_for_runtime (TREE_VALUE (type_node
));
415 c
= ggc_cleared_alloc
<eh_catch_d
> ();
416 c
->type_list
= type_list
;
417 l
= t
->u
.eh_try
.last_catch
;
422 t
->u
.eh_try
.first_catch
= c
;
423 t
->u
.eh_try
.last_catch
= c
;
429 gen_eh_region_allowed (eh_region outer
, tree allowed
)
431 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
432 region
->u
.allowed
.type_list
= allowed
;
434 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
435 add_type_for_runtime (TREE_VALUE (allowed
));
441 gen_eh_region_must_not_throw (eh_region outer
)
443 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
447 gen_eh_landing_pad (eh_region region
)
449 eh_landing_pad lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
451 lp
->next_lp
= region
->landing_pads
;
453 lp
->index
= vec_safe_length (cfun
->eh
->lp_array
);
454 region
->landing_pads
= lp
;
456 vec_safe_push (cfun
->eh
->lp_array
, lp
);
462 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
464 return (*ifun
->eh
->region_array
)[i
];
468 get_eh_region_from_number (int i
)
470 return get_eh_region_from_number_fn (cfun
, i
);
474 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
476 return (*ifun
->eh
->lp_array
)[i
];
480 get_eh_landing_pad_from_number (int i
)
482 return get_eh_landing_pad_from_number_fn (cfun
, i
);
486 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
489 return (*ifun
->eh
->region_array
)[-i
];
495 lp
= (*ifun
->eh
->lp_array
)[i
];
501 get_eh_region_from_lp_number (int i
)
503 return get_eh_region_from_lp_number_fn (cfun
, i
);
506 /* Returns true if the current function has exception handling regions. */
509 current_function_has_exception_handlers (void)
511 return cfun
->eh
->region_tree
!= NULL
;
514 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
515 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
517 struct duplicate_eh_regions_data
519 duplicate_eh_regions_map label_map
;
520 void *label_map_data
;
521 hash_map
<void *, void *> *eh_map
;
525 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
526 eh_region old_r
, eh_region outer
)
528 eh_landing_pad old_lp
, new_lp
;
531 new_r
= gen_eh_region (old_r
->type
, outer
);
532 gcc_assert (!data
->eh_map
->put (old_r
, new_r
));
542 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
544 /* We should be doing all our region duplication before and
545 during inlining, which is before filter lists are created. */
546 gcc_assert (oc
->filter_list
== NULL
);
547 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
548 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
553 case ERT_ALLOWED_EXCEPTIONS
:
554 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
555 if (old_r
->u
.allowed
.label
)
556 new_r
->u
.allowed
.label
557 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
559 new_r
->u
.allowed
.label
= NULL_TREE
;
562 case ERT_MUST_NOT_THROW
:
563 new_r
->u
.must_not_throw
.failure_loc
=
564 LOCATION_LOCUS (old_r
->u
.must_not_throw
.failure_loc
);
565 new_r
->u
.must_not_throw
.failure_decl
=
566 old_r
->u
.must_not_throw
.failure_decl
;
570 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
572 /* Don't bother copying unused landing pads. */
573 if (old_lp
->post_landing_pad
== NULL
)
576 new_lp
= gen_eh_landing_pad (new_r
);
577 gcc_assert (!data
->eh_map
->put (old_lp
, new_lp
));
579 new_lp
->post_landing_pad
580 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
581 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
584 /* Make sure to preserve the original use of __cxa_end_cleanup. */
585 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
587 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
588 duplicate_eh_regions_1 (data
, old_r
, new_r
);
591 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
592 the current function and root the tree below OUTER_REGION.
593 The special case of COPY_REGION of NULL means all regions.
594 Remap labels using MAP/MAP_DATA callback. Return a pointer map
595 that allows the caller to remap uses of both EH regions and
598 hash_map
<void *, void *> *
599 duplicate_eh_regions (struct function
*ifun
,
600 eh_region copy_region
, int outer_lp
,
601 duplicate_eh_regions_map map
, void *map_data
)
603 struct duplicate_eh_regions_data data
;
604 eh_region outer_region
;
607 verify_eh_tree (ifun
);
609 data
.label_map
= map
;
610 data
.label_map_data
= map_data
;
611 data
.eh_map
= new hash_map
<void *, void *>;
613 outer_region
= get_eh_region_from_lp_number_fn (cfun
, outer_lp
);
615 /* Copy all the regions in the subtree. */
617 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
621 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
622 duplicate_eh_regions_1 (&data
, r
, outer_region
);
626 verify_eh_tree (cfun
);
631 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
634 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
639 gcc_assert (ifun
->eh
->region_array
);
640 gcc_assert (ifun
->eh
->region_tree
);
642 b_outer
= sbitmap_alloc (ifun
->eh
->region_array
->length ());
643 bitmap_clear (b_outer
);
647 bitmap_set_bit (b_outer
, region_b
->index
);
648 region_b
= region_b
->outer
;
654 if (bitmap_bit_p (b_outer
, region_a
->index
))
656 region_a
= region_a
->outer
;
660 sbitmap_free (b_outer
);
665 add_type_for_runtime (tree type
)
667 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
668 if (TREE_CODE (type
) == NOP_EXPR
)
671 bool existed
= false;
672 tree
*slot
= &type_to_runtime_map
->get_or_insert (type
, &existed
);
674 *slot
= lang_hooks
.eh_runtime_type (type
);
678 lookup_type_for_runtime (tree type
)
680 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
681 if (TREE_CODE (type
) == NOP_EXPR
)
684 /* We should have always inserted the data earlier. */
685 return *type_to_runtime_map
->get (type
);
689 /* Represent an entry in @TTypes for either catch actions
690 or exception filter actions. */
691 struct ttypes_filter
{
696 /* Helper for ttypes_filter hashing. */
698 struct ttypes_filter_hasher
: free_ptr_hash
<ttypes_filter
>
700 typedef tree_node
*compare_type
;
701 static inline hashval_t
hash (const ttypes_filter
*);
702 static inline bool equal (const ttypes_filter
*, const tree_node
*);
705 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
706 (a tree) for a @TTypes type node we are thinking about adding. */
709 ttypes_filter_hasher::equal (const ttypes_filter
*entry
, const tree_node
*data
)
711 return entry
->t
== data
;
715 ttypes_filter_hasher::hash (const ttypes_filter
*entry
)
717 return TREE_HASH (entry
->t
);
720 typedef hash_table
<ttypes_filter_hasher
> ttypes_hash_type
;
723 /* Helper for ehspec hashing. */
725 struct ehspec_hasher
: free_ptr_hash
<ttypes_filter
>
727 static inline hashval_t
hash (const ttypes_filter
*);
728 static inline bool equal (const ttypes_filter
*, const ttypes_filter
*);
731 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
732 exception specification list we are thinking about adding. */
733 /* ??? Currently we use the type lists in the order given. Someone
734 should put these in some canonical order. */
737 ehspec_hasher::equal (const ttypes_filter
*entry
, const ttypes_filter
*data
)
739 return type_list_equal (entry
->t
, data
->t
);
742 /* Hash function for exception specification lists. */
745 ehspec_hasher::hash (const ttypes_filter
*entry
)
750 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
751 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
755 typedef hash_table
<ehspec_hasher
> ehspec_hash_type
;
758 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
759 to speed up the search. Return the filter value to be used. */
762 add_ttypes_entry (ttypes_hash_type
*ttypes_hash
, tree type
)
764 struct ttypes_filter
**slot
, *n
;
766 slot
= ttypes_hash
->find_slot_with_hash (type
, (hashval_t
) TREE_HASH (type
),
769 if ((n
= *slot
) == NULL
)
771 /* Filter value is a 1 based table index. */
773 n
= XNEW (struct ttypes_filter
);
775 n
->filter
= vec_safe_length (cfun
->eh
->ttype_data
) + 1;
778 vec_safe_push (cfun
->eh
->ttype_data
, type
);
784 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
785 to speed up the search. Return the filter value to be used. */
788 add_ehspec_entry (ehspec_hash_type
*ehspec_hash
, ttypes_hash_type
*ttypes_hash
,
791 struct ttypes_filter
**slot
, *n
;
792 struct ttypes_filter dummy
;
795 slot
= ehspec_hash
->find_slot (&dummy
, INSERT
);
797 if ((n
= *slot
) == NULL
)
801 if (targetm
.arm_eabi_unwinder
)
802 len
= vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
);
804 len
= vec_safe_length (cfun
->eh
->ehspec_data
.other
);
806 /* Filter value is a -1 based byte index into a uleb128 buffer. */
808 n
= XNEW (struct ttypes_filter
);
810 n
->filter
= -(len
+ 1);
813 /* Generate a 0 terminated list of filter values. */
814 for (; list
; list
= TREE_CHAIN (list
))
816 if (targetm
.arm_eabi_unwinder
)
817 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, TREE_VALUE (list
));
820 /* Look up each type in the list and encode its filter
821 value as a uleb128. */
822 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
823 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
826 if (targetm
.arm_eabi_unwinder
)
827 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
829 vec_safe_push (cfun
->eh
->ehspec_data
.other
, (uchar
)0);
835 /* Generate the action filter values to be used for CATCH and
836 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
837 we use lots of landing pads, and so every type or list can share
838 the same filter value, which saves table space. */
841 assign_filter_values (void)
847 vec_alloc (cfun
->eh
->ttype_data
, 16);
848 if (targetm
.arm_eabi_unwinder
)
849 vec_alloc (cfun
->eh
->ehspec_data
.arm_eabi
, 64);
851 vec_alloc (cfun
->eh
->ehspec_data
.other
, 64);
853 ehspec_hash_type
ehspec (31);
854 ttypes_hash_type
ttypes (31);
856 for (i
= 1; vec_safe_iterate (cfun
->eh
->region_array
, i
, &r
); ++i
)
864 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
866 /* Whatever type_list is (NULL or true list), we build a list
867 of filters for the region. */
868 c
->filter_list
= NULL_TREE
;
870 if (c
->type_list
!= NULL
)
872 /* Get a filter value for each of the types caught and store
873 them in the region's dedicated list. */
874 tree tp_node
= c
->type_list
;
876 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
879 = add_ttypes_entry (&ttypes
, TREE_VALUE (tp_node
));
880 tree flt_node
= build_int_cst (integer_type_node
, flt
);
883 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
888 /* Get a filter value for the NULL list also since it
889 will need an action record anyway. */
890 int flt
= add_ttypes_entry (&ttypes
, NULL
);
891 tree flt_node
= build_int_cst (integer_type_node
, flt
);
894 = tree_cons (NULL_TREE
, flt_node
, NULL
);
899 case ERT_ALLOWED_EXCEPTIONS
:
901 = add_ehspec_entry (&ehspec
, &ttypes
, r
->u
.allowed
.type_list
);
910 /* Emit SEQ into basic block just before INSN (that is assumed to be
911 first instruction of some existing BB and return the newly
914 emit_to_new_bb_before (rtx_insn
*seq
, rtx insn
)
921 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
922 call), we don't want it to go into newly created landing pad or other EH
924 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
925 if (e
->flags
& EDGE_FALLTHRU
)
926 force_nonfallthru (e
);
929 last
= emit_insn_before (seq
, insn
);
930 if (BARRIER_P (last
))
931 last
= PREV_INSN (last
);
932 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
933 update_bb_for_insn (bb
);
934 bb
->flags
|= BB_SUPERBLOCK
;
938 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
939 at the rtl level. Emit the code required by the target at a landing
940 pad for the given region. */
943 expand_dw2_landing_pad_for_region (eh_region region
)
945 if (targetm
.have_exception_receiver ())
946 emit_insn (targetm
.gen_exception_receiver ());
947 else if (targetm
.have_nonlocal_goto_receiver ())
948 emit_insn (targetm
.gen_nonlocal_goto_receiver ());
952 if (region
->exc_ptr_reg
)
953 emit_move_insn (region
->exc_ptr_reg
,
954 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
955 if (region
->filter_reg
)
956 emit_move_insn (region
->filter_reg
,
957 gen_rtx_REG (targetm
.eh_return_filter_mode (),
958 EH_RETURN_DATA_REGNO (1)));
961 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
964 dw2_build_landing_pads (void)
968 int e_flags
= EDGE_FALLTHRU
;
970 /* If we're going to partition blocks, we need to be able to add
971 new landing pads later, which means that we need to hold on to
972 the post-landing-pad block. Prevent it from being merged away.
973 We'll remove this bit after partitioning. */
974 if (flag_reorder_blocks_and_partition
)
975 e_flags
|= EDGE_PRESERVE
;
977 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
983 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
988 lp
->landing_pad
= gen_label_rtx ();
989 emit_label (lp
->landing_pad
);
990 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
992 expand_dw2_landing_pad_for_region (lp
->region
);
997 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
998 e
= make_edge (bb
, bb
->next_bb
, e_flags
);
999 e
->count
= bb
->count
;
1000 e
->probability
= REG_BR_PROB_BASE
;
1003 struct loop
*loop
= bb
->next_bb
->loop_father
;
1004 /* If we created a pre-header block, add the new block to the
1005 outer loop, otherwise to the loop itself. */
1006 if (bb
->next_bb
== loop
->header
)
1007 add_bb_to_loop (bb
, loop_outer (loop
));
1009 add_bb_to_loop (bb
, loop
);
1015 static vec
<int> sjlj_lp_call_site_index
;
1017 /* Process all active landing pads. Assign each one a compact dispatch
1018 index, and a call-site index. */
1021 sjlj_assign_call_site_values (void)
1023 action_hash_type
ar_hash (31);
1027 vec_alloc (crtl
->eh
.action_record_data
, 64);
1031 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1032 if (lp
&& lp
->post_landing_pad
)
1034 int action
, call_site
;
1036 /* First: build the action table. */
1037 action
= collect_one_action_chain (&ar_hash
, lp
->region
);
1039 /* Next: assign call-site values. If dwarf2 terms, this would be
1040 the region number assigned by convert_to_eh_region_ranges, but
1041 handles no-action and must-not-throw differently. */
1042 /* Map must-not-throw to otherwise unused call-site index 0. */
1045 /* Map no-action to otherwise unused call-site index -1. */
1046 else if (action
== -1)
1048 /* Otherwise, look it up in the table. */
1050 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1051 sjlj_lp_call_site_index
[i
] = call_site
;
1059 /* Emit code to record the current call-site index before every
1060 insn that can throw. */
1063 sjlj_mark_call_sites (void)
1065 int last_call_site
= -2;
1069 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1075 rtx_insn
*before
, *p
;
1077 /* Reset value tracking at extended basic block boundaries. */
1079 last_call_site
= -2;
1081 /* If the function allocates dynamic stack space, the context must
1082 be updated after every allocation/deallocation accordingly. */
1083 if (NOTE_P (insn
) && NOTE_KIND (insn
) == NOTE_INSN_UPDATE_SJLJ_CONTEXT
)
1088 buf_addr
= plus_constant (Pmode
, XEXP (crtl
->eh
.sjlj_fc
, 0),
1090 expand_builtin_update_setjmp_buf (buf_addr
);
1093 emit_insn_before (p
, insn
);
1096 if (! INSN_P (insn
))
1099 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1103 this_call_site
= sjlj_lp_call_site_index
[lp
->index
];
1106 /* Calls (and trapping insns) without notes are outside any
1107 exception handling region in this function. Mark them as
1109 this_call_site
= -1;
1113 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1117 if (this_call_site
!= -1)
1118 crtl
->uses_eh_lsda
= 1;
1120 if (this_call_site
== last_call_site
)
1123 /* Don't separate a call from it's argument loads. */
1126 before
= find_first_parameter_load (insn
, NULL
);
1129 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1130 sjlj_fc_call_site_ofs
);
1131 emit_move_insn (mem
, gen_int_mode (this_call_site
, GET_MODE (mem
)));
1135 emit_insn_before (p
, before
);
1136 last_call_site
= this_call_site
;
1140 /* Construct the SjLj_Function_Context. */
1143 sjlj_emit_function_enter (rtx_code_label
*dispatch_label
)
1145 rtx_insn
*fn_begin
, *seq
;
1147 bool fn_begin_outside_block
;
1148 rtx personality
= get_personality_function (current_function_decl
);
1150 fc
= crtl
->eh
.sjlj_fc
;
1154 /* We're storing this libcall's address into memory instead of
1155 calling it directly. Thus, we must call assemble_external_libcall
1156 here, as we can not depend on emit_library_call to do it for us. */
1157 assemble_external_libcall (personality
);
1158 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1159 emit_move_insn (mem
, personality
);
1161 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1162 if (crtl
->uses_eh_lsda
)
1167 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1168 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1169 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1170 emit_move_insn (mem
, sym
);
1173 emit_move_insn (mem
, const0_rtx
);
1177 rtx addr
= plus_constant (Pmode
, XEXP (fc
, 0), sjlj_fc_jbuf_ofs
);
1179 #ifdef DONT_USE_BUILTIN_SETJMP
1180 addr
= copy_addr_to_reg (addr
);
1181 addr
= convert_memory_address (ptr_mode
, addr
);
1182 tree addr_tree
= make_tree (ptr_type_node
, addr
);
1184 tree fn
= builtin_decl_implicit (BUILT_IN_SETJMP
);
1185 tree call_expr
= build_call_expr (fn
, 1, addr_tree
);
1186 rtx x
= expand_call (call_expr
, NULL_RTX
, false);
1188 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1189 TYPE_MODE (integer_type_node
), 0,
1190 dispatch_label
, REG_BR_PROB_BASE
/ 100);
1192 expand_builtin_setjmp_setup (addr
, dispatch_label
);
1196 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1197 1, XEXP (fc
, 0), Pmode
);
1202 /* ??? Instead of doing this at the beginning of the function,
1203 do this in a block that is at loop level 0 and dominates all
1204 can_throw_internal instructions. */
1206 fn_begin_outside_block
= true;
1207 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1208 if (NOTE_P (fn_begin
))
1210 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1212 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1213 fn_begin_outside_block
= false;
1216 if (fn_begin_outside_block
)
1217 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1219 emit_insn_after (seq
, fn_begin
);
1222 /* Call back from expand_function_end to know where we should put
1223 the call to unwind_sjlj_unregister_libfunc if needed. */
1226 sjlj_emit_function_exit_after (rtx_insn
*after
)
1228 crtl
->eh
.sjlj_exit_after
= after
;
1232 sjlj_emit_function_exit (void)
1234 rtx_insn
*seq
, *insn
;
1238 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1239 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1244 /* ??? Really this can be done in any block at loop level 0 that
1245 post-dominates all can_throw_internal instructions. This is
1246 the last possible moment. */
1248 insn
= crtl
->eh
.sjlj_exit_after
;
1250 insn
= NEXT_INSN (insn
);
1252 emit_insn_after (seq
, insn
);
1256 sjlj_emit_dispatch_table (rtx_code_label
*dispatch_label
, int num_dispatch
)
1258 machine_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1259 machine_mode filter_mode
= targetm
.eh_return_filter_mode ();
1261 rtx mem
, fc
, exc_ptr_reg
, filter_reg
;
1267 vec
<tree
> dispatch_labels
= vNULL
;
1269 fc
= crtl
->eh
.sjlj_fc
;
1273 emit_label (dispatch_label
);
1275 #ifndef DONT_USE_BUILTIN_SETJMP
1276 expand_builtin_setjmp_receiver (dispatch_label
);
1278 /* The caller of expand_builtin_setjmp_receiver is responsible for
1279 making sure that the label doesn't vanish. The only other caller
1280 is the expander for __builtin_setjmp_receiver, which places this
1281 label on the nonlocal_goto_label list. Since we're modeling these
1282 CFG edges more exactly, we can use the forced_labels list instead. */
1283 LABEL_PRESERVE_P (dispatch_label
) = 1;
1285 = gen_rtx_INSN_LIST (VOIDmode
, dispatch_label
, forced_labels
);
1288 /* Load up exc_ptr and filter values from the function context. */
1289 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1290 if (unwind_word_mode
!= ptr_mode
)
1292 #ifdef POINTERS_EXTEND_UNSIGNED
1293 mem
= convert_memory_address (ptr_mode
, mem
);
1295 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1298 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1300 mem
= adjust_address (fc
, unwind_word_mode
,
1301 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1302 if (unwind_word_mode
!= filter_mode
)
1303 mem
= convert_to_mode (filter_mode
, mem
, 0);
1304 filter_reg
= force_reg (filter_mode
, mem
);
1306 /* Jump to one of the directly reachable regions. */
1309 rtx_code_label
*first_reachable_label
= NULL
;
1311 /* If there's exactly one call site in the function, don't bother
1312 generating a switch statement. */
1313 if (num_dispatch
> 1)
1314 dispatch_labels
.create (num_dispatch
);
1316 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1317 if (lp
&& lp
->post_landing_pad
)
1320 rtx_code_label
*label
;
1324 lp
->landing_pad
= dispatch_label
;
1326 if (num_dispatch
> 1)
1328 tree t_label
, case_elt
, t
;
1330 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1331 t
= build_int_cst (integer_type_node
, disp_index
);
1332 case_elt
= build_case_label (t
, NULL
, t_label
);
1333 dispatch_labels
.quick_push (case_elt
);
1334 label
= jump_target_rtx (t_label
);
1337 label
= gen_label_rtx ();
1339 if (disp_index
== 0)
1340 first_reachable_label
= label
;
1345 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1347 emit_move_insn (r
->filter_reg
, filter_reg
);
1349 seq2
= get_insns ();
1352 rtx_insn
*before
= label_rtx (lp
->post_landing_pad
);
1353 bb
= emit_to_new_bb_before (seq2
, before
);
1354 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1355 e
->count
= bb
->count
;
1356 e
->probability
= REG_BR_PROB_BASE
;
1359 struct loop
*loop
= bb
->next_bb
->loop_father
;
1360 /* If we created a pre-header block, add the new block to the
1361 outer loop, otherwise to the loop itself. */
1362 if (bb
->next_bb
== loop
->header
)
1363 add_bb_to_loop (bb
, loop_outer (loop
));
1365 add_bb_to_loop (bb
, loop
);
1366 /* ??? For multiple dispatches we will end up with edges
1367 from the loop tree root into this loop, making it a
1368 multiple-entry loop. Discard all affected loops. */
1369 if (num_dispatch
> 1)
1371 for (loop
= bb
->loop_father
;
1372 loop_outer (loop
); loop
= loop_outer (loop
))
1373 mark_loop_for_removal (loop
);
1379 gcc_assert (disp_index
== num_dispatch
);
1381 if (num_dispatch
> 1)
1383 rtx disp
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1384 sjlj_fc_call_site_ofs
);
1385 expand_sjlj_dispatch_table (disp
, dispatch_labels
);
1391 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1392 if (num_dispatch
== 1)
1394 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1395 e
->count
= bb
->count
;
1396 e
->probability
= REG_BR_PROB_BASE
;
1399 struct loop
*loop
= bb
->next_bb
->loop_father
;
1400 /* If we created a pre-header block, add the new block to the
1401 outer loop, otherwise to the loop itself. */
1402 if (bb
->next_bb
== loop
->header
)
1403 add_bb_to_loop (bb
, loop_outer (loop
));
1405 add_bb_to_loop (bb
, loop
);
1410 /* We are not wiring up edges here, but as the dispatcher call
1411 is at function begin simply associate the block with the
1412 outermost (non-)loop. */
1414 add_bb_to_loop (bb
, current_loops
->tree_root
);
1419 sjlj_build_landing_pads (void)
1423 num_dispatch
= vec_safe_length (cfun
->eh
->lp_array
);
1424 if (num_dispatch
== 0)
1426 sjlj_lp_call_site_index
.safe_grow_cleared (num_dispatch
);
1428 num_dispatch
= sjlj_assign_call_site_values ();
1429 if (num_dispatch
> 0)
1431 rtx_code_label
*dispatch_label
= gen_label_rtx ();
1432 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1433 TYPE_MODE (sjlj_fc_type_node
),
1434 TYPE_ALIGN (sjlj_fc_type_node
));
1436 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1437 int_size_in_bytes (sjlj_fc_type_node
),
1440 sjlj_mark_call_sites ();
1441 sjlj_emit_function_enter (dispatch_label
);
1442 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1443 sjlj_emit_function_exit ();
1446 /* If we do not have any landing pads, we may still need to register a
1447 personality routine and (empty) LSDA to handle must-not-throw regions. */
1448 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
1450 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1451 TYPE_MODE (sjlj_fc_type_node
),
1452 TYPE_ALIGN (sjlj_fc_type_node
));
1454 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1455 int_size_in_bytes (sjlj_fc_type_node
),
1458 sjlj_mark_call_sites ();
1459 sjlj_emit_function_enter (NULL
);
1460 sjlj_emit_function_exit ();
1463 sjlj_lp_call_site_index
.release ();
1466 /* Update the sjlj function context. This function should be called
1467 whenever we allocate or deallocate dynamic stack space. */
1470 update_sjlj_context (void)
1472 if (!flag_exceptions
)
1475 emit_note (NOTE_INSN_UPDATE_SJLJ_CONTEXT
);
1478 /* After initial rtl generation, call back to finish generating
1479 exception support code. */
1482 finish_eh_generation (void)
1486 /* Construct the landing pads. */
1487 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1488 sjlj_build_landing_pads ();
1490 dw2_build_landing_pads ();
1491 break_superblocks ();
1493 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1494 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1495 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->insns
.r
)
1496 commit_edge_insertions ();
1498 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1499 FOR_EACH_BB_FN (bb
, cfun
)
1505 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1507 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1508 if (e
->flags
& EDGE_EH
)
1511 /* We should not have generated any new throwing insns during this
1512 pass, and we should not have lost any EH edges, so we only need
1513 to handle two cases here:
1514 (1) reachable handler and an existing edge to post-landing-pad,
1515 (2) no reachable handler and no edge. */
1516 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1519 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1521 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1522 e
->flags
|= (CALL_P (BB_END (bb
))
1523 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1529 /* This section handles removing dead code for flow. */
1532 remove_eh_landing_pad (eh_landing_pad lp
)
1536 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1540 if (lp
->post_landing_pad
)
1541 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1542 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1545 /* Splice the EH region at PP from the region tree. */
1548 remove_eh_handler_splicer (eh_region
*pp
)
1550 eh_region region
= *pp
;
1553 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1555 if (lp
->post_landing_pad
)
1556 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1557 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1563 outer
= region
->outer
;
1565 *pp
= p
= region
->inner
;
1574 *pp
= region
->next_peer
;
1576 (*cfun
->eh
->region_array
)[region
->index
] = NULL
;
1579 /* Splice a single EH region REGION from the region tree.
1581 To unlink REGION, we need to find the pointer to it with a relatively
1582 expensive search in REGION's outer region. If you are going to
1583 remove a number of handlers, using remove_unreachable_eh_regions may
1584 be a better option. */
1587 remove_eh_handler (eh_region region
)
1589 eh_region
*pp
, *pp_start
, p
, outer
;
1591 outer
= region
->outer
;
1593 pp_start
= &outer
->inner
;
1595 pp_start
= &cfun
->eh
->region_tree
;
1596 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1599 remove_eh_handler_splicer (pp
);
1602 /* Worker for remove_unreachable_eh_regions.
1603 PP is a pointer to the region to start a region tree depth-first
1604 search from. R_REACHABLE is the set of regions that have to be
1608 remove_unreachable_eh_regions_worker (eh_region
*pp
, sbitmap r_reachable
)
1612 eh_region region
= *pp
;
1613 remove_unreachable_eh_regions_worker (®ion
->inner
, r_reachable
);
1614 if (!bitmap_bit_p (r_reachable
, region
->index
))
1615 remove_eh_handler_splicer (pp
);
1617 pp
= ®ion
->next_peer
;
1621 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1622 Do this by traversing the EH tree top-down and splice out regions that
1623 are not marked. By removing regions from the leaves, we avoid costly
1624 searches in the region tree. */
1627 remove_unreachable_eh_regions (sbitmap r_reachable
)
1629 remove_unreachable_eh_regions_worker (&cfun
->eh
->region_tree
, r_reachable
);
1632 /* Invokes CALLBACK for every exception handler landing pad label.
1633 Only used by reload hackery; should not be used by new code. */
1636 for_each_eh_label (void (*callback
) (rtx
))
1641 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1645 rtx_code_label
*lab
= lp
->landing_pad
;
1646 if (lab
&& LABEL_P (lab
))
1652 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1655 At the gimple level, we use LP_NR
1656 > 0 : The statement transfers to landing pad LP_NR
1657 = 0 : The statement is outside any EH region
1658 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1660 At the rtl level, we use LP_NR
1661 > 0 : The insn transfers to landing pad LP_NR
1662 = 0 : The insn cannot throw
1663 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1664 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1665 missing note: The insn is outside any EH region.
1667 ??? This difference probably ought to be avoided. We could stand
1668 to record nothrow for arbitrary gimple statements, and so avoid
1669 some moderately complex lookups in stmt_could_throw_p. Perhaps
1670 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1671 no-nonlocal-goto property should be recorded elsewhere as a bit
1672 on the call_insn directly. Perhaps we should make more use of
1673 attaching the trees to call_insns (reachable via symbol_ref in
1674 direct call cases) and just pull the data out of the trees. */
1677 make_reg_eh_region_note (rtx_insn
*insn
, int ecf_flags
, int lp_nr
)
1680 if (ecf_flags
& ECF_NOTHROW
)
1682 else if (lp_nr
!= 0)
1683 value
= GEN_INT (lp_nr
);
1686 add_reg_note (insn
, REG_EH_REGION
, value
);
1689 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1690 nor perform a non-local goto. Replace the region note if it
1694 make_reg_eh_region_note_nothrow_nononlocal (rtx_insn
*insn
)
1696 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1697 rtx intmin
= GEN_INT (INT_MIN
);
1700 XEXP (note
, 0) = intmin
;
1702 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1705 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1709 insn_could_throw_p (const_rtx insn
)
1711 if (!flag_exceptions
)
1715 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1716 return may_trap_p (PATTERN (insn
));
1720 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1721 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1722 to look for a note, or the note itself. */
1725 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx_insn
*first
, rtx last
)
1728 rtx note
= note_or_insn
;
1730 if (INSN_P (note_or_insn
))
1732 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1736 note
= XEXP (note
, 0);
1738 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1739 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1740 && insn_could_throw_p (insn
))
1741 add_reg_note (insn
, REG_EH_REGION
, note
);
1744 /* Likewise, but iterate backward. */
1747 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx_insn
*last
, rtx first
)
1750 rtx note
= note_or_insn
;
1752 if (INSN_P (note_or_insn
))
1754 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1758 note
= XEXP (note
, 0);
1760 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1761 if (insn_could_throw_p (insn
))
1762 add_reg_note (insn
, REG_EH_REGION
, note
);
1766 /* Extract all EH information from INSN. Return true if the insn
1767 was marked NOTHROW. */
1770 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1771 eh_landing_pad
*plp
)
1773 eh_landing_pad lp
= NULL
;
1779 if (! INSN_P (insn
))
1782 if (NONJUMP_INSN_P (insn
)
1783 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1784 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1786 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1789 ret
= !insn_could_throw_p (insn
);
1793 lp_nr
= INTVAL (XEXP (note
, 0));
1794 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1801 r
= (*cfun
->eh
->region_array
)[-lp_nr
];
1804 lp
= (*cfun
->eh
->lp_array
)[lp_nr
];
1814 /* Return the landing pad to which INSN may go, or NULL if it does not
1815 have a reachable landing pad within this function. */
1818 get_eh_landing_pad_from_rtx (const_rtx insn
)
1823 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1827 /* Return the region to which INSN may go, or NULL if it does not
1828 have a reachable region within this function. */
1831 get_eh_region_from_rtx (const_rtx insn
)
1836 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1840 /* Return true if INSN throws and is caught by something in this function. */
1843 can_throw_internal (const_rtx insn
)
1845 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1848 /* Return true if INSN throws and escapes from the current function. */
1851 can_throw_external (const_rtx insn
)
1857 if (! INSN_P (insn
))
1860 if (NONJUMP_INSN_P (insn
)
1861 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1863 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1864 int i
, n
= seq
->len ();
1866 for (i
= 0; i
< n
; i
++)
1867 if (can_throw_external (seq
->element (i
)))
1873 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1875 /* If we can't throw, we obviously can't throw external. */
1879 /* If we have an internal landing pad, then we're not external. */
1883 /* If we're not within an EH region, then we are external. */
1887 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1888 which don't always have landing pads. */
1889 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1893 /* Return true if INSN cannot throw at all. */
1896 insn_nothrow_p (const_rtx insn
)
1901 if (! INSN_P (insn
))
1904 if (NONJUMP_INSN_P (insn
)
1905 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1907 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1908 int i
, n
= seq
->len ();
1910 for (i
= 0; i
< n
; i
++)
1911 if (!insn_nothrow_p (seq
->element (i
)))
1917 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1920 /* Return true if INSN can perform a non-local goto. */
1921 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1924 can_nonlocal_goto (const rtx_insn
*insn
)
1926 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1928 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1929 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1935 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1938 set_nothrow_function_flags (void)
1944 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1945 something that can throw an exception. We specifically exempt
1946 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1947 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1950 crtl
->all_throwers_are_sibcalls
= 1;
1952 /* If we don't know that this implementation of the function will
1953 actually be used, then we must not set TREE_NOTHROW, since
1954 callers must not assume that this function does not throw. */
1955 if (TREE_NOTHROW (current_function_decl
))
1958 if (! flag_exceptions
)
1961 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1962 if (can_throw_external (insn
))
1966 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
1968 crtl
->all_throwers_are_sibcalls
= 0;
1974 && (cgraph_node::get (current_function_decl
)->get_availability ()
1975 >= AVAIL_AVAILABLE
))
1977 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
1978 struct cgraph_edge
*e
;
1979 for (e
= node
->callers
; e
; e
= e
->next_caller
)
1980 e
->can_throw_external
= false;
1981 node
->set_nothrow_flag (true);
1984 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
1985 current_function_name ());
1992 const pass_data pass_data_set_nothrow_function_flags
=
1994 RTL_PASS
, /* type */
1995 "nothrow", /* name */
1996 OPTGROUP_NONE
, /* optinfo_flags */
1997 TV_NONE
, /* tv_id */
1998 0, /* properties_required */
1999 0, /* properties_provided */
2000 0, /* properties_destroyed */
2001 0, /* todo_flags_start */
2002 0, /* todo_flags_finish */
2005 class pass_set_nothrow_function_flags
: public rtl_opt_pass
2008 pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2009 : rtl_opt_pass (pass_data_set_nothrow_function_flags
, ctxt
)
2012 /* opt_pass methods: */
2013 virtual unsigned int execute (function
*)
2015 return set_nothrow_function_flags ();
2018 }; // class pass_set_nothrow_function_flags
2023 make_pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2025 return new pass_set_nothrow_function_flags (ctxt
);
2029 /* Various hooks for unwind library. */
2031 /* Expand the EH support builtin functions:
2032 __builtin_eh_pointer and __builtin_eh_filter. */
2035 expand_builtin_eh_common (tree region_nr_t
)
2037 HOST_WIDE_INT region_nr
;
2040 gcc_assert (tree_fits_shwi_p (region_nr_t
));
2041 region_nr
= tree_to_shwi (region_nr_t
);
2043 region
= (*cfun
->eh
->region_array
)[region_nr
];
2045 /* ??? We shouldn't have been able to delete a eh region without
2046 deleting all the code that depended on it. */
2047 gcc_assert (region
!= NULL
);
2052 /* Expand to the exc_ptr value from the given eh region. */
2055 expand_builtin_eh_pointer (tree exp
)
2058 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2059 if (region
->exc_ptr_reg
== NULL
)
2060 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2061 return region
->exc_ptr_reg
;
2064 /* Expand to the filter value from the given eh region. */
2067 expand_builtin_eh_filter (tree exp
)
2070 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2071 if (region
->filter_reg
== NULL
)
2072 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
2073 return region
->filter_reg
;
2076 /* Copy the exc_ptr and filter values from one landing pad's registers
2077 to another. This is used to inline the resx statement. */
2080 expand_builtin_eh_copy_values (tree exp
)
2083 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2085 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
2086 machine_mode fmode
= targetm
.eh_return_filter_mode ();
2088 if (dst
->exc_ptr_reg
== NULL
)
2089 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2090 if (src
->exc_ptr_reg
== NULL
)
2091 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2093 if (dst
->filter_reg
== NULL
)
2094 dst
->filter_reg
= gen_reg_rtx (fmode
);
2095 if (src
->filter_reg
== NULL
)
2096 src
->filter_reg
= gen_reg_rtx (fmode
);
2098 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2099 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2104 /* Do any necessary initialization to access arbitrary stack frames.
2105 On the SPARC, this means flushing the register windows. */
2108 expand_builtin_unwind_init (void)
2110 /* Set this so all the registers get saved in our frame; we need to be
2111 able to copy the saved values for any registers from frames we unwind. */
2112 crtl
->saves_all_registers
= 1;
2114 SETUP_FRAME_ADDRESSES ();
2117 /* Map a non-negative number to an eh return data register number; expands
2118 to -1 if no return data register is associated with the input number.
2119 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2122 expand_builtin_eh_return_data_regno (tree exp
)
2124 tree which
= CALL_EXPR_ARG (exp
, 0);
2125 unsigned HOST_WIDE_INT iwhich
;
2127 if (TREE_CODE (which
) != INTEGER_CST
)
2129 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2133 iwhich
= tree_to_uhwi (which
);
2134 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2135 if (iwhich
== INVALID_REGNUM
)
2138 #ifdef DWARF_FRAME_REGNUM
2139 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2141 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2144 return GEN_INT (iwhich
);
2147 /* Given a value extracted from the return address register or stack slot,
2148 return the actual address encoded in that value. */
2151 expand_builtin_extract_return_addr (tree addr_tree
)
2153 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2155 if (GET_MODE (addr
) != Pmode
2156 && GET_MODE (addr
) != VOIDmode
)
2158 #ifdef POINTERS_EXTEND_UNSIGNED
2159 addr
= convert_memory_address (Pmode
, addr
);
2161 addr
= convert_to_mode (Pmode
, addr
, 0);
2165 /* First mask out any unwanted bits. */
2166 rtx mask
= MASK_RETURN_ADDR
;
2168 expand_and (Pmode
, addr
, mask
, addr
);
2170 /* Then adjust to find the real return address. */
2171 if (RETURN_ADDR_OFFSET
)
2172 addr
= plus_constant (Pmode
, addr
, RETURN_ADDR_OFFSET
);
2177 /* Given an actual address in addr_tree, do any necessary encoding
2178 and return the value to be stored in the return address register or
2179 stack slot so the epilogue will return to that address. */
2182 expand_builtin_frob_return_addr (tree addr_tree
)
2184 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2186 addr
= convert_memory_address (Pmode
, addr
);
2188 if (RETURN_ADDR_OFFSET
)
2190 addr
= force_reg (Pmode
, addr
);
2191 addr
= plus_constant (Pmode
, addr
, -RETURN_ADDR_OFFSET
);
2197 /* Set up the epilogue with the magic bits we'll need to return to the
2198 exception handler. */
2201 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2206 #ifdef EH_RETURN_STACKADJ_RTX
2207 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2208 VOIDmode
, EXPAND_NORMAL
);
2209 tmp
= convert_memory_address (Pmode
, tmp
);
2210 if (!crtl
->eh
.ehr_stackadj
)
2211 crtl
->eh
.ehr_stackadj
= copy_addr_to_reg (tmp
);
2212 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2213 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2216 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2217 VOIDmode
, EXPAND_NORMAL
);
2218 tmp
= convert_memory_address (Pmode
, tmp
);
2219 if (!crtl
->eh
.ehr_handler
)
2220 crtl
->eh
.ehr_handler
= copy_addr_to_reg (tmp
);
2221 else if (tmp
!= crtl
->eh
.ehr_handler
)
2222 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2224 if (!crtl
->eh
.ehr_label
)
2225 crtl
->eh
.ehr_label
= gen_label_rtx ();
2226 emit_jump (crtl
->eh
.ehr_label
);
2229 /* Expand __builtin_eh_return. This exit path from the function loads up
2230 the eh return data registers, adjusts the stack, and branches to a
2231 given PC other than the normal return address. */
2234 expand_eh_return (void)
2236 rtx_code_label
*around_label
;
2238 if (! crtl
->eh
.ehr_label
)
2241 crtl
->calls_eh_return
= 1;
2243 #ifdef EH_RETURN_STACKADJ_RTX
2244 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2247 around_label
= gen_label_rtx ();
2248 emit_jump (around_label
);
2250 emit_label (crtl
->eh
.ehr_label
);
2251 clobber_return_register ();
2253 #ifdef EH_RETURN_STACKADJ_RTX
2254 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2257 if (targetm
.have_eh_return ())
2258 emit_insn (targetm
.gen_eh_return (crtl
->eh
.ehr_handler
));
2261 if (rtx handler
= EH_RETURN_HANDLER_RTX
)
2262 emit_move_insn (handler
, crtl
->eh
.ehr_handler
);
2264 error ("__builtin_eh_return not supported on this target");
2267 emit_label (around_label
);
2270 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2271 POINTERS_EXTEND_UNSIGNED and return it. */
2274 expand_builtin_extend_pointer (tree addr_tree
)
2276 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2279 #ifdef POINTERS_EXTEND_UNSIGNED
2280 extend
= POINTERS_EXTEND_UNSIGNED
;
2282 /* The previous EH code did an unsigned extend by default, so we do this also
2287 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2291 add_action_record (action_hash_type
*ar_hash
, int filter
, int next
)
2293 struct action_record
**slot
, *new_ar
, tmp
;
2295 tmp
.filter
= filter
;
2297 slot
= ar_hash
->find_slot (&tmp
, INSERT
);
2299 if ((new_ar
= *slot
) == NULL
)
2301 new_ar
= XNEW (struct action_record
);
2302 new_ar
->offset
= crtl
->eh
.action_record_data
->length () + 1;
2303 new_ar
->filter
= filter
;
2304 new_ar
->next
= next
;
2307 /* The filter value goes in untouched. The link to the next
2308 record is a "self-relative" byte offset, or zero to indicate
2309 that there is no next record. So convert the absolute 1 based
2310 indices we've been carrying around into a displacement. */
2312 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2314 next
-= crtl
->eh
.action_record_data
->length () + 1;
2315 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2318 return new_ar
->offset
;
2322 collect_one_action_chain (action_hash_type
*ar_hash
, eh_region region
)
2326 /* If we've reached the top of the region chain, then we have
2327 no actions, and require no landing pad. */
2331 switch (region
->type
)
2336 /* A cleanup adds a zero filter to the beginning of the chain, but
2337 there are special cases to look out for. If there are *only*
2338 cleanups along a path, then it compresses to a zero action.
2339 Further, if there are multiple cleanups along a path, we only
2340 need to represent one of them, as that is enough to trigger
2341 entry to the landing pad at runtime. */
2342 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2345 for (r
= region
->outer
; r
; r
= r
->outer
)
2346 if (r
->type
== ERT_CLEANUP
)
2348 return add_action_record (ar_hash
, 0, next
);
2355 /* Process the associated catch regions in reverse order.
2356 If there's a catch-all handler, then we don't need to
2357 search outer regions. Use a magic -3 value to record
2358 that we haven't done the outer search. */
2360 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2362 if (c
->type_list
== NULL
)
2364 /* Retrieve the filter from the head of the filter list
2365 where we have stored it (see assign_filter_values). */
2366 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2367 next
= add_action_record (ar_hash
, filter
, 0);
2371 /* Once the outer search is done, trigger an action record for
2372 each filter we have. */
2377 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2379 /* If there is no next action, terminate the chain. */
2382 /* If all outer actions are cleanups or must_not_throw,
2383 we'll have no action record for it, since we had wanted
2384 to encode these states in the call-site record directly.
2385 Add a cleanup action to the chain to catch these. */
2387 next
= add_action_record (ar_hash
, 0, 0);
2390 flt_node
= c
->filter_list
;
2391 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2393 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2394 next
= add_action_record (ar_hash
, filter
, next
);
2401 case ERT_ALLOWED_EXCEPTIONS
:
2402 /* An exception specification adds its filter to the
2403 beginning of the chain. */
2404 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2406 /* If there is no next action, terminate the chain. */
2409 /* If all outer actions are cleanups or must_not_throw,
2410 we'll have no action record for it, since we had wanted
2411 to encode these states in the call-site record directly.
2412 Add a cleanup action to the chain to catch these. */
2414 next
= add_action_record (ar_hash
, 0, 0);
2416 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2418 case ERT_MUST_NOT_THROW
:
2419 /* A must-not-throw region with no inner handlers or cleanups
2420 requires no call-site entry. Note that this differs from
2421 the no handler or cleanup case in that we do require an lsda
2422 to be generated. Return a magic -2 value to record this. */
2430 add_call_site (rtx landing_pad
, int action
, int section
)
2432 call_site_record record
;
2434 record
= ggc_alloc
<call_site_record_d
> ();
2435 record
->landing_pad
= landing_pad
;
2436 record
->action
= action
;
2438 vec_safe_push (crtl
->eh
.call_site_record_v
[section
], record
);
2440 return call_site_base
+ crtl
->eh
.call_site_record_v
[section
]->length () - 1;
2444 emit_note_eh_region_end (rtx_insn
*insn
)
2446 rtx_insn
*next
= NEXT_INSN (insn
);
2448 /* Make sure we do not split a call and its corresponding
2449 CALL_ARG_LOCATION note. */
2450 if (next
&& NOTE_P (next
)
2451 && NOTE_KIND (next
) == NOTE_INSN_CALL_ARG_LOCATION
)
2454 return emit_note_after (NOTE_INSN_EH_REGION_END
, insn
);
2457 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2458 The new note numbers will not refer to region numbers, but
2459 instead to call site entries. */
2462 convert_to_eh_region_ranges (void)
2467 action_hash_type
ar_hash (31);
2468 int last_action
= -3;
2469 rtx_insn
*last_action_insn
= NULL
;
2470 rtx last_landing_pad
= NULL_RTX
;
2471 rtx_insn
*first_no_action_insn
= NULL
;
2474 rtx_insn
*section_switch_note
= NULL
;
2475 rtx_insn
*first_no_action_insn_before_switch
= NULL
;
2476 rtx_insn
*last_no_action_insn_before_switch
= NULL
;
2477 int saved_call_site_base
= call_site_base
;
2479 vec_alloc (crtl
->eh
.action_record_data
, 64);
2481 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2488 rtx_code_label
*this_landing_pad
;
2491 if (NONJUMP_INSN_P (insn
)
2492 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2493 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2495 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2499 this_action
= collect_one_action_chain (&ar_hash
, region
);
2503 /* Existence of catch handlers, or must-not-throw regions
2504 implies that an lsda is needed (even if empty). */
2505 if (this_action
!= -1)
2506 crtl
->uses_eh_lsda
= 1;
2508 /* Delay creation of region notes for no-action regions
2509 until we're sure that an lsda will be required. */
2510 else if (last_action
== -3)
2512 first_no_action_insn
= iter
;
2516 if (this_action
>= 0)
2517 this_landing_pad
= lp
->landing_pad
;
2519 this_landing_pad
= NULL
;
2521 /* Differing actions or landing pads implies a change in call-site
2522 info, which implies some EH_REGION note should be emitted. */
2523 if (last_action
!= this_action
2524 || last_landing_pad
!= this_landing_pad
)
2526 /* If there is a queued no-action region in the other section
2527 with hot/cold partitioning, emit it now. */
2528 if (first_no_action_insn_before_switch
)
2530 gcc_assert (this_action
!= -1
2531 && last_action
== (first_no_action_insn
2533 call_site
= add_call_site (NULL_RTX
, 0, 0);
2534 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2535 first_no_action_insn_before_switch
);
2536 NOTE_EH_HANDLER (note
) = call_site
;
2538 = emit_note_eh_region_end (last_no_action_insn_before_switch
);
2539 NOTE_EH_HANDLER (note
) = call_site
;
2540 gcc_assert (last_action
!= -3
2541 || (last_action_insn
2542 == last_no_action_insn_before_switch
));
2543 first_no_action_insn_before_switch
= NULL
;
2544 last_no_action_insn_before_switch
= NULL
;
2547 /* If we'd not seen a previous action (-3) or the previous
2548 action was must-not-throw (-2), then we do not need an
2550 if (last_action
>= -1)
2552 /* If we delayed the creation of the begin, do it now. */
2553 if (first_no_action_insn
)
2555 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2556 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2557 first_no_action_insn
);
2558 NOTE_EH_HANDLER (note
) = call_site
;
2559 first_no_action_insn
= NULL
;
2562 note
= emit_note_eh_region_end (last_action_insn
);
2563 NOTE_EH_HANDLER (note
) = call_site
;
2566 /* If the new action is must-not-throw, then no region notes
2568 if (this_action
>= -1)
2570 call_site
= add_call_site (this_landing_pad
,
2571 this_action
< 0 ? 0 : this_action
,
2573 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2574 NOTE_EH_HANDLER (note
) = call_site
;
2577 last_action
= this_action
;
2578 last_landing_pad
= this_landing_pad
;
2580 last_action_insn
= iter
;
2582 else if (NOTE_P (iter
)
2583 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2585 gcc_assert (section_switch_note
== NULL_RTX
);
2586 gcc_assert (flag_reorder_blocks_and_partition
);
2587 section_switch_note
= iter
;
2588 if (first_no_action_insn
)
2590 first_no_action_insn_before_switch
= first_no_action_insn
;
2591 last_no_action_insn_before_switch
= last_action_insn
;
2592 first_no_action_insn
= NULL
;
2593 gcc_assert (last_action
== -1);
2596 /* Force closing of current EH region before section switch and
2597 opening a new one afterwards. */
2598 else if (last_action
!= -3)
2599 last_landing_pad
= pc_rtx
;
2600 if (crtl
->eh
.call_site_record_v
[cur_sec
])
2601 call_site_base
+= crtl
->eh
.call_site_record_v
[cur_sec
]->length ();
2603 gcc_assert (crtl
->eh
.call_site_record_v
[cur_sec
] == NULL
);
2604 vec_alloc (crtl
->eh
.call_site_record_v
[cur_sec
], 10);
2607 if (last_action
>= -1 && ! first_no_action_insn
)
2609 note
= emit_note_eh_region_end (last_action_insn
);
2610 NOTE_EH_HANDLER (note
) = call_site
;
2613 call_site_base
= saved_call_site_base
;
2620 const pass_data pass_data_convert_to_eh_region_ranges
=
2622 RTL_PASS
, /* type */
2623 "eh_ranges", /* name */
2624 OPTGROUP_NONE
, /* optinfo_flags */
2625 TV_NONE
, /* tv_id */
2626 0, /* properties_required */
2627 0, /* properties_provided */
2628 0, /* properties_destroyed */
2629 0, /* todo_flags_start */
2630 0, /* todo_flags_finish */
2633 class pass_convert_to_eh_region_ranges
: public rtl_opt_pass
2636 pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2637 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges
, ctxt
)
2640 /* opt_pass methods: */
2641 virtual bool gate (function
*);
2642 virtual unsigned int execute (function
*)
2644 return convert_to_eh_region_ranges ();
2647 }; // class pass_convert_to_eh_region_ranges
2650 pass_convert_to_eh_region_ranges::gate (function
*)
2652 /* Nothing to do for SJLJ exceptions or if no regions created. */
2653 if (cfun
->eh
->region_tree
== NULL
)
2655 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2663 make_pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2665 return new pass_convert_to_eh_region_ranges (ctxt
);
2669 push_uleb128 (vec
<uchar
, va_gc
> **data_area
, unsigned int value
)
2673 unsigned char byte
= value
& 0x7f;
2677 vec_safe_push (*data_area
, byte
);
2683 push_sleb128 (vec
<uchar
, va_gc
> **data_area
, int value
)
2690 byte
= value
& 0x7f;
2692 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2693 || (value
== -1 && (byte
& 0x40) != 0));
2696 vec_safe_push (*data_area
, byte
);
2702 #ifndef HAVE_AS_LEB128
2704 dw2_size_of_call_site_table (int section
)
2706 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2707 int size
= n
* (4 + 4 + 4);
2710 for (i
= 0; i
< n
; ++i
)
2712 struct call_site_record_d
*cs
=
2713 (*crtl
->eh
.call_site_record_v
[section
])[i
];
2714 size
+= size_of_uleb128 (cs
->action
);
2721 sjlj_size_of_call_site_table (void)
2723 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2727 for (i
= 0; i
< n
; ++i
)
2729 struct call_site_record_d
*cs
=
2730 (*crtl
->eh
.call_site_record_v
[0])[i
];
2731 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2732 size
+= size_of_uleb128 (cs
->action
);
2740 dw2_output_call_site_table (int cs_format
, int section
)
2742 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2747 begin
= current_function_func_begin_label
;
2748 else if (first_function_block_is_cold
)
2749 begin
= crtl
->subsections
.hot_section_label
;
2751 begin
= crtl
->subsections
.cold_section_label
;
2753 for (i
= 0; i
< n
; ++i
)
2755 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[section
])[i
];
2756 char reg_start_lab
[32];
2757 char reg_end_lab
[32];
2758 char landing_pad_lab
[32];
2760 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2761 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2763 if (cs
->landing_pad
)
2764 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2765 CODE_LABEL_NUMBER (cs
->landing_pad
));
2767 /* ??? Perhaps use insn length scaling if the assembler supports
2768 generic arithmetic. */
2769 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2770 data4 if the function is small enough. */
2771 if (cs_format
== DW_EH_PE_uleb128
)
2773 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2774 "region %d start", i
);
2775 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2777 if (cs
->landing_pad
)
2778 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2781 dw2_asm_output_data_uleb128 (0, "landing pad");
2785 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2786 "region %d start", i
);
2787 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2788 if (cs
->landing_pad
)
2789 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2792 dw2_asm_output_data (4, 0, "landing pad");
2794 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2797 call_site_base
+= n
;
2801 sjlj_output_call_site_table (void)
2803 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2806 for (i
= 0; i
< n
; ++i
)
2808 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[0])[i
];
2810 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2811 "region %d landing pad", i
);
2812 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2815 call_site_base
+= n
;
2818 /* Switch to the section that should be used for exception tables. */
2821 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2825 if (exception_section
)
2826 s
= exception_section
;
2831 if (EH_TABLES_CAN_BE_READ_ONLY
)
2834 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2835 flags
= ((! flag_pic
2836 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2837 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2838 ? 0 : SECTION_WRITE
);
2841 flags
= SECTION_WRITE
;
2843 /* Compute the section and cache it into exception_section,
2844 unless it depends on the function name. */
2845 if (targetm_common
.have_named_sections
)
2847 #ifdef HAVE_LD_EH_GC_SECTIONS
2848 if (flag_function_sections
2849 || (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
))
2851 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2852 /* The EH table must match the code section, so only mark
2853 it linkonce if we have COMDAT groups to tie them together. */
2854 if (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
)
2855 flags
|= SECTION_LINKONCE
;
2856 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2857 s
= get_section (section_name
, flags
, current_function_decl
);
2858 free (section_name
);
2863 = s
= get_section (".gcc_except_table", flags
, NULL
);
2867 = s
= flags
== SECTION_WRITE
? data_section
: readonly_data_section
;
2870 switch_to_section (s
);
2874 /* Output a reference from an exception table to the type_info object TYPE.
2875 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2879 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2882 bool is_public
= true;
2884 if (type
== NULL_TREE
)
2888 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2889 runtime types so TYPE should already be a runtime type
2890 reference. When pass_ipa_free_lang data is made a default
2891 pass, we can then remove the call to lookup_type_for_runtime
2894 type
= lookup_type_for_runtime (type
);
2896 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2898 /* Let cgraph know that the rtti decl is used. Not all of the
2899 paths below go through assemble_integer, which would take
2900 care of this for us. */
2902 if (TREE_CODE (type
) == ADDR_EXPR
)
2904 type
= TREE_OPERAND (type
, 0);
2905 if (TREE_CODE (type
) == VAR_DECL
)
2906 is_public
= TREE_PUBLIC (type
);
2909 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
2912 /* Allow the target to override the type table entry format. */
2913 if (targetm
.asm_out
.ttype (value
))
2916 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
2917 assemble_integer (value
, tt_format_size
,
2918 tt_format_size
* BITS_PER_UNIT
, 1);
2920 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
2924 output_one_function_exception_table (int section
)
2926 int tt_format
, cs_format
, lp_format
, i
;
2927 #ifdef HAVE_AS_LEB128
2928 char ttype_label
[32];
2929 char cs_after_size_label
[32];
2930 char cs_end_label
[32];
2935 int tt_format_size
= 0;
2937 have_tt_data
= (vec_safe_length (cfun
->eh
->ttype_data
)
2938 || (targetm
.arm_eabi_unwinder
2939 ? vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
)
2940 : vec_safe_length (cfun
->eh
->ehspec_data
.other
)));
2942 /* Indicate the format of the @TType entries. */
2944 tt_format
= DW_EH_PE_omit
;
2947 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2948 #ifdef HAVE_AS_LEB128
2949 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
2950 section
? "LLSDATTC" : "LLSDATT",
2951 current_function_funcdef_no
);
2953 tt_format_size
= size_of_encoded_value (tt_format
);
2955 assemble_align (tt_format_size
* BITS_PER_UNIT
);
2958 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
2959 current_function_funcdef_no
);
2961 /* The LSDA header. */
2963 /* Indicate the format of the landing pad start pointer. An omitted
2964 field implies @LPStart == @Start. */
2965 /* Currently we always put @LPStart == @Start. This field would
2966 be most useful in moving the landing pads completely out of
2967 line to another section, but it could also be used to minimize
2968 the size of uleb128 landing pad offsets. */
2969 lp_format
= DW_EH_PE_omit
;
2970 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
2971 eh_data_format_name (lp_format
));
2973 /* @LPStart pointer would go here. */
2975 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
2976 eh_data_format_name (tt_format
));
2978 #ifndef HAVE_AS_LEB128
2979 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2980 call_site_len
= sjlj_size_of_call_site_table ();
2982 call_site_len
= dw2_size_of_call_site_table (section
);
2985 /* A pc-relative 4-byte displacement to the @TType data. */
2988 #ifdef HAVE_AS_LEB128
2989 char ttype_after_disp_label
[32];
2990 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
2991 section
? "LLSDATTDC" : "LLSDATTD",
2992 current_function_funcdef_no
);
2993 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
2994 "@TType base offset");
2995 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
2997 /* Ug. Alignment queers things. */
2998 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3000 before_disp
= 1 + 1;
3001 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3003 + vec_safe_length (crtl
->eh
.action_record_data
)
3004 + (vec_safe_length (cfun
->eh
->ttype_data
)
3010 unsigned int disp_size
, pad
;
3013 disp_size
= size_of_uleb128 (disp
);
3014 pad
= before_disp
+ disp_size
+ after_disp
;
3015 if (pad
% tt_format_size
)
3016 pad
= tt_format_size
- (pad
% tt_format_size
);
3019 disp
= after_disp
+ pad
;
3021 while (disp
!= last_disp
);
3023 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3027 /* Indicate the format of the call-site offsets. */
3028 #ifdef HAVE_AS_LEB128
3029 cs_format
= DW_EH_PE_uleb128
;
3031 cs_format
= DW_EH_PE_udata4
;
3033 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3034 eh_data_format_name (cs_format
));
3036 #ifdef HAVE_AS_LEB128
3037 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3038 section
? "LLSDACSBC" : "LLSDACSB",
3039 current_function_funcdef_no
);
3040 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3041 section
? "LLSDACSEC" : "LLSDACSE",
3042 current_function_funcdef_no
);
3043 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3044 "Call-site table length");
3045 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3046 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3047 sjlj_output_call_site_table ();
3049 dw2_output_call_site_table (cs_format
, section
);
3050 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3052 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3053 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3054 sjlj_output_call_site_table ();
3056 dw2_output_call_site_table (cs_format
, section
);
3059 /* ??? Decode and interpret the data for flag_debug_asm. */
3062 FOR_EACH_VEC_ELT (*crtl
->eh
.action_record_data
, i
, uc
)
3063 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3067 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3069 i
= vec_safe_length (cfun
->eh
->ttype_data
);
3072 tree type
= (*cfun
->eh
->ttype_data
)[i
];
3073 output_ttype (type
, tt_format
, tt_format_size
);
3076 #ifdef HAVE_AS_LEB128
3078 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3081 /* ??? Decode and interpret the data for flag_debug_asm. */
3082 if (targetm
.arm_eabi_unwinder
)
3086 vec_safe_iterate (cfun
->eh
->ehspec_data
.arm_eabi
, i
, &type
); ++i
)
3087 output_ttype (type
, tt_format
, tt_format_size
);
3093 vec_safe_iterate (cfun
->eh
->ehspec_data
.other
, i
, &uc
); ++i
)
3094 dw2_asm_output_data (1, uc
,
3095 i
? NULL
: "Exception specification table");
3100 output_function_exception_table (const char *fnname
)
3102 rtx personality
= get_personality_function (current_function_decl
);
3104 /* Not all functions need anything. */
3105 if (! crtl
->uses_eh_lsda
)
3110 assemble_external_libcall (personality
);
3112 if (targetm
.asm_out
.emit_except_personality
)
3113 targetm
.asm_out
.emit_except_personality (personality
);
3116 switch_to_exception_section (fnname
);
3118 /* If the target wants a label to begin the table, emit it here. */
3119 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3121 output_one_function_exception_table (0);
3122 if (crtl
->eh
.call_site_record_v
[1])
3123 output_one_function_exception_table (1);
3125 switch_to_section (current_function_section ());
3129 set_eh_throw_stmt_table (function
*fun
, hash_map
<gimple
*, int> *table
)
3131 fun
->eh
->throw_stmt_table
= table
;
3134 hash_map
<gimple
*, int> *
3135 get_eh_throw_stmt_table (struct function
*fun
)
3137 return fun
->eh
->throw_stmt_table
;
3140 /* Determine if the function needs an EH personality function. */
3142 enum eh_personality_kind
3143 function_needs_eh_personality (struct function
*fn
)
3145 enum eh_personality_kind kind
= eh_personality_none
;
3148 FOR_ALL_EH_REGION_FN (i
, fn
)
3153 /* Can do with any personality including the generic C one. */
3154 kind
= eh_personality_any
;
3158 case ERT_ALLOWED_EXCEPTIONS
:
3159 /* Always needs a EH personality function. The generic C
3160 personality doesn't handle these even for empty type lists. */
3161 return eh_personality_lang
;
3163 case ERT_MUST_NOT_THROW
:
3164 /* Always needs a EH personality function. The language may specify
3165 what abort routine that must be used, e.g. std::terminate. */
3166 return eh_personality_lang
;
3173 /* Dump EH information to OUT. */
3176 dump_eh_tree (FILE * out
, struct function
*fun
)
3180 static const char *const type_name
[] = {
3181 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3184 i
= fun
->eh
->region_tree
;
3188 fprintf (out
, "Eh tree:\n");
3191 fprintf (out
, " %*s %i %s", depth
* 2, "",
3192 i
->index
, type_name
[(int) i
->type
]);
3194 if (i
->landing_pads
)
3198 fprintf (out
, " land:");
3199 if (current_ir_type () == IR_GIMPLE
)
3201 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3203 fprintf (out
, "{%i,", lp
->index
);
3204 print_generic_expr (out
, lp
->post_landing_pad
, 0);
3212 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3214 fprintf (out
, "{%i,", lp
->index
);
3215 if (lp
->landing_pad
)
3216 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3217 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3219 fprintf (out
, "(nil),");
3220 if (lp
->post_landing_pad
)
3222 rtx_insn
*lab
= label_rtx (lp
->post_landing_pad
);
3223 fprintf (out
, "%i%s}", INSN_UID (lab
),
3224 NOTE_P (lab
) ? "(del)" : "");
3227 fprintf (out
, "(nil)}");
3237 case ERT_MUST_NOT_THROW
:
3243 fprintf (out
, " catch:");
3244 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3249 fprintf (out
, "lab:");
3250 print_generic_expr (out
, c
->label
, 0);
3253 print_generic_expr (out
, c
->type_list
, 0);
3261 case ERT_ALLOWED_EXCEPTIONS
:
3262 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3263 print_generic_expr (out
, i
->u
.allowed
.type_list
, 0);
3268 /* If there are sub-regions, process them. */
3270 i
= i
->inner
, depth
++;
3271 /* If there are peers, process them. */
3272 else if (i
->next_peer
)
3274 /* Otherwise, step back up the tree to the next peer. */
3284 while (i
->next_peer
== NULL
);
3290 /* Dump the EH tree for FN on stderr. */
3293 debug_eh_tree (struct function
*fn
)
3295 dump_eh_tree (stderr
, fn
);
3298 /* Verify invariants on EH datastructures. */
3301 verify_eh_tree (struct function
*fun
)
3304 int nvisited_lp
, nvisited_r
;
3305 int count_lp
, count_r
, depth
, i
;
3309 if (!fun
->eh
->region_tree
)
3313 for (i
= 1; vec_safe_iterate (fun
->eh
->region_array
, i
, &r
); ++i
)
3320 error ("region_array is corrupted for region %i", r
->index
);
3326 for (i
= 1; vec_safe_iterate (fun
->eh
->lp_array
, i
, &lp
); ++i
)
3333 error ("lp_array is corrupted for lp %i", lp
->index
);
3338 depth
= nvisited_lp
= nvisited_r
= 0;
3340 r
= fun
->eh
->region_tree
;
3343 if ((*fun
->eh
->region_array
)[r
->index
] != r
)
3345 error ("region_array is corrupted for region %i", r
->index
);
3348 if (r
->outer
!= outer
)
3350 error ("outer block of region %i is wrong", r
->index
);
3355 error ("negative nesting depth of region %i", r
->index
);
3360 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3362 if ((*fun
->eh
->lp_array
)[lp
->index
] != lp
)
3364 error ("lp_array is corrupted for lp %i", lp
->index
);
3367 if (lp
->region
!= r
)
3369 error ("region of lp %i is wrong", lp
->index
);
3376 outer
= r
, r
= r
->inner
, depth
++;
3377 else if (r
->next_peer
)
3389 while (r
->next_peer
== NULL
);
3396 error ("tree list ends on depth %i", depth
);
3399 if (count_r
!= nvisited_r
)
3401 error ("region_array does not match region_tree");
3404 if (count_lp
!= nvisited_lp
)
3406 error ("lp_array does not match region_tree");
3412 dump_eh_tree (stderr
, fun
);
3413 internal_error ("verify_eh_tree failed");
3417 #include "gt-except.h"