1 /* Implements exception handling.
2 Copyright (C) 1989-2024 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, EH_ELSE_EXPR, WITH_CLEANUP_EXPR,
31 CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
33 During initial gimplification (gimplify.cc) these are lowered to the
34 GIMPLE_TRY, GIMPLE_CATCH, GIMPLE_EH_ELSE, and GIMPLE_EH_FILTER
35 nodes. The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are
36 converted into GIMPLE_TRY_FINALLY nodes; the others are a more
37 direct 1-1 conversion.
39 During pass_lower_eh (tree-eh.cc) 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.cc), 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.cc), 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.cc), 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.cc), 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.cc) 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.cc) emits the required unwind data. */
114 #include "coretypes.h"
119 #include "cfghooks.h"
120 #include "tree-pass.h"
121 #include "memmodel.h"
123 #include "stringpool.h"
126 #include "emit-rtl.h"
128 #include "diagnostic.h"
129 #include "fold-const.h"
130 #include "stor-layout.h"
135 #include "libfuncs.h"
138 #include "dwarf2asm.h"
140 #include "common/common-target.h"
141 #include "langhooks.h"
143 #include "tree-pretty-print.h"
145 #include "builtins.h"
146 #include "tree-hash-traits.h"
149 static GTY(()) int call_site_base
;
151 static GTY(()) hash_map
<tree_hash
, tree
> *type_to_runtime_map
;
153 static GTY(()) tree setjmp_fn
;
155 /* Describe the SjLj_Function_Context structure. */
156 static GTY(()) tree sjlj_fc_type_node
;
157 static int sjlj_fc_call_site_ofs
;
158 static int sjlj_fc_data_ofs
;
159 static int sjlj_fc_personality_ofs
;
160 static int sjlj_fc_lsda_ofs
;
161 static int sjlj_fc_jbuf_ofs
;
164 struct GTY(()) call_site_record_d
170 /* In the following structure and associated functions,
171 we represent entries in the action table as 1-based indices.
174 0: null action record, non-null landing pad; implies cleanups
175 -1: null action record, null landing pad; implies no action
176 -2: no call-site entry; implies must_not_throw
177 -3: we have yet to process outer regions
179 Further, no special cases apply to the "next" field of the record.
180 For next, 0 means end of list. */
189 /* Hashtable helpers. */
191 struct action_record_hasher
: free_ptr_hash
<action_record
>
193 static inline hashval_t
hash (const action_record
*);
194 static inline bool equal (const action_record
*, const action_record
*);
198 action_record_hasher::hash (const action_record
*entry
)
200 return entry
->next
* 1009 + entry
->filter
;
204 action_record_hasher::equal (const action_record
*entry
,
205 const action_record
*data
)
207 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
210 typedef hash_table
<action_record_hasher
> action_hash_type
;
212 static bool get_eh_region_and_lp_from_rtx (const_rtx
, eh_region
*,
215 static void dw2_build_landing_pads (void);
217 static int collect_one_action_chain (action_hash_type
*, eh_region
);
218 static int add_call_site (rtx
, int, int);
220 static void push_uleb128 (vec
<uchar
, va_gc
> **, unsigned int);
221 static void push_sleb128 (vec
<uchar
, va_gc
> **, int);
222 static int dw2_size_of_call_site_table (int);
223 static int sjlj_size_of_call_site_table (void);
224 static void dw2_output_call_site_table (int, int);
225 static void sjlj_output_call_site_table (void);
231 if (! flag_exceptions
)
234 type_to_runtime_map
= hash_map
<tree_hash
, tree
>::create_ggc (31);
236 /* Create the SjLj_Function_Context structure. This should match
237 the definition in unwind-sjlj.c. */
238 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
240 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
242 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
244 f_prev
= build_decl (BUILTINS_LOCATION
,
245 FIELD_DECL
, get_identifier ("__prev"),
246 build_pointer_type (sjlj_fc_type_node
));
247 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
249 f_cs
= build_decl (BUILTINS_LOCATION
,
250 FIELD_DECL
, get_identifier ("__call_site"),
252 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
254 tmp
= build_index_type (size_int (4 - 1));
255 tmp
= build_array_type (lang_hooks
.types
.type_for_mode
256 (targetm
.unwind_word_mode (), 1),
258 f_data
= build_decl (BUILTINS_LOCATION
,
259 FIELD_DECL
, get_identifier ("__data"), tmp
);
260 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
262 f_per
= build_decl (BUILTINS_LOCATION
,
263 FIELD_DECL
, get_identifier ("__personality"),
265 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
267 f_lsda
= build_decl (BUILTINS_LOCATION
,
268 FIELD_DECL
, get_identifier ("__lsda"),
270 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
272 #ifdef DONT_USE_BUILTIN_SETJMP
274 tmp
= size_int (JMP_BUF_SIZE
- 1);
276 /* Should be large enough for most systems, if it is not,
277 JMP_BUF_SIZE should be defined with the proper value. It will
278 also tend to be larger than necessary for most systems, a more
279 optimal port will define JMP_BUF_SIZE. */
280 tmp
= size_int (FIRST_PSEUDO_REGISTER
+ 2 - 1);
283 /* Compute a minimally sized jump buffer. We need room to store at
284 least 3 pointers - stack pointer, frame pointer and return address.
285 Plus for some targets we need room for an extra pointer - in the
286 case of MIPS this is the global pointer. This makes a total of four
287 pointers, but to be safe we actually allocate room for 5.
289 If pointers are smaller than words then we allocate enough room for
290 5 words, just in case the backend needs this much room. For more
291 discussion on this issue see:
292 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
293 if (POINTER_SIZE
> BITS_PER_WORD
)
294 tmp
= size_int (5 - 1);
296 tmp
= size_int ((5 * BITS_PER_WORD
/ POINTER_SIZE
) - 1);
299 tmp
= build_index_type (tmp
);
300 tmp
= build_array_type (ptr_type_node
, tmp
);
301 f_jbuf
= build_decl (BUILTINS_LOCATION
,
302 FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
303 #ifdef DONT_USE_BUILTIN_SETJMP
304 /* We don't know what the alignment requirements of the
305 runtime's jmp_buf has. Overestimate. */
306 SET_DECL_ALIGN (f_jbuf
, BIGGEST_ALIGNMENT
);
307 DECL_USER_ALIGN (f_jbuf
) = 1;
309 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
311 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
312 TREE_CHAIN (f_prev
) = f_cs
;
313 TREE_CHAIN (f_cs
) = f_data
;
314 TREE_CHAIN (f_data
) = f_per
;
315 TREE_CHAIN (f_per
) = f_lsda
;
316 TREE_CHAIN (f_lsda
) = f_jbuf
;
318 layout_type (sjlj_fc_type_node
);
320 /* Cache the interesting field offsets so that we have
321 easy access from rtl. */
322 sjlj_fc_call_site_ofs
323 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs
))
324 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs
)) / BITS_PER_UNIT
);
326 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data
))
327 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data
)) / BITS_PER_UNIT
);
328 sjlj_fc_personality_ofs
329 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per
))
330 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per
)) / BITS_PER_UNIT
);
332 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda
))
333 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda
)) / BITS_PER_UNIT
);
335 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf
))
336 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf
)) / BITS_PER_UNIT
);
338 #ifdef DONT_USE_BUILTIN_SETJMP
339 tmp
= build_function_type_list (integer_type_node
, TREE_TYPE (f_jbuf
),
341 setjmp_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
342 get_identifier ("setjmp"), tmp
);
343 TREE_PUBLIC (setjmp_fn
) = 1;
344 DECL_EXTERNAL (setjmp_fn
) = 1;
345 DECL_ASSEMBLER_NAME (setjmp_fn
);
351 init_eh_for_function (void)
353 cfun
->eh
= ggc_cleared_alloc
<eh_status
> ();
355 /* Make sure zero'th entries are used. */
356 vec_safe_push (cfun
->eh
->region_array
, (eh_region
)0);
357 vec_safe_push (cfun
->eh
->lp_array
, (eh_landing_pad
)0);
360 /* Routines to generate the exception tree somewhat directly.
361 These are used from tree-eh.cc when processing exception related
362 nodes during tree optimization. */
365 gen_eh_region (enum eh_region_type type
, eh_region outer
)
369 /* Insert a new blank region as a leaf in the tree. */
370 new_eh
= ggc_cleared_alloc
<eh_region_d
> ();
372 new_eh
->outer
= outer
;
375 new_eh
->next_peer
= outer
->inner
;
376 outer
->inner
= new_eh
;
380 new_eh
->next_peer
= cfun
->eh
->region_tree
;
381 cfun
->eh
->region_tree
= new_eh
;
384 new_eh
->index
= vec_safe_length (cfun
->eh
->region_array
);
385 vec_safe_push (cfun
->eh
->region_array
, new_eh
);
387 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
388 if (targetm
.arm_eabi_unwinder
&& lang_hooks
.eh_use_cxa_end_cleanup
)
389 new_eh
->use_cxa_end_cleanup
= true;
395 gen_eh_region_cleanup (eh_region outer
)
397 return gen_eh_region (ERT_CLEANUP
, outer
);
401 gen_eh_region_try (eh_region outer
)
403 return gen_eh_region (ERT_TRY
, outer
);
407 gen_eh_region_catch (eh_region t
, tree type_or_list
)
410 tree type_list
, type_node
;
412 gcc_assert (t
->type
== ERT_TRY
);
414 /* Ensure to always end up with a type list to normalize further
415 processing, then register each type against the runtime types map. */
416 type_list
= type_or_list
;
419 if (TREE_CODE (type_or_list
) != TREE_LIST
)
420 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
422 type_node
= type_list
;
423 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
424 add_type_for_runtime (TREE_VALUE (type_node
));
427 c
= ggc_cleared_alloc
<eh_catch_d
> ();
428 c
->type_list
= type_list
;
429 l
= t
->u
.eh_try
.last_catch
;
434 t
->u
.eh_try
.first_catch
= c
;
435 t
->u
.eh_try
.last_catch
= c
;
441 gen_eh_region_allowed (eh_region outer
, tree allowed
)
443 eh_region region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
444 region
->u
.allowed
.type_list
= allowed
;
446 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
447 add_type_for_runtime (TREE_VALUE (allowed
));
453 gen_eh_region_must_not_throw (eh_region outer
)
455 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
459 gen_eh_landing_pad (eh_region region
)
461 eh_landing_pad lp
= ggc_cleared_alloc
<eh_landing_pad_d
> ();
463 lp
->next_lp
= region
->landing_pads
;
465 lp
->index
= vec_safe_length (cfun
->eh
->lp_array
);
466 region
->landing_pads
= lp
;
468 vec_safe_push (cfun
->eh
->lp_array
, lp
);
474 get_eh_region_from_number_fn (struct function
*ifun
, int i
)
476 return (*ifun
->eh
->region_array
)[i
];
480 get_eh_region_from_number (int i
)
482 return get_eh_region_from_number_fn (cfun
, i
);
486 get_eh_landing_pad_from_number_fn (struct function
*ifun
, int i
)
488 return (*ifun
->eh
->lp_array
)[i
];
492 get_eh_landing_pad_from_number (int i
)
494 return get_eh_landing_pad_from_number_fn (cfun
, i
);
498 get_eh_region_from_lp_number_fn (struct function
*ifun
, int i
)
501 return (*ifun
->eh
->region_array
)[-i
];
507 lp
= (*ifun
->eh
->lp_array
)[i
];
513 get_eh_region_from_lp_number (int i
)
515 return get_eh_region_from_lp_number_fn (cfun
, i
);
518 /* Returns true if the current function has exception handling regions. */
521 current_function_has_exception_handlers (void)
523 return cfun
->eh
->region_tree
!= NULL
;
526 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
527 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
529 struct duplicate_eh_regions_data
531 duplicate_eh_regions_map label_map
;
532 void *label_map_data
;
533 hash_map
<void *, void *> *eh_map
;
537 duplicate_eh_regions_1 (struct duplicate_eh_regions_data
*data
,
538 eh_region old_r
, eh_region outer
)
540 eh_landing_pad old_lp
, new_lp
;
543 new_r
= gen_eh_region (old_r
->type
, outer
);
544 gcc_assert (!data
->eh_map
->put (old_r
, new_r
));
554 for (oc
= old_r
->u
.eh_try
.first_catch
; oc
; oc
= oc
->next_catch
)
556 /* We should be doing all our region duplication before and
557 during inlining, which is before filter lists are created. */
558 gcc_assert (oc
->filter_list
== NULL
);
559 nc
= gen_eh_region_catch (new_r
, oc
->type_list
);
560 nc
->label
= data
->label_map (oc
->label
, data
->label_map_data
);
565 case ERT_ALLOWED_EXCEPTIONS
:
566 new_r
->u
.allowed
.type_list
= old_r
->u
.allowed
.type_list
;
567 if (old_r
->u
.allowed
.label
)
568 new_r
->u
.allowed
.label
569 = data
->label_map (old_r
->u
.allowed
.label
, data
->label_map_data
);
571 new_r
->u
.allowed
.label
= NULL_TREE
;
574 case ERT_MUST_NOT_THROW
:
575 new_r
->u
.must_not_throw
.failure_loc
=
576 LOCATION_LOCUS (old_r
->u
.must_not_throw
.failure_loc
);
577 new_r
->u
.must_not_throw
.failure_decl
=
578 old_r
->u
.must_not_throw
.failure_decl
;
582 for (old_lp
= old_r
->landing_pads
; old_lp
; old_lp
= old_lp
->next_lp
)
584 /* Don't bother copying unused landing pads. */
585 if (old_lp
->post_landing_pad
== NULL
)
588 new_lp
= gen_eh_landing_pad (new_r
);
589 gcc_assert (!data
->eh_map
->put (old_lp
, new_lp
));
591 new_lp
->post_landing_pad
592 = data
->label_map (old_lp
->post_landing_pad
, data
->label_map_data
);
593 EH_LANDING_PAD_NR (new_lp
->post_landing_pad
) = new_lp
->index
;
596 /* Make sure to preserve the original use of __cxa_end_cleanup. */
597 new_r
->use_cxa_end_cleanup
= old_r
->use_cxa_end_cleanup
;
599 for (old_r
= old_r
->inner
; old_r
; old_r
= old_r
->next_peer
)
600 duplicate_eh_regions_1 (data
, old_r
, new_r
);
603 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
604 the current function and root the tree below OUTER_REGION.
605 The special case of COPY_REGION of NULL means all regions.
606 Remap labels using MAP/MAP_DATA callback. Return a pointer map
607 that allows the caller to remap uses of both EH regions and
610 hash_map
<void *, void *> *
611 duplicate_eh_regions (struct function
*ifun
,
612 eh_region copy_region
, int outer_lp
,
613 duplicate_eh_regions_map map
, void *map_data
)
615 struct duplicate_eh_regions_data data
;
616 eh_region outer_region
;
619 verify_eh_tree (ifun
);
621 data
.label_map
= map
;
622 data
.label_map_data
= map_data
;
623 data
.eh_map
= new hash_map
<void *, void *>;
625 outer_region
= get_eh_region_from_lp_number_fn (cfun
, outer_lp
);
627 /* Copy all the regions in the subtree. */
629 duplicate_eh_regions_1 (&data
, copy_region
, outer_region
);
633 for (r
= ifun
->eh
->region_tree
; r
; r
= r
->next_peer
)
634 duplicate_eh_regions_1 (&data
, r
, outer_region
);
638 verify_eh_tree (cfun
);
643 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
646 eh_region_outermost (struct function
*ifun
, eh_region region_a
,
649 gcc_assert (ifun
->eh
->region_array
);
650 gcc_assert (ifun
->eh
->region_tree
);
652 auto_sbitmap
b_outer (ifun
->eh
->region_array
->length ());
653 bitmap_clear (b_outer
);
657 bitmap_set_bit (b_outer
, region_b
->index
);
658 region_b
= region_b
->outer
;
664 if (bitmap_bit_p (b_outer
, region_a
->index
))
666 region_a
= region_a
->outer
;
674 add_type_for_runtime (tree type
)
676 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
677 if (TREE_CODE (type
) == NOP_EXPR
)
680 bool existed
= false;
681 tree
*slot
= &type_to_runtime_map
->get_or_insert (type
, &existed
);
683 *slot
= lang_hooks
.eh_runtime_type (type
);
687 lookup_type_for_runtime (tree type
)
689 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
690 if (TREE_CODE (type
) == NOP_EXPR
)
693 /* We should have always inserted the data earlier. */
694 return *type_to_runtime_map
->get (type
);
698 /* Represent an entry in @TTypes for either catch actions
699 or exception filter actions. */
700 struct ttypes_filter
{
705 /* Helper for ttypes_filter hashing. */
707 struct ttypes_filter_hasher
: free_ptr_hash
<ttypes_filter
>
709 typedef tree_node
*compare_type
;
710 static inline hashval_t
hash (const ttypes_filter
*);
711 static inline bool equal (const ttypes_filter
*, const tree_node
*);
714 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
715 (a tree) for a @TTypes type node we are thinking about adding. */
718 ttypes_filter_hasher::equal (const ttypes_filter
*entry
, const tree_node
*data
)
720 return entry
->t
== data
;
724 ttypes_filter_hasher::hash (const ttypes_filter
*entry
)
726 return TREE_HASH (entry
->t
);
729 typedef hash_table
<ttypes_filter_hasher
> ttypes_hash_type
;
732 /* Helper for ehspec hashing. */
734 struct ehspec_hasher
: free_ptr_hash
<ttypes_filter
>
736 static inline hashval_t
hash (const ttypes_filter
*);
737 static inline bool equal (const ttypes_filter
*, const ttypes_filter
*);
740 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
741 exception specification list we are thinking about adding. */
742 /* ??? Currently we use the type lists in the order given. Someone
743 should put these in some canonical order. */
746 ehspec_hasher::equal (const ttypes_filter
*entry
, const ttypes_filter
*data
)
748 return type_list_equal (entry
->t
, data
->t
);
751 /* Hash function for exception specification lists. */
754 ehspec_hasher::hash (const ttypes_filter
*entry
)
759 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
760 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
764 typedef hash_table
<ehspec_hasher
> ehspec_hash_type
;
767 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
768 to speed up the search. Return the filter value to be used. */
771 add_ttypes_entry (ttypes_hash_type
*ttypes_hash
, tree type
)
773 struct ttypes_filter
**slot
, *n
;
775 slot
= ttypes_hash
->find_slot_with_hash (type
, (hashval_t
) TREE_HASH (type
),
778 if ((n
= *slot
) == NULL
)
780 /* Filter value is a 1 based table index. */
782 n
= XNEW (struct ttypes_filter
);
784 n
->filter
= vec_safe_length (cfun
->eh
->ttype_data
) + 1;
787 vec_safe_push (cfun
->eh
->ttype_data
, type
);
793 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
794 to speed up the search. Return the filter value to be used. */
797 add_ehspec_entry (ehspec_hash_type
*ehspec_hash
, ttypes_hash_type
*ttypes_hash
,
800 struct ttypes_filter
**slot
, *n
;
801 struct ttypes_filter dummy
;
804 slot
= ehspec_hash
->find_slot (&dummy
, INSERT
);
806 if ((n
= *slot
) == NULL
)
810 if (targetm
.arm_eabi_unwinder
)
811 len
= vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
);
813 len
= vec_safe_length (cfun
->eh
->ehspec_data
.other
);
815 /* Filter value is a -1 based byte index into a uleb128 buffer. */
817 n
= XNEW (struct ttypes_filter
);
819 n
->filter
= -(len
+ 1);
822 /* Generate a 0 terminated list of filter values. */
823 for (; list
; list
= TREE_CHAIN (list
))
825 if (targetm
.arm_eabi_unwinder
)
826 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, TREE_VALUE (list
));
829 /* Look up each type in the list and encode its filter
830 value as a uleb128. */
831 push_uleb128 (&cfun
->eh
->ehspec_data
.other
,
832 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
835 if (targetm
.arm_eabi_unwinder
)
836 vec_safe_push (cfun
->eh
->ehspec_data
.arm_eabi
, NULL_TREE
);
838 vec_safe_push (cfun
->eh
->ehspec_data
.other
, (uchar
)0);
844 /* Generate the action filter values to be used for CATCH and
845 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
846 we use lots of landing pads, and so every type or list can share
847 the same filter value, which saves table space. */
850 assign_filter_values (void)
856 vec_alloc (cfun
->eh
->ttype_data
, 16);
857 if (targetm
.arm_eabi_unwinder
)
858 vec_alloc (cfun
->eh
->ehspec_data
.arm_eabi
, 64);
860 vec_alloc (cfun
->eh
->ehspec_data
.other
, 64);
862 ehspec_hash_type
ehspec (31);
863 ttypes_hash_type
ttypes (31);
865 for (i
= 1; vec_safe_iterate (cfun
->eh
->region_array
, i
, &r
); ++i
)
873 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
875 /* Whatever type_list is (NULL or true list), we build a list
876 of filters for the region. */
877 c
->filter_list
= NULL_TREE
;
879 if (c
->type_list
!= NULL
)
881 /* Get a filter value for each of the types caught and store
882 them in the region's dedicated list. */
883 tree tp_node
= c
->type_list
;
885 for ( ; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
888 = add_ttypes_entry (&ttypes
, TREE_VALUE (tp_node
));
889 tree flt_node
= build_int_cst (integer_type_node
, flt
);
892 = tree_cons (NULL_TREE
, flt_node
, c
->filter_list
);
897 /* Get a filter value for the NULL list also since it
898 will need an action record anyway. */
899 int flt
= add_ttypes_entry (&ttypes
, NULL
);
900 tree flt_node
= build_int_cst (integer_type_node
, flt
);
903 = tree_cons (NULL_TREE
, flt_node
, NULL
);
908 case ERT_ALLOWED_EXCEPTIONS
:
910 = add_ehspec_entry (&ehspec
, &ttypes
, r
->u
.allowed
.type_list
);
919 /* Emit SEQ into basic block just before INSN (that is assumed to be
920 first instruction of some existing BB and return the newly
923 emit_to_new_bb_before (rtx_insn
*seq
, rtx_insn
*insn
)
925 rtx_insn
*next
, *last
;
930 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
931 call), we don't want it to go into newly created landing pad or other EH
933 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
934 if (e
->flags
& EDGE_FALLTHRU
)
935 force_nonfallthru (e
);
939 /* Make sure to put the location of INSN or a subsequent instruction on SEQ
940 to avoid inheriting the location of the previous instruction. */
942 while (next
&& !NONDEBUG_INSN_P (next
))
943 next
= NEXT_INSN (next
);
945 last
= emit_insn_before_setloc (seq
, insn
, INSN_LOCATION (next
));
947 last
= emit_insn_before (seq
, insn
);
948 if (BARRIER_P (last
))
949 last
= PREV_INSN (last
);
950 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
951 update_bb_for_insn (bb
);
952 bb
->flags
|= BB_SUPERBLOCK
;
956 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
957 at the rtl level. Emit the code required by the target at a landing
958 pad for the given region. */
961 expand_dw2_landing_pad_for_region (eh_region region
)
963 if (targetm
.have_exception_receiver ())
964 emit_insn (targetm
.gen_exception_receiver ());
965 else if (targetm
.have_nonlocal_goto_receiver ())
966 emit_insn (targetm
.gen_nonlocal_goto_receiver ());
970 if (region
->exc_ptr_reg
)
971 emit_move_insn (region
->exc_ptr_reg
,
972 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
973 if (region
->filter_reg
)
974 emit_move_insn (region
->filter_reg
,
975 gen_rtx_REG (targetm
.eh_return_filter_mode (),
976 EH_RETURN_DATA_REGNO (1)));
979 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
982 dw2_build_landing_pads (void)
986 int e_flags
= EDGE_FALLTHRU
;
988 /* If we're going to partition blocks, we need to be able to add
989 new landing pads later, which means that we need to hold on to
990 the post-landing-pad block. Prevent it from being merged away.
991 We'll remove this bit after partitioning. */
992 if (flag_reorder_blocks_and_partition
)
993 e_flags
|= EDGE_PRESERVE
;
995 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1000 if (lp
== NULL
|| lp
->post_landing_pad
== NULL
)
1005 lp
->landing_pad
= gen_label_rtx ();
1006 emit_label (lp
->landing_pad
);
1007 LABEL_PRESERVE_P (lp
->landing_pad
) = 1;
1009 expand_dw2_landing_pad_for_region (lp
->region
);
1014 bb
= emit_to_new_bb_before (seq
, label_rtx (lp
->post_landing_pad
));
1015 bb
->count
= bb
->next_bb
->count
;
1016 make_single_succ_edge (bb
, bb
->next_bb
, e_flags
);
1019 class loop
*loop
= bb
->next_bb
->loop_father
;
1020 /* If we created a pre-header block, add the new block to the
1021 outer loop, otherwise to the loop itself. */
1022 if (bb
->next_bb
== loop
->header
)
1023 add_bb_to_loop (bb
, loop_outer (loop
));
1025 add_bb_to_loop (bb
, loop
);
1031 static vec
<int> sjlj_lp_call_site_index
;
1033 /* Process all active landing pads. Assign each one a compact dispatch
1034 index, and a call-site index. */
1037 sjlj_assign_call_site_values (void)
1039 action_hash_type
ar_hash (31);
1043 vec_alloc (crtl
->eh
.action_record_data
, 64);
1047 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1048 if (lp
&& lp
->post_landing_pad
)
1050 int action
, call_site
;
1052 /* First: build the action table. */
1053 action
= collect_one_action_chain (&ar_hash
, lp
->region
);
1055 /* Next: assign call-site values. If dwarf2 terms, this would be
1056 the region number assigned by convert_to_eh_region_ranges, but
1057 handles no-action and must-not-throw differently. */
1058 /* Map must-not-throw to otherwise unused call-site index 0. */
1061 /* Map no-action to otherwise unused call-site index -1. */
1062 else if (action
== -1)
1064 /* Otherwise, look it up in the table. */
1066 call_site
= add_call_site (GEN_INT (disp_index
), action
, 0);
1067 sjlj_lp_call_site_index
[i
] = call_site
;
1075 /* Emit code to record the current call-site index before every
1076 insn that can throw. */
1079 sjlj_mark_call_sites (void)
1081 int last_call_site
= -2;
1085 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1091 rtx_insn
*before
, *p
;
1093 /* Reset value tracking at extended basic block boundaries. */
1095 last_call_site
= -2;
1097 /* If the function allocates dynamic stack space, the context must
1098 be updated after every allocation/deallocation accordingly. */
1099 if (NOTE_P (insn
) && NOTE_KIND (insn
) == NOTE_INSN_UPDATE_SJLJ_CONTEXT
)
1104 buf_addr
= plus_constant (Pmode
, XEXP (crtl
->eh
.sjlj_fc
, 0),
1106 expand_builtin_update_setjmp_buf (buf_addr
);
1109 emit_insn_before (p
, insn
);
1112 if (! INSN_P (insn
))
1115 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1119 this_call_site
= sjlj_lp_call_site_index
[lp
->index
];
1122 /* Calls (and trapping insns) without notes are outside any
1123 exception handling region in this function. Mark them as
1125 this_call_site
= -1;
1129 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1133 if (this_call_site
!= -1)
1134 crtl
->uses_eh_lsda
= 1;
1136 if (this_call_site
== last_call_site
)
1139 /* Don't separate a call from it's argument loads. */
1142 before
= find_first_parameter_load (insn
, NULL
);
1145 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1146 sjlj_fc_call_site_ofs
);
1147 emit_move_insn (mem
, gen_int_mode (this_call_site
, GET_MODE (mem
)));
1151 emit_insn_before (p
, before
);
1152 last_call_site
= this_call_site
;
1156 /* Construct the SjLj_Function_Context. */
1159 sjlj_emit_function_enter (rtx_code_label
*dispatch_label
)
1161 rtx_insn
*fn_begin
, *seq
;
1163 bool fn_begin_outside_block
;
1164 rtx personality
= get_personality_function (current_function_decl
);
1166 fc
= crtl
->eh
.sjlj_fc
;
1170 /* We're storing this libcall's address into memory instead of
1171 calling it directly. Thus, we must call assemble_external_libcall
1172 here, as we cannot depend on emit_library_call to do it for us. */
1173 assemble_external_libcall (personality
);
1174 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1175 emit_move_insn (mem
, personality
);
1177 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1178 if (crtl
->uses_eh_lsda
)
1183 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1184 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1185 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1186 emit_move_insn (mem
, sym
);
1189 emit_move_insn (mem
, const0_rtx
);
1193 rtx addr
= plus_constant (Pmode
, XEXP (fc
, 0), sjlj_fc_jbuf_ofs
);
1195 #ifdef DONT_USE_BUILTIN_SETJMP
1196 addr
= copy_addr_to_reg (addr
);
1197 addr
= convert_memory_address (ptr_mode
, addr
);
1198 tree addr_tree
= make_tree (ptr_type_node
, addr
);
1200 tree call_expr
= build_call_expr (setjmp_fn
, 1, addr_tree
);
1201 rtx x
= expand_call (call_expr
, NULL_RTX
, false);
1203 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1204 TYPE_MODE (integer_type_node
), 0,
1206 profile_probability::unlikely ());
1208 expand_builtin_setjmp_setup (addr
, dispatch_label
);
1212 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1213 XEXP (fc
, 0), Pmode
);
1218 /* ??? Instead of doing this at the beginning of the function,
1219 do this in a block that is at loop level 0 and dominates all
1220 can_throw_internal instructions. */
1222 fn_begin_outside_block
= true;
1223 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1224 if (NOTE_P (fn_begin
))
1226 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1228 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1229 fn_begin_outside_block
= false;
1232 #ifdef DONT_USE_BUILTIN_SETJMP
1235 /* The sequence contains a branch in the middle so we need to force
1236 the creation of a new basic block by means of BB_SUPERBLOCK. */
1237 if (fn_begin_outside_block
)
1240 = split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1241 if (JUMP_P (BB_END (bb
)))
1242 emit_insn_before (seq
, BB_END (bb
));
1244 emit_insn_after (seq
, BB_END (bb
));
1247 emit_insn_after (seq
, fn_begin
);
1249 single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->flags
|= BB_SUPERBLOCK
;
1254 if (fn_begin_outside_block
)
1255 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1257 emit_insn_after (seq
, fn_begin
);
1260 /* Call back from expand_function_end to know where we should put
1261 the call to unwind_sjlj_unregister_libfunc if needed. */
1264 sjlj_emit_function_exit_after (rtx_insn
*after
)
1266 crtl
->eh
.sjlj_exit_after
= after
;
1270 sjlj_emit_function_exit (void)
1272 rtx_insn
*seq
, *insn
;
1276 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1277 XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1282 /* ??? Really this can be done in any block at loop level 0 that
1283 post-dominates all can_throw_internal instructions. This is
1284 the last possible moment. */
1286 insn
= crtl
->eh
.sjlj_exit_after
;
1288 insn
= NEXT_INSN (insn
);
1290 emit_insn_after (seq
, insn
);
1294 sjlj_emit_dispatch_table (rtx_code_label
*dispatch_label
, int num_dispatch
)
1296 scalar_int_mode unwind_word_mode
= targetm
.unwind_word_mode ();
1297 scalar_int_mode filter_mode
= targetm
.eh_return_filter_mode ();
1299 rtx mem
, fc
, exc_ptr_reg
, filter_reg
;
1304 vec
<tree
> dispatch_labels
= vNULL
;
1306 fc
= crtl
->eh
.sjlj_fc
;
1310 emit_label (dispatch_label
);
1312 #ifndef DONT_USE_BUILTIN_SETJMP
1313 expand_builtin_setjmp_receiver (dispatch_label
);
1315 /* The caller of expand_builtin_setjmp_receiver is responsible for
1316 making sure that the label doesn't vanish. The only other caller
1317 is the expander for __builtin_setjmp_receiver, which places this
1318 label on the nonlocal_goto_label list. Since we're modeling these
1319 CFG edges more exactly, we can use the forced_labels list instead. */
1320 LABEL_PRESERVE_P (dispatch_label
) = 1;
1321 vec_safe_push
<rtx_insn
*> (forced_labels
, dispatch_label
);
1324 /* Load up exc_ptr and filter values from the function context. */
1325 mem
= adjust_address (fc
, unwind_word_mode
, sjlj_fc_data_ofs
);
1326 if (unwind_word_mode
!= ptr_mode
)
1328 #ifdef POINTERS_EXTEND_UNSIGNED
1329 mem
= convert_memory_address (ptr_mode
, mem
);
1331 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1334 exc_ptr_reg
= force_reg (ptr_mode
, mem
);
1336 mem
= adjust_address (fc
, unwind_word_mode
,
1337 sjlj_fc_data_ofs
+ GET_MODE_SIZE (unwind_word_mode
));
1338 if (unwind_word_mode
!= filter_mode
)
1339 mem
= convert_to_mode (filter_mode
, mem
, 0);
1340 filter_reg
= force_reg (filter_mode
, mem
);
1342 /* Jump to one of the directly reachable regions. */
1345 rtx_code_label
*first_reachable_label
= NULL
;
1347 /* If there's exactly one call site in the function, don't bother
1348 generating a switch statement. */
1349 if (num_dispatch
> 1)
1350 dispatch_labels
.create (num_dispatch
);
1352 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1353 if (lp
&& lp
->post_landing_pad
)
1356 rtx_code_label
*label
;
1360 lp
->landing_pad
= dispatch_label
;
1362 if (num_dispatch
> 1)
1364 tree t_label
, case_elt
, t
;
1366 t_label
= create_artificial_label (UNKNOWN_LOCATION
);
1367 t
= build_int_cst (integer_type_node
, disp_index
);
1368 case_elt
= build_case_label (t
, NULL
, t_label
);
1369 dispatch_labels
.quick_push (case_elt
);
1370 label
= jump_target_rtx (t_label
);
1373 label
= gen_label_rtx ();
1375 if (disp_index
== 0)
1376 first_reachable_label
= label
;
1381 emit_move_insn (r
->exc_ptr_reg
, exc_ptr_reg
);
1383 emit_move_insn (r
->filter_reg
, filter_reg
);
1385 seq2
= get_insns ();
1388 rtx_insn
*before
= label_rtx (lp
->post_landing_pad
);
1389 bb
= emit_to_new_bb_before (seq2
, before
);
1390 make_single_succ_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1393 class loop
*loop
= bb
->next_bb
->loop_father
;
1394 /* If we created a pre-header block, add the new block to the
1395 outer loop, otherwise to the loop itself. */
1396 if (bb
->next_bb
== loop
->header
)
1397 add_bb_to_loop (bb
, loop_outer (loop
));
1399 add_bb_to_loop (bb
, loop
);
1400 /* ??? For multiple dispatches we will end up with edges
1401 from the loop tree root into this loop, making it a
1402 multiple-entry loop. Discard all affected loops. */
1403 if (num_dispatch
> 1)
1405 for (loop
= bb
->loop_father
;
1406 loop_outer (loop
); loop
= loop_outer (loop
))
1407 mark_loop_for_removal (loop
);
1413 gcc_assert (disp_index
== num_dispatch
);
1415 if (num_dispatch
> 1)
1417 rtx disp
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1418 sjlj_fc_call_site_ofs
);
1419 expand_sjlj_dispatch_table (disp
, dispatch_labels
);
1425 bb
= emit_to_new_bb_before (seq
, first_reachable_label
);
1426 if (num_dispatch
== 1)
1428 make_single_succ_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1431 class loop
*loop
= bb
->next_bb
->loop_father
;
1432 /* If we created a pre-header block, add the new block to the
1433 outer loop, otherwise to the loop itself. */
1434 if (bb
->next_bb
== loop
->header
)
1435 add_bb_to_loop (bb
, loop_outer (loop
));
1437 add_bb_to_loop (bb
, loop
);
1442 /* We are not wiring up edges here, but as the dispatcher call
1443 is at function begin simply associate the block with the
1444 outermost (non-)loop. */
1446 add_bb_to_loop (bb
, current_loops
->tree_root
);
1451 sjlj_build_landing_pads (void)
1455 num_dispatch
= vec_safe_length (cfun
->eh
->lp_array
);
1456 if (num_dispatch
== 0)
1458 sjlj_lp_call_site_index
.safe_grow_cleared (num_dispatch
, true);
1460 num_dispatch
= sjlj_assign_call_site_values ();
1461 if (num_dispatch
> 0)
1463 rtx_code_label
*dispatch_label
= gen_label_rtx ();
1464 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1465 TYPE_MODE (sjlj_fc_type_node
),
1466 TYPE_ALIGN (sjlj_fc_type_node
));
1468 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1469 int_size_in_bytes (sjlj_fc_type_node
),
1472 sjlj_mark_call_sites ();
1473 sjlj_emit_function_enter (dispatch_label
);
1474 sjlj_emit_dispatch_table (dispatch_label
, num_dispatch
);
1475 sjlj_emit_function_exit ();
1478 /* If we do not have any landing pads, we may still need to register a
1479 personality routine and (empty) LSDA to handle must-not-throw regions. */
1480 else if (function_needs_eh_personality (cfun
) != eh_personality_none
)
1482 int align
= STACK_SLOT_ALIGNMENT (sjlj_fc_type_node
,
1483 TYPE_MODE (sjlj_fc_type_node
),
1484 TYPE_ALIGN (sjlj_fc_type_node
));
1486 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
1487 int_size_in_bytes (sjlj_fc_type_node
),
1490 sjlj_mark_call_sites ();
1491 sjlj_emit_function_enter (NULL
);
1492 sjlj_emit_function_exit ();
1495 sjlj_lp_call_site_index
.release ();
1498 /* Update the sjlj function context. This function should be called
1499 whenever we allocate or deallocate dynamic stack space. */
1502 update_sjlj_context (void)
1504 if (!flag_exceptions
)
1507 emit_note (NOTE_INSN_UPDATE_SJLJ_CONTEXT
);
1510 /* After initial rtl generation, call back to finish generating
1511 exception support code. */
1514 finish_eh_generation (void)
1518 /* Construct the landing pads. */
1519 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1520 sjlj_build_landing_pads ();
1522 dw2_build_landing_pads ();
1524 break_superblocks ();
1526 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1527 FOR_EACH_BB_FN (bb
, cfun
)
1533 lp
= get_eh_landing_pad_from_rtx (BB_END (bb
));
1535 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1536 if (e
->flags
& EDGE_EH
)
1539 /* We should not have generated any new throwing insns during this
1540 pass, and we should not have lost any EH edges, so we only need
1541 to handle two cases here:
1542 (1) reachable handler and an existing edge to post-landing-pad,
1543 (2) no reachable handler and no edge. */
1544 gcc_assert ((lp
!= NULL
) == (e
!= NULL
));
1547 gcc_assert (BB_HEAD (e
->dest
) == label_rtx (lp
->post_landing_pad
));
1549 redirect_edge_succ (e
, BLOCK_FOR_INSN (lp
->landing_pad
));
1550 e
->flags
|= (CALL_P (BB_END (bb
))
1551 ? EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
1556 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
1557 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1558 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->insns
.r
)
1559 commit_edge_insertions ();
1562 /* This section handles removing dead code for flow. */
1565 remove_eh_landing_pad (eh_landing_pad lp
)
1569 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
1573 if (lp
->post_landing_pad
)
1574 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1575 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1578 /* Splice the EH region at PP from the region tree. */
1581 remove_eh_handler_splicer (eh_region
*pp
)
1583 eh_region region
= *pp
;
1586 for (lp
= region
->landing_pads
; lp
; lp
= lp
->next_lp
)
1588 if (lp
->post_landing_pad
)
1589 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1590 (*cfun
->eh
->lp_array
)[lp
->index
] = NULL
;
1596 outer
= region
->outer
;
1598 *pp
= p
= region
->inner
;
1607 *pp
= region
->next_peer
;
1609 (*cfun
->eh
->region_array
)[region
->index
] = NULL
;
1612 /* Splice a single EH region REGION from the region tree.
1614 To unlink REGION, we need to find the pointer to it with a relatively
1615 expensive search in REGION's outer region. If you are going to
1616 remove a number of handlers, using remove_unreachable_eh_regions may
1617 be a better option. */
1620 remove_eh_handler (eh_region region
)
1622 eh_region
*pp
, *pp_start
, p
, outer
;
1624 outer
= region
->outer
;
1626 pp_start
= &outer
->inner
;
1628 pp_start
= &cfun
->eh
->region_tree
;
1629 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
1632 remove_eh_handler_splicer (pp
);
1635 /* Worker for remove_unreachable_eh_regions.
1636 PP is a pointer to the region to start a region tree depth-first
1637 search from. R_REACHABLE is the set of regions that have to be
1641 remove_unreachable_eh_regions_worker (eh_region
*pp
, sbitmap r_reachable
)
1645 eh_region region
= *pp
;
1646 remove_unreachable_eh_regions_worker (®ion
->inner
, r_reachable
);
1647 if (!bitmap_bit_p (r_reachable
, region
->index
))
1648 remove_eh_handler_splicer (pp
);
1650 pp
= ®ion
->next_peer
;
1654 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1655 Do this by traversing the EH tree top-down and splice out regions that
1656 are not marked. By removing regions from the leaves, we avoid costly
1657 searches in the region tree. */
1660 remove_unreachable_eh_regions (sbitmap r_reachable
)
1662 remove_unreachable_eh_regions_worker (&cfun
->eh
->region_tree
, r_reachable
);
1665 /* Invokes CALLBACK for every exception handler landing pad label.
1666 Only used by reload hackery; should not be used by new code. */
1669 for_each_eh_label (void (*callback
) (rtx
))
1674 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1678 rtx_code_label
*lab
= lp
->landing_pad
;
1679 if (lab
&& LABEL_P (lab
))
1685 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1688 At the gimple level, we use LP_NR
1689 > 0 : The statement transfers to landing pad LP_NR
1690 = 0 : The statement is outside any EH region
1691 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1693 At the rtl level, we use LP_NR
1694 > 0 : The insn transfers to landing pad LP_NR
1695 = 0 : The insn cannot throw
1696 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1697 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1698 missing note: The insn is outside any EH region.
1700 ??? This difference probably ought to be avoided. We could stand
1701 to record nothrow for arbitrary gimple statements, and so avoid
1702 some moderately complex lookups in stmt_could_throw_p. Perhaps
1703 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1704 no-nonlocal-goto property should be recorded elsewhere as a bit
1705 on the call_insn directly. Perhaps we should make more use of
1706 attaching the trees to call_insns (reachable via symbol_ref in
1707 direct call cases) and just pull the data out of the trees. */
1710 make_reg_eh_region_note (rtx_insn
*insn
, int ecf_flags
, int lp_nr
)
1713 if (ecf_flags
& ECF_NOTHROW
)
1715 else if (lp_nr
!= 0)
1716 value
= GEN_INT (lp_nr
);
1719 add_reg_note (insn
, REG_EH_REGION
, value
);
1722 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1723 nor perform a non-local goto. Replace the region note if it
1727 make_reg_eh_region_note_nothrow_nononlocal (rtx_insn
*insn
)
1729 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1730 rtx intmin
= GEN_INT (INT_MIN
);
1733 XEXP (note
, 0) = intmin
;
1735 add_reg_note (insn
, REG_EH_REGION
, intmin
);
1738 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1742 insn_could_throw_p (const_rtx insn
)
1744 if (!flag_exceptions
)
1748 if (INSN_P (insn
) && cfun
->can_throw_non_call_exceptions
)
1749 return may_trap_p (PATTERN (insn
));
1753 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1754 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1755 to look for a note, or the note itself. */
1758 copy_reg_eh_region_note_forward (rtx note_or_insn
, rtx_insn
*first
, rtx last
)
1761 rtx note
= note_or_insn
;
1763 if (INSN_P (note_or_insn
))
1765 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1769 else if (is_a
<rtx_insn
*> (note_or_insn
))
1771 note
= XEXP (note
, 0);
1773 for (insn
= first
; insn
!= last
; insn
= NEXT_INSN (insn
))
1774 if (!find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1775 && insn_could_throw_p (insn
))
1776 add_reg_note (insn
, REG_EH_REGION
, note
);
1779 /* Likewise, but iterate backward. */
1782 copy_reg_eh_region_note_backward (rtx note_or_insn
, rtx_insn
*last
, rtx first
)
1785 rtx note
= note_or_insn
;
1787 if (INSN_P (note_or_insn
))
1789 note
= find_reg_note (note_or_insn
, REG_EH_REGION
, NULL_RTX
);
1793 else if (is_a
<rtx_insn
*> (note_or_insn
))
1795 note
= XEXP (note
, 0);
1797 for (insn
= last
; insn
!= first
; insn
= PREV_INSN (insn
))
1798 if (insn_could_throw_p (insn
))
1799 add_reg_note (insn
, REG_EH_REGION
, note
);
1803 /* Extract all EH information from INSN. Return true if the insn
1804 was marked NOTHROW. */
1807 get_eh_region_and_lp_from_rtx (const_rtx insn
, eh_region
*pr
,
1808 eh_landing_pad
*plp
)
1810 eh_landing_pad lp
= NULL
;
1816 if (! INSN_P (insn
))
1819 if (NONJUMP_INSN_P (insn
)
1820 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1821 insn
= XVECEXP (PATTERN (insn
), 0, 0);
1823 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1826 ret
= !insn_could_throw_p (insn
);
1830 lp_nr
= INTVAL (XEXP (note
, 0));
1831 if (lp_nr
== 0 || lp_nr
== INT_MIN
)
1838 r
= (*cfun
->eh
->region_array
)[-lp_nr
];
1841 lp
= (*cfun
->eh
->lp_array
)[lp_nr
];
1851 /* Return the landing pad to which INSN may go, or NULL if it does not
1852 have a reachable landing pad within this function. */
1855 get_eh_landing_pad_from_rtx (const_rtx insn
)
1860 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1864 /* Return the region to which INSN may go, or NULL if it does not
1865 have a reachable region within this function. */
1868 get_eh_region_from_rtx (const_rtx insn
)
1873 get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1877 /* Return true if INSN throws and is caught by something in this function. */
1880 can_throw_internal (const_rtx insn
)
1882 return get_eh_landing_pad_from_rtx (insn
) != NULL
;
1885 /* Return true if INSN throws and escapes from the current function. */
1888 can_throw_external (const_rtx insn
)
1894 if (! INSN_P (insn
))
1897 if (NONJUMP_INSN_P (insn
)
1898 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1900 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1901 int i
, n
= seq
->len ();
1903 for (i
= 0; i
< n
; i
++)
1904 if (can_throw_external (seq
->element (i
)))
1910 nothrow
= get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1912 /* If we can't throw, we obviously can't throw external. */
1916 /* If we have an internal landing pad, then we're not external. */
1920 /* If we're not within an EH region, then we are external. */
1924 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1925 which don't always have landing pads. */
1926 gcc_assert (r
->type
== ERT_MUST_NOT_THROW
);
1930 /* Return true if INSN cannot throw at all. */
1933 insn_nothrow_p (const_rtx insn
)
1938 if (! INSN_P (insn
))
1941 if (NONJUMP_INSN_P (insn
)
1942 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1944 rtx_sequence
*seq
= as_a
<rtx_sequence
*> (PATTERN (insn
));
1945 int i
, n
= seq
->len ();
1947 for (i
= 0; i
< n
; i
++)
1948 if (!insn_nothrow_p (seq
->element (i
)))
1954 return get_eh_region_and_lp_from_rtx (insn
, &r
, &lp
);
1957 /* Return true if INSN can perform a non-local goto. */
1958 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1961 can_nonlocal_goto (const rtx_insn
*insn
)
1963 if (nonlocal_goto_handler_labels
&& CALL_P (insn
))
1965 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1966 if (!note
|| INTVAL (XEXP (note
, 0)) != INT_MIN
)
1972 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1975 set_nothrow_function_flags (void)
1981 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1982 something that can throw an exception. We specifically exempt
1983 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1984 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1987 crtl
->all_throwers_are_sibcalls
= 1;
1989 /* If we don't know that this implementation of the function will
1990 actually be used, then we must not set TREE_NOTHROW, since
1991 callers must not assume that this function does not throw. */
1992 if (TREE_NOTHROW (current_function_decl
))
1995 if (! flag_exceptions
)
1998 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1999 if (can_throw_external (insn
))
2003 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
2005 crtl
->all_throwers_are_sibcalls
= 0;
2011 && (cgraph_node::get (current_function_decl
)->get_availability ()
2012 >= AVAIL_AVAILABLE
))
2014 struct cgraph_node
*node
= cgraph_node::get (current_function_decl
);
2015 struct cgraph_edge
*e
;
2016 for (e
= node
->callers
; e
; e
= e
->next_caller
)
2017 e
->can_throw_external
= false;
2018 node
->set_nothrow_flag (true);
2021 fprintf (dump_file
, "Marking function nothrow: %s\n\n",
2022 current_function_name ());
2029 const pass_data pass_data_set_nothrow_function_flags
=
2031 RTL_PASS
, /* type */
2032 "nothrow", /* name */
2033 OPTGROUP_NONE
, /* optinfo_flags */
2034 TV_NONE
, /* tv_id */
2035 0, /* properties_required */
2036 0, /* properties_provided */
2037 0, /* properties_destroyed */
2038 0, /* todo_flags_start */
2039 0, /* todo_flags_finish */
2042 class pass_set_nothrow_function_flags
: public rtl_opt_pass
2045 pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2046 : rtl_opt_pass (pass_data_set_nothrow_function_flags
, ctxt
)
2049 /* opt_pass methods: */
2050 unsigned int execute (function
*) final override
2052 return set_nothrow_function_flags ();
2055 }; // class pass_set_nothrow_function_flags
2060 make_pass_set_nothrow_function_flags (gcc::context
*ctxt
)
2062 return new pass_set_nothrow_function_flags (ctxt
);
2066 /* Various hooks for unwind library. */
2068 /* Expand the EH support builtin functions:
2069 __builtin_eh_pointer and __builtin_eh_filter. */
2072 expand_builtin_eh_common (tree region_nr_t
)
2074 HOST_WIDE_INT region_nr
;
2077 gcc_assert (tree_fits_shwi_p (region_nr_t
));
2078 region_nr
= tree_to_shwi (region_nr_t
);
2080 region
= (*cfun
->eh
->region_array
)[region_nr
];
2082 /* ??? We shouldn't have been able to delete a eh region without
2083 deleting all the code that depended on it. */
2084 gcc_assert (region
!= NULL
);
2089 /* Expand to the exc_ptr value from the given eh region. */
2092 expand_builtin_eh_pointer (tree exp
)
2095 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2096 if (region
->exc_ptr_reg
== NULL
)
2097 region
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2098 return region
->exc_ptr_reg
;
2101 /* Expand to the filter value from the given eh region. */
2104 expand_builtin_eh_filter (tree exp
)
2107 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2108 if (region
->filter_reg
== NULL
)
2109 region
->filter_reg
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
2110 return region
->filter_reg
;
2113 /* Copy the exc_ptr and filter values from one landing pad's registers
2114 to another. This is used to inline the resx statement. */
2117 expand_builtin_eh_copy_values (tree exp
)
2120 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 0));
2122 = expand_builtin_eh_common (CALL_EXPR_ARG (exp
, 1));
2123 scalar_int_mode fmode
= targetm
.eh_return_filter_mode ();
2125 if (dst
->exc_ptr_reg
== NULL
)
2126 dst
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2127 if (src
->exc_ptr_reg
== NULL
)
2128 src
->exc_ptr_reg
= gen_reg_rtx (ptr_mode
);
2130 if (dst
->filter_reg
== NULL
)
2131 dst
->filter_reg
= gen_reg_rtx (fmode
);
2132 if (src
->filter_reg
== NULL
)
2133 src
->filter_reg
= gen_reg_rtx (fmode
);
2135 emit_move_insn (dst
->exc_ptr_reg
, src
->exc_ptr_reg
);
2136 emit_move_insn (dst
->filter_reg
, src
->filter_reg
);
2141 /* Do any necessary initialization to access arbitrary stack frames.
2142 On the SPARC, this means flushing the register windows. */
2145 expand_builtin_unwind_init (void)
2147 /* Set this so all the registers get saved in our frame; we need to be
2148 able to copy the saved values for any registers from frames we unwind. */
2149 crtl
->saves_all_registers
= 1;
2151 SETUP_FRAME_ADDRESSES ();
2154 /* Map a non-negative number to an eh return data register number; expands
2155 to -1 if no return data register is associated with the input number.
2156 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2159 expand_builtin_eh_return_data_regno (tree exp
)
2161 tree which
= CALL_EXPR_ARG (exp
, 0);
2162 unsigned HOST_WIDE_INT iwhich
;
2164 if (TREE_CODE (which
) != INTEGER_CST
)
2166 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2170 if (!tree_fits_uhwi_p (which
))
2173 iwhich
= tree_to_uhwi (which
);
2174 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2175 if (iwhich
== INVALID_REGNUM
)
2178 #ifdef DWARF_FRAME_REGNUM
2179 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2181 iwhich
= DEBUGGER_REGNO (iwhich
);
2184 return GEN_INT (iwhich
);
2187 /* Given a value extracted from the return address register or stack slot,
2188 return the actual address encoded in that value. */
2191 expand_builtin_extract_return_addr (tree addr_tree
)
2193 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2195 if (GET_MODE (addr
) != Pmode
2196 && GET_MODE (addr
) != VOIDmode
)
2198 #ifdef POINTERS_EXTEND_UNSIGNED
2199 addr
= convert_memory_address (Pmode
, addr
);
2201 addr
= convert_to_mode (Pmode
, addr
, 0);
2205 /* First mask out any unwanted bits. */
2206 rtx mask
= MASK_RETURN_ADDR
;
2208 expand_and (Pmode
, addr
, mask
, addr
);
2210 /* Then adjust to find the real return address. */
2211 if (RETURN_ADDR_OFFSET
)
2212 addr
= plus_constant (Pmode
, addr
, RETURN_ADDR_OFFSET
);
2217 /* Given an actual address in addr_tree, do any necessary encoding
2218 and return the value to be stored in the return address register or
2219 stack slot so the epilogue will return to that address. */
2222 expand_builtin_frob_return_addr (tree addr_tree
)
2224 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2226 addr
= convert_memory_address (Pmode
, addr
);
2228 if (RETURN_ADDR_OFFSET
)
2230 addr
= force_reg (Pmode
, addr
);
2231 addr
= plus_constant (Pmode
, addr
, -RETURN_ADDR_OFFSET
);
2237 /* Set up the epilogue with the magic bits we'll need to return to the
2238 exception handler. */
2241 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2246 #ifdef EH_RETURN_STACKADJ_RTX
2247 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2248 VOIDmode
, EXPAND_NORMAL
);
2249 tmp
= convert_memory_address (Pmode
, tmp
);
2250 if (!crtl
->eh
.ehr_stackadj
)
2251 crtl
->eh
.ehr_stackadj
= copy_addr_to_reg (tmp
);
2252 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2253 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2256 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2257 VOIDmode
, EXPAND_NORMAL
);
2258 tmp
= convert_memory_address (Pmode
, tmp
);
2259 if (!crtl
->eh
.ehr_handler
)
2260 crtl
->eh
.ehr_handler
= copy_addr_to_reg (tmp
);
2261 else if (tmp
!= crtl
->eh
.ehr_handler
)
2262 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2264 if (!crtl
->eh
.ehr_label
)
2265 crtl
->eh
.ehr_label
= gen_label_rtx ();
2266 emit_jump (crtl
->eh
.ehr_label
);
2269 /* Expand __builtin_eh_return. This exit path from the function loads up
2270 the eh return data registers, adjusts the stack, and branches to a
2271 given PC other than the normal return address. */
2274 expand_eh_return (void)
2276 rtx_code_label
*around_label
;
2278 if (! crtl
->eh
.ehr_label
)
2281 crtl
->calls_eh_return
= 1;
2283 #ifdef EH_RETURN_STACKADJ_RTX
2284 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2287 #ifdef EH_RETURN_TAKEN_RTX
2288 emit_move_insn (EH_RETURN_TAKEN_RTX
, const0_rtx
);
2291 around_label
= gen_label_rtx ();
2292 emit_jump (around_label
);
2294 emit_label (crtl
->eh
.ehr_label
);
2295 clobber_return_register ();
2297 #ifdef EH_RETURN_STACKADJ_RTX
2298 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2301 #ifdef EH_RETURN_TAKEN_RTX
2302 emit_move_insn (EH_RETURN_TAKEN_RTX
, const1_rtx
);
2305 if (targetm
.have_eh_return ())
2306 emit_insn (targetm
.gen_eh_return (crtl
->eh
.ehr_handler
));
2309 if (rtx handler
= EH_RETURN_HANDLER_RTX
)
2310 emit_move_insn (handler
, crtl
->eh
.ehr_handler
);
2312 error ("%<__builtin_eh_return%> not supported on this target");
2315 #ifdef EH_RETURN_TAKEN_RTX
2316 rtx_code_label
*eh_done_label
= gen_label_rtx ();
2317 emit_jump (eh_done_label
);
2320 emit_label (around_label
);
2322 #ifdef EH_RETURN_TAKEN_RTX
2323 for (rtx tmp
: { EH_RETURN_STACKADJ_RTX
, EH_RETURN_HANDLER_RTX
})
2324 if (tmp
&& REG_P (tmp
))
2326 emit_label (eh_done_label
);
2330 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2331 POINTERS_EXTEND_UNSIGNED and return it. */
2334 expand_builtin_extend_pointer (tree addr_tree
)
2336 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2339 #ifdef POINTERS_EXTEND_UNSIGNED
2340 extend
= POINTERS_EXTEND_UNSIGNED
;
2342 /* The previous EH code did an unsigned extend by default, so we do this also
2347 return convert_modes (targetm
.unwind_word_mode (), ptr_mode
, addr
, extend
);
2351 add_action_record (action_hash_type
*ar_hash
, int filter
, int next
)
2353 struct action_record
**slot
, *new_ar
, tmp
;
2355 tmp
.filter
= filter
;
2357 slot
= ar_hash
->find_slot (&tmp
, INSERT
);
2359 if ((new_ar
= *slot
) == NULL
)
2361 new_ar
= XNEW (struct action_record
);
2362 new_ar
->offset
= crtl
->eh
.action_record_data
->length () + 1;
2363 new_ar
->filter
= filter
;
2364 new_ar
->next
= next
;
2367 /* The filter value goes in untouched. The link to the next
2368 record is a "self-relative" byte offset, or zero to indicate
2369 that there is no next record. So convert the absolute 1 based
2370 indices we've been carrying around into a displacement. */
2372 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
2374 next
-= crtl
->eh
.action_record_data
->length () + 1;
2375 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
2378 return new_ar
->offset
;
2382 collect_one_action_chain (action_hash_type
*ar_hash
, eh_region region
)
2386 /* If we've reached the top of the region chain, then we have
2387 no actions, and require no landing pad. */
2391 switch (region
->type
)
2396 /* A cleanup adds a zero filter to the beginning of the chain, but
2397 there are special cases to look out for. If there are *only*
2398 cleanups along a path, then it compresses to a zero action.
2399 Further, if there are multiple cleanups along a path, we only
2400 need to represent one of them, as that is enough to trigger
2401 entry to the landing pad at runtime. */
2402 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2405 for (r
= region
->outer
; r
; r
= r
->outer
)
2406 if (r
->type
== ERT_CLEANUP
)
2408 return add_action_record (ar_hash
, 0, next
);
2415 /* Process the associated catch regions in reverse order.
2416 If there's a catch-all handler, then we don't need to
2417 search outer regions. Use a magic -3 value to record
2418 that we haven't done the outer search. */
2420 for (c
= region
->u
.eh_try
.last_catch
; c
; c
= c
->prev_catch
)
2422 if (c
->type_list
== NULL
)
2424 /* Retrieve the filter from the head of the filter list
2425 where we have stored it (see assign_filter_values). */
2426 int filter
= TREE_INT_CST_LOW (TREE_VALUE (c
->filter_list
));
2427 next
= add_action_record (ar_hash
, filter
, 0);
2431 /* Once the outer search is done, trigger an action record for
2432 each filter we have. */
2437 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2439 /* If there is no next action, terminate the chain. */
2442 /* If all outer actions are cleanups or must_not_throw,
2443 we'll have no action record for it, since we had wanted
2444 to encode these states in the call-site record directly.
2445 Add a cleanup action to the chain to catch these. */
2447 next
= add_action_record (ar_hash
, 0, 0);
2450 flt_node
= c
->filter_list
;
2451 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
2453 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
2454 next
= add_action_record (ar_hash
, filter
, next
);
2461 case ERT_ALLOWED_EXCEPTIONS
:
2462 /* An exception specification adds its filter to the
2463 beginning of the chain. */
2464 next
= collect_one_action_chain (ar_hash
, region
->outer
);
2466 /* If there is no next action, terminate the chain. */
2469 /* If all outer actions are cleanups or must_not_throw,
2470 we'll have no action record for it, since we had wanted
2471 to encode these states in the call-site record directly.
2472 Add a cleanup action to the chain to catch these. */
2474 next
= add_action_record (ar_hash
, 0, 0);
2476 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
2478 case ERT_MUST_NOT_THROW
:
2479 /* A must-not-throw region with no inner handlers or cleanups
2480 requires no call-site entry. Note that this differs from
2481 the no handler or cleanup case in that we do require an lsda
2482 to be generated. Return a magic -2 value to record this. */
2490 add_call_site (rtx landing_pad
, int action
, int section
)
2492 call_site_record record
;
2494 record
= ggc_alloc
<call_site_record_d
> ();
2495 record
->landing_pad
= landing_pad
;
2496 record
->action
= action
;
2498 vec_safe_push (crtl
->eh
.call_site_record_v
[section
], record
);
2500 return call_site_base
+ crtl
->eh
.call_site_record_v
[section
]->length () - 1;
2504 emit_note_eh_region_end (rtx_insn
*insn
)
2506 return emit_note_after (NOTE_INSN_EH_REGION_END
, insn
);
2509 /* Add NOP after NOTE_INSN_SWITCH_TEXT_SECTIONS when the cold section starts
2511 With landing pad being at offset 0 from the start label of the section
2512 we would miss EH delivery because 0 is special and means no landing pad. */
2515 maybe_add_nop_after_section_switch (void)
2517 if (!crtl
->uses_eh_lsda
2518 || !crtl
->eh
.call_site_record_v
[1])
2520 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[1]);
2521 hash_set
<rtx_insn
*> visited
;
2523 for (int i
= 0; i
< n
; ++i
)
2525 struct call_site_record_d
*cs
2526 = (*crtl
->eh
.call_site_record_v
[1])[i
];
2527 if (cs
->landing_pad
)
2529 rtx_insn
*insn
= as_a
<rtx_insn
*> (cs
->landing_pad
);
2532 /* Landing pads have LABEL_PRESERVE_P flag set. This check make
2533 sure that we do not walk past landing pad visited earlier
2534 which would result in possible quadratic behaviour. */
2535 if (LABEL_P (insn
) && LABEL_PRESERVE_P (insn
)
2536 && visited
.add (insn
))
2539 /* Conservatively assume that ASM insn may be empty. We have
2540 now way to tell what they contain. */
2541 if (active_insn_p (insn
)
2542 && GET_CODE (PATTERN (insn
)) != ASM_INPUT
2543 && GET_CODE (PATTERN (insn
)) != ASM_OPERANDS
)
2546 /* If we reached the start of hot section, then NOP will be
2548 if (GET_CODE (insn
) == NOTE
2549 && NOTE_KIND (insn
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2551 emit_insn_after (gen_nop (), insn
);
2555 /* We visit only labels from cold section. We should never hit
2556 begining of the insn stream here. */
2557 insn
= PREV_INSN (insn
);
2564 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2565 The new note numbers will not refer to region numbers, but
2566 instead to call site entries. */
2569 convert_to_eh_region_ranges (void)
2574 action_hash_type
ar_hash (31);
2575 int last_action
= -3;
2576 rtx_insn
*last_action_insn
= NULL
;
2577 rtx last_landing_pad
= NULL_RTX
;
2578 rtx_insn
*first_no_action_insn
= NULL
;
2581 rtx_insn
*section_switch_note
= NULL
;
2582 rtx_insn
*first_no_action_insn_before_switch
= NULL
;
2583 rtx_insn
*last_no_action_insn_before_switch
= NULL
;
2584 int saved_call_site_base
= call_site_base
;
2586 vec_alloc (crtl
->eh
.action_record_data
, 64);
2588 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
2595 rtx_code_label
*this_landing_pad
;
2598 if (NONJUMP_INSN_P (insn
)
2599 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2600 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2602 nothrow
= get_eh_region_and_lp_from_rtx (insn
, ®ion
, &lp
);
2606 this_action
= collect_one_action_chain (&ar_hash
, region
);
2610 /* Existence of catch handlers, or must-not-throw regions
2611 implies that an lsda is needed (even if empty). */
2612 if (this_action
!= -1)
2613 crtl
->uses_eh_lsda
= 1;
2615 /* Delay creation of region notes for no-action regions
2616 until we're sure that an lsda will be required. */
2617 else if (last_action
== -3)
2619 first_no_action_insn
= iter
;
2623 if (this_action
>= 0)
2624 this_landing_pad
= lp
->landing_pad
;
2626 this_landing_pad
= NULL
;
2628 /* Differing actions or landing pads implies a change in call-site
2629 info, which implies some EH_REGION note should be emitted. */
2630 if (last_action
!= this_action
2631 || last_landing_pad
!= this_landing_pad
)
2633 /* If there is a queued no-action region in the other section
2634 with hot/cold partitioning, emit it now. */
2635 if (first_no_action_insn_before_switch
)
2637 gcc_assert (this_action
!= -1
2638 && last_action
== (first_no_action_insn
2640 call_site
= add_call_site (NULL_RTX
, 0, 0);
2641 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2642 first_no_action_insn_before_switch
);
2643 NOTE_EH_HANDLER (note
) = call_site
;
2645 = emit_note_eh_region_end (last_no_action_insn_before_switch
);
2646 NOTE_EH_HANDLER (note
) = call_site
;
2647 gcc_assert (last_action
!= -3
2648 || (last_action_insn
2649 == last_no_action_insn_before_switch
));
2650 first_no_action_insn_before_switch
= NULL
;
2651 last_no_action_insn_before_switch
= NULL
;
2654 /* If we'd not seen a previous action (-3) or the previous
2655 action was must-not-throw (-2), then we do not need an
2657 if (last_action
>= -1)
2659 /* If we delayed the creation of the begin, do it now. */
2660 if (first_no_action_insn
)
2662 call_site
= add_call_site (NULL_RTX
, 0, cur_sec
);
2663 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
2664 first_no_action_insn
);
2665 NOTE_EH_HANDLER (note
) = call_site
;
2666 first_no_action_insn
= NULL
;
2669 note
= emit_note_eh_region_end (last_action_insn
);
2670 NOTE_EH_HANDLER (note
) = call_site
;
2673 /* If the new action is must-not-throw, then no region notes
2675 if (this_action
>= -1)
2677 call_site
= add_call_site (this_landing_pad
,
2678 this_action
< 0 ? 0 : this_action
,
2680 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
2681 NOTE_EH_HANDLER (note
) = call_site
;
2684 last_action
= this_action
;
2685 last_landing_pad
= this_landing_pad
;
2687 last_action_insn
= iter
;
2689 else if (NOTE_P (iter
)
2690 && NOTE_KIND (iter
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
2692 gcc_assert (section_switch_note
== NULL_RTX
);
2693 gcc_assert (flag_reorder_blocks_and_partition
);
2694 section_switch_note
= iter
;
2695 if (first_no_action_insn
)
2697 first_no_action_insn_before_switch
= first_no_action_insn
;
2698 last_no_action_insn_before_switch
= last_action_insn
;
2699 first_no_action_insn
= NULL
;
2700 gcc_assert (last_action
== -1);
2703 /* Force closing of current EH region before section switch and
2704 opening a new one afterwards. */
2705 else if (last_action
!= -3)
2706 last_landing_pad
= pc_rtx
;
2707 if (crtl
->eh
.call_site_record_v
[cur_sec
])
2708 call_site_base
+= crtl
->eh
.call_site_record_v
[cur_sec
]->length ();
2710 gcc_assert (crtl
->eh
.call_site_record_v
[cur_sec
] == NULL
);
2711 vec_alloc (crtl
->eh
.call_site_record_v
[cur_sec
], 10);
2714 if (last_action
>= -1 && ! first_no_action_insn
)
2716 note
= emit_note_eh_region_end (last_action_insn
);
2717 NOTE_EH_HANDLER (note
) = call_site
;
2720 call_site_base
= saved_call_site_base
;
2727 const pass_data pass_data_convert_to_eh_region_ranges
=
2729 RTL_PASS
, /* type */
2730 "eh_ranges", /* name */
2731 OPTGROUP_NONE
, /* optinfo_flags */
2732 TV_NONE
, /* tv_id */
2733 0, /* properties_required */
2734 0, /* properties_provided */
2735 0, /* properties_destroyed */
2736 0, /* todo_flags_start */
2737 0, /* todo_flags_finish */
2740 class pass_convert_to_eh_region_ranges
: public rtl_opt_pass
2743 pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2744 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges
, ctxt
)
2747 /* opt_pass methods: */
2748 bool gate (function
*) final override
;
2749 unsigned int execute (function
*) final override
2751 int ret
= convert_to_eh_region_ranges ();
2752 maybe_add_nop_after_section_switch ();
2756 }; // class pass_convert_to_eh_region_ranges
2759 pass_convert_to_eh_region_ranges::gate (function
*)
2761 /* Nothing to do for SJLJ exceptions or if no regions created. */
2762 if (cfun
->eh
->region_tree
== NULL
)
2764 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
2772 make_pass_convert_to_eh_region_ranges (gcc::context
*ctxt
)
2774 return new pass_convert_to_eh_region_ranges (ctxt
);
2778 push_uleb128 (vec
<uchar
, va_gc
> **data_area
, unsigned int value
)
2782 unsigned char byte
= value
& 0x7f;
2786 vec_safe_push (*data_area
, byte
);
2792 push_sleb128 (vec
<uchar
, va_gc
> **data_area
, int value
)
2799 byte
= value
& 0x7f;
2801 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
2802 || (value
== -1 && (byte
& 0x40) != 0));
2805 vec_safe_push (*data_area
, byte
);
2812 dw2_size_of_call_site_table (int section
)
2814 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2815 int size
= n
* (4 + 4 + 4);
2818 for (i
= 0; i
< n
; ++i
)
2820 struct call_site_record_d
*cs
=
2821 (*crtl
->eh
.call_site_record_v
[section
])[i
];
2822 size
+= size_of_uleb128 (cs
->action
);
2829 sjlj_size_of_call_site_table (void)
2831 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2835 for (i
= 0; i
< n
; ++i
)
2837 struct call_site_record_d
*cs
=
2838 (*crtl
->eh
.call_site_record_v
[0])[i
];
2839 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
2840 size
+= size_of_uleb128 (cs
->action
);
2847 dw2_output_call_site_table (int cs_format
, int section
)
2849 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[section
]);
2854 begin
= current_function_func_begin_label
;
2855 else if (first_function_block_is_cold
)
2856 begin
= crtl
->subsections
.hot_section_label
;
2858 begin
= crtl
->subsections
.cold_section_label
;
2860 for (i
= 0; i
< n
; ++i
)
2862 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[section
])[i
];
2863 char reg_start_lab
[32];
2864 char reg_end_lab
[32];
2865 char landing_pad_lab
[32];
2867 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
2868 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
2870 if (cs
->landing_pad
)
2871 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
2872 CODE_LABEL_NUMBER (cs
->landing_pad
));
2874 /* ??? Perhaps use insn length scaling if the assembler supports
2875 generic arithmetic. */
2876 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2877 data4 if the function is small enough. */
2878 if (cs_format
== DW_EH_PE_uleb128
)
2880 dw2_asm_output_delta_uleb128 (reg_start_lab
, begin
,
2881 "region %d start", i
);
2882 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
2884 if (cs
->landing_pad
)
2885 dw2_asm_output_delta_uleb128 (landing_pad_lab
, begin
,
2888 dw2_asm_output_data_uleb128 (0, "landing pad");
2892 dw2_asm_output_delta (4, reg_start_lab
, begin
,
2893 "region %d start", i
);
2894 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
2895 if (cs
->landing_pad
)
2896 dw2_asm_output_delta (4, landing_pad_lab
, begin
,
2899 dw2_asm_output_data (4, 0, "landing pad");
2901 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2904 call_site_base
+= n
;
2908 sjlj_output_call_site_table (void)
2910 int n
= vec_safe_length (crtl
->eh
.call_site_record_v
[0]);
2913 for (i
= 0; i
< n
; ++i
)
2915 struct call_site_record_d
*cs
= (*crtl
->eh
.call_site_record_v
[0])[i
];
2917 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
2918 "region %d landing pad", i
);
2919 dw2_asm_output_data_uleb128 (cs
->action
, "action");
2922 call_site_base
+= n
;
2925 /* Switch to the section that should be used for exception tables. */
2928 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
2932 if (exception_section
)
2933 s
= exception_section
;
2938 if (EH_TABLES_CAN_BE_READ_ONLY
)
2941 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2942 flags
= ((! flag_pic
2943 || ((tt_format
& 0x70) != DW_EH_PE_absptr
2944 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
2945 ? 0 : SECTION_WRITE
);
2948 flags
= SECTION_WRITE
;
2950 /* Compute the section and cache it into exception_section,
2951 unless it depends on the function name. */
2952 if (targetm_common
.have_named_sections
)
2954 #ifdef HAVE_LD_EH_GC_SECTIONS
2955 if (flag_function_sections
2956 || (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
))
2958 char *section_name
= XNEWVEC (char, strlen (fnname
) + 32);
2959 /* The EH table must match the code section, so only mark
2960 it linkonce if we have COMDAT groups to tie them together. */
2961 if (DECL_COMDAT_GROUP (current_function_decl
) && HAVE_COMDAT_GROUP
)
2962 flags
|= SECTION_LINKONCE
;
2963 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
2964 s
= get_section (section_name
, flags
, current_function_decl
);
2965 free (section_name
);
2970 = s
= get_section (".gcc_except_table", flags
, NULL
);
2974 = s
= flags
== SECTION_WRITE
? data_section
: readonly_data_section
;
2977 switch_to_section (s
);
2980 /* Output a reference from an exception table to the type_info object TYPE.
2981 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2985 output_ttype (tree type
, int tt_format
, int tt_format_size
)
2988 bool is_public
= true;
2990 if (type
== NULL_TREE
)
2994 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2995 runtime types so TYPE should already be a runtime type
2996 reference. When pass_ipa_free_lang data is made a default
2997 pass, we can then remove the call to lookup_type_for_runtime
3000 type
= lookup_type_for_runtime (type
);
3002 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
3004 /* Let cgraph know that the rtti decl is used. Not all of the
3005 paths below go through assemble_integer, which would take
3006 care of this for us. */
3008 if (TREE_CODE (type
) == ADDR_EXPR
)
3010 type
= TREE_OPERAND (type
, 0);
3012 is_public
= TREE_PUBLIC (type
);
3015 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
3018 /* Allow the target to override the type table entry format. */
3019 if (targetm
.asm_out
.ttype (value
))
3022 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
3023 assemble_integer (value
, tt_format_size
,
3024 tt_format_size
* BITS_PER_UNIT
, 1);
3026 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, is_public
, NULL
);
3029 /* Output an exception table for the current function according to SECTION.
3031 If the function has been partitioned into hot and cold parts, value 0 for
3032 SECTION refers to the table associated with the hot part while value 1
3033 refers to the table associated with the cold part. If the function has
3034 not been partitioned, value 0 refers to the single exception table. */
3037 output_one_function_exception_table (int section
)
3039 int tt_format
, cs_format
, lp_format
, i
;
3040 char ttype_label
[32];
3041 char cs_after_size_label
[32];
3042 char cs_end_label
[32];
3045 int tt_format_size
= 0;
3047 have_tt_data
= (vec_safe_length (cfun
->eh
->ttype_data
)
3048 || (targetm
.arm_eabi_unwinder
3049 ? vec_safe_length (cfun
->eh
->ehspec_data
.arm_eabi
)
3050 : vec_safe_length (cfun
->eh
->ehspec_data
.other
)));
3052 /* Indicate the format of the @TType entries. */
3054 tt_format
= DW_EH_PE_omit
;
3057 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
3059 ASM_GENERATE_INTERNAL_LABEL (ttype_label
,
3060 section
? "LLSDATTC" : "LLSDATT",
3061 current_function_funcdef_no
);
3063 tt_format_size
= size_of_encoded_value (tt_format
);
3065 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3068 targetm
.asm_out
.internal_label (asm_out_file
, section
? "LLSDAC" : "LLSDA",
3069 current_function_funcdef_no
);
3071 /* The LSDA header. */
3073 /* Indicate the format of the landing pad start pointer. An omitted
3074 field implies @LPStart == @Start. */
3075 /* Currently we always put @LPStart == @Start. This field would
3076 be most useful in moving the landing pads completely out of
3077 line to another section, but it could also be used to minimize
3078 the size of uleb128 landing pad offsets. */
3079 lp_format
= DW_EH_PE_omit
;
3080 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
3081 eh_data_format_name (lp_format
));
3083 /* @LPStart pointer would go here. */
3085 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
3086 eh_data_format_name (tt_format
));
3088 if (!HAVE_AS_LEB128
)
3090 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3091 call_site_len
= sjlj_size_of_call_site_table ();
3093 call_site_len
= dw2_size_of_call_site_table (section
);
3096 /* A pc-relative 4-byte displacement to the @TType data. */
3101 char ttype_after_disp_label
[32];
3102 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
,
3103 section
? "LLSDATTDC" : "LLSDATTD",
3104 current_function_funcdef_no
);
3105 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3106 "@TType base offset");
3107 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3111 /* Ug. Alignment queers things. */
3112 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3114 before_disp
= 1 + 1;
3115 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3117 + vec_safe_length (crtl
->eh
.action_record_data
)
3118 + (vec_safe_length (cfun
->eh
->ttype_data
)
3124 unsigned int disp_size
, pad
;
3127 disp_size
= size_of_uleb128 (disp
);
3128 pad
= before_disp
+ disp_size
+ after_disp
;
3129 if (pad
% tt_format_size
)
3130 pad
= tt_format_size
- (pad
% tt_format_size
);
3133 disp
= after_disp
+ pad
;
3135 while (disp
!= last_disp
);
3137 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3141 /* Indicate the format of the call-site offsets. */
3143 cs_format
= DW_EH_PE_uleb128
;
3145 cs_format
= DW_EH_PE_udata4
;
3147 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3148 eh_data_format_name (cs_format
));
3152 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
,
3153 section
? "LLSDACSBC" : "LLSDACSB",
3154 current_function_funcdef_no
);
3155 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
,
3156 section
? "LLSDACSEC" : "LLSDACSE",
3157 current_function_funcdef_no
);
3158 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3159 "Call-site table length");
3160 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3161 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3162 sjlj_output_call_site_table ();
3164 dw2_output_call_site_table (cs_format
, section
);
3165 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3169 dw2_asm_output_data_uleb128 (call_site_len
, "Call-site table length");
3170 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
3171 sjlj_output_call_site_table ();
3173 dw2_output_call_site_table (cs_format
, section
);
3176 /* ??? Decode and interpret the data for flag_debug_asm. */
3179 FOR_EACH_VEC_ELT (*crtl
->eh
.action_record_data
, i
, uc
)
3180 dw2_asm_output_data (1, uc
, i
? NULL
: "Action record table");
3184 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3186 i
= vec_safe_length (cfun
->eh
->ttype_data
);
3189 tree type
= (*cfun
->eh
->ttype_data
)[i
];
3190 output_ttype (type
, tt_format
, tt_format_size
);
3193 if (HAVE_AS_LEB128
&& have_tt_data
)
3194 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3196 /* ??? Decode and interpret the data for flag_debug_asm. */
3197 if (targetm
.arm_eabi_unwinder
)
3201 vec_safe_iterate (cfun
->eh
->ehspec_data
.arm_eabi
, i
, &type
); ++i
)
3202 output_ttype (type
, tt_format
, tt_format_size
);
3208 vec_safe_iterate (cfun
->eh
->ehspec_data
.other
, i
, &uc
); ++i
)
3209 dw2_asm_output_data (1, uc
,
3210 i
? NULL
: "Exception specification table");
3214 /* Output an exception table for the current function according to SECTION,
3215 switching back and forth from the function section appropriately.
3217 If the function has been partitioned into hot and cold parts, value 0 for
3218 SECTION refers to the table associated with the hot part while value 1
3219 refers to the table associated with the cold part. If the function has
3220 not been partitioned, value 0 refers to the single exception table. */
3223 output_function_exception_table (int section
)
3225 const char *fnname
= get_fnname_from_decl (current_function_decl
);
3226 rtx personality
= get_personality_function (current_function_decl
);
3228 /* Not all functions need anything. */
3229 if (!crtl
->uses_eh_lsda
3230 || targetm_common
.except_unwind_info (&global_options
) == UI_NONE
)
3233 /* No need to emit any boilerplate stuff for the cold part. */
3234 if (section
== 1 && !crtl
->eh
.call_site_record_v
[1])
3239 assemble_external_libcall (personality
);
3241 if (targetm
.asm_out
.emit_except_personality
)
3242 targetm
.asm_out
.emit_except_personality (personality
);
3245 switch_to_exception_section (fnname
);
3247 /* If the target wants a label to begin the table, emit it here. */
3248 targetm
.asm_out
.emit_except_table_label (asm_out_file
);
3250 /* Do the real work. */
3251 output_one_function_exception_table (section
);
3253 switch_to_section (current_function_section ());
3257 set_eh_throw_stmt_table (function
*fun
, hash_map
<gimple
*, int> *table
)
3259 fun
->eh
->throw_stmt_table
= table
;
3262 hash_map
<gimple
*, int> *
3263 get_eh_throw_stmt_table (struct function
*fun
)
3265 return fun
->eh
->throw_stmt_table
;
3268 /* Determine if the function needs an EH personality function. */
3270 enum eh_personality_kind
3271 function_needs_eh_personality (struct function
*fn
)
3273 enum eh_personality_kind kind
= eh_personality_none
;
3276 FOR_ALL_EH_REGION_FN (i
, fn
)
3281 /* Can do with any personality including the generic C one. */
3282 kind
= eh_personality_any
;
3286 case ERT_ALLOWED_EXCEPTIONS
:
3287 /* Always needs a EH personality function. The generic C
3288 personality doesn't handle these even for empty type lists. */
3289 return eh_personality_lang
;
3291 case ERT_MUST_NOT_THROW
:
3292 /* Always needs a EH personality function. The language may specify
3293 what abort routine that must be used, e.g. std::terminate. */
3294 return eh_personality_lang
;
3301 /* Dump EH information to OUT. */
3304 dump_eh_tree (FILE * out
, struct function
*fun
)
3308 static const char *const type_name
[] = {
3309 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3312 i
= fun
->eh
->region_tree
;
3316 fprintf (out
, "Eh tree:\n");
3319 fprintf (out
, " %*s %i %s", depth
* 2, "",
3320 i
->index
, type_name
[(int) i
->type
]);
3322 if (i
->landing_pads
)
3326 fprintf (out
, " land:");
3327 if (current_ir_type () == IR_GIMPLE
)
3329 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3331 fprintf (out
, "{%i,", lp
->index
);
3332 print_generic_expr (out
, lp
->post_landing_pad
);
3340 for (lp
= i
->landing_pads
; lp
; lp
= lp
->next_lp
)
3342 fprintf (out
, "{%i,", lp
->index
);
3343 if (lp
->landing_pad
)
3344 fprintf (out
, "%i%s,", INSN_UID (lp
->landing_pad
),
3345 NOTE_P (lp
->landing_pad
) ? "(del)" : "");
3347 fprintf (out
, "(nil),");
3348 if (lp
->post_landing_pad
)
3350 rtx_insn
*lab
= label_rtx (lp
->post_landing_pad
);
3351 fprintf (out
, "%i%s}", INSN_UID (lab
),
3352 NOTE_P (lab
) ? "(del)" : "");
3355 fprintf (out
, "(nil)}");
3365 case ERT_MUST_NOT_THROW
:
3371 fprintf (out
, " catch:");
3372 for (c
= i
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3377 fprintf (out
, "lab:");
3378 print_generic_expr (out
, c
->label
);
3381 print_generic_expr (out
, c
->type_list
);
3389 case ERT_ALLOWED_EXCEPTIONS
:
3390 fprintf (out
, " filter :%i types:", i
->u
.allowed
.filter
);
3391 print_generic_expr (out
, i
->u
.allowed
.type_list
);
3396 /* If there are sub-regions, process them. */
3398 i
= i
->inner
, depth
++;
3399 /* If there are peers, process them. */
3400 else if (i
->next_peer
)
3402 /* Otherwise, step back up the tree to the next peer. */
3412 while (i
->next_peer
== NULL
);
3418 /* Dump the EH tree for FN on stderr. */
3421 debug_eh_tree (struct function
*fn
)
3423 dump_eh_tree (stderr
, fn
);
3426 /* Verify invariants on EH datastructures. */
3429 verify_eh_tree (struct function
*fun
)
3432 int nvisited_lp
, nvisited_r
;
3433 int count_lp
, count_r
, depth
, i
;
3437 if (!fun
->eh
->region_tree
)
3441 for (i
= 1; vec_safe_iterate (fun
->eh
->region_array
, i
, &r
); ++i
)
3448 error ("%<region_array%> is corrupted for region %i", r
->index
);
3454 for (i
= 1; vec_safe_iterate (fun
->eh
->lp_array
, i
, &lp
); ++i
)
3461 error ("%<lp_array%> is corrupted for lp %i", lp
->index
);
3466 depth
= nvisited_lp
= nvisited_r
= 0;
3468 r
= fun
->eh
->region_tree
;
3471 if ((*fun
->eh
->region_array
)[r
->index
] != r
)
3473 error ("%<region_array%> is corrupted for region %i", r
->index
);
3476 if (r
->outer
!= outer
)
3478 error ("outer block of region %i is wrong", r
->index
);
3483 error ("negative nesting depth of region %i", r
->index
);
3488 for (lp
= r
->landing_pads
; lp
; lp
= lp
->next_lp
)
3490 if ((*fun
->eh
->lp_array
)[lp
->index
] != lp
)
3492 error ("%<lp_array%> is corrupted for lp %i", lp
->index
);
3495 if (lp
->region
!= r
)
3497 error ("region of lp %i is wrong", lp
->index
);
3504 outer
= r
, r
= r
->inner
, depth
++;
3505 else if (r
->next_peer
)
3517 while (r
->next_peer
== NULL
);
3524 error ("tree list ends on depth %i", depth
);
3527 if (count_r
!= nvisited_r
)
3529 error ("%<region_array%> does not match %<region_tree%>");
3532 if (count_lp
!= nvisited_lp
)
3534 error ("%<lp_array%> does not match %<region_tree%>");
3540 dump_eh_tree (stderr
, fun
);
3541 internal_error ("%qs failed", __func__
);
3545 #include "gt-except.h"