1 /* Implements exception handling.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5 Contributed by Mike Stump <mrs@cygnus.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* An exception is an event that can be signaled from within a
25 function. This event can then be "caught" or "trapped" by the
26 callers of this function. This potentially allows program flow to
27 be transferred to any arbitrary code associated with a function call
28 several levels up the stack.
30 The intended use for this mechanism is for signaling "exceptional
31 events" in an out-of-band fashion, hence its name. The C++ language
32 (and many other OO-styled or functional languages) practically
33 requires such a mechanism, as otherwise it becomes very difficult
34 or even impossible to signal failure conditions in complex
35 situations. The traditional C++ example is when an error occurs in
36 the process of constructing an object; without such a mechanism, it
37 is impossible to signal that the error occurs without adding global
38 state variables and error checks around every object construction.
40 The act of causing this event to occur is referred to as "throwing
41 an exception". (Alternate terms include "raising an exception" or
42 "signaling an exception".) The term "throw" is used because control
43 is returned to the callers of the function that is signaling the
44 exception, and thus there is the concept of "throwing" the
45 exception up the call stack.
47 [ Add updated documentation on how to use this. ] */
52 #include "coretypes.h"
60 #include "insn-config.h"
62 #include "integrate.h"
63 #include "hard-reg-set.h"
64 #include "basic-block.h"
66 #include "dwarf2asm.h"
67 #include "dwarf2out.h"
75 #include "langhooks.h"
77 #include "diagnostic.h"
78 #include "tree-pass.h"
81 /* Provide defaults for stuff that may not be defined when using
83 #ifndef EH_RETURN_DATA_REGNO
84 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
87 /* Protect cleanup actions with must-not-throw regions, with a call
88 to the given failure handler. */
89 tree (*lang_protect_cleanup_actions
) (void);
91 /* Return true if type A catches type B. */
92 int (*lang_eh_type_covers
) (tree a
, tree b
);
94 /* Map a type to a runtime object to match type. */
95 tree (*lang_eh_runtime_type
) (tree
);
97 /* A hash table of label to region number. */
99 struct ehl_map_entry
GTY(())
102 struct eh_region
*region
;
105 static GTY(()) int call_site_base
;
106 static GTY ((param_is (union tree_node
)))
107 htab_t type_to_runtime_map
;
109 /* Describe the SjLj_Function_Context structure. */
110 static GTY(()) tree sjlj_fc_type_node
;
111 static int sjlj_fc_call_site_ofs
;
112 static int sjlj_fc_data_ofs
;
113 static int sjlj_fc_personality_ofs
;
114 static int sjlj_fc_lsda_ofs
;
115 static int sjlj_fc_jbuf_ofs
;
117 /* Describes one exception region. */
118 struct eh_region
GTY(())
120 /* The immediately surrounding region. */
121 struct eh_region
*outer
;
123 /* The list of immediately contained regions. */
124 struct eh_region
*inner
;
125 struct eh_region
*next_peer
;
127 /* An identifier for this region. */
130 /* When a region is deleted, its parents inherit the REG_EH_REGION
131 numbers already assigned. */
134 /* Each region does exactly one thing. */
141 ERT_ALLOWED_EXCEPTIONS
,
146 /* Holds the action to perform based on the preceding type. */
148 /* A list of catch blocks, a surrounding try block,
149 and the label for continuing after a catch. */
150 struct eh_region_u_try
{
151 struct eh_region
*catch;
152 struct eh_region
*last_catch
;
153 } GTY ((tag ("ERT_TRY"))) try;
155 /* The list through the catch handlers, the list of type objects
156 matched, and the list of associated filters. */
157 struct eh_region_u_catch
{
158 struct eh_region
*next_catch
;
159 struct eh_region
*prev_catch
;
162 } GTY ((tag ("ERT_CATCH"))) catch;
164 /* A tree_list of allowed types. */
165 struct eh_region_u_allowed
{
168 } GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed
;
170 /* The type given by a call to "throw foo();", or discovered
172 struct eh_region_u_throw
{
174 } GTY ((tag ("ERT_THROW"))) throw;
176 /* Retain the cleanup expression even after expansion so that
177 we can match up fixup regions. */
178 struct eh_region_u_cleanup
{
179 struct eh_region
*prev_try
;
180 } GTY ((tag ("ERT_CLEANUP"))) cleanup
;
181 } GTY ((desc ("%0.type"))) u
;
183 /* Entry point for this region's handler before landing pads are built. */
187 /* Entry point for this region's handler from the runtime eh library. */
190 /* Entry point for this region's handler from an inner region. */
191 rtx post_landing_pad
;
193 /* The RESX insn for handing off control to the next outermost handler,
197 /* True if something in this region may throw. */
198 unsigned may_contain_throw
: 1;
201 typedef struct eh_region
*eh_region
;
203 struct call_site_record
GTY(())
209 DEF_VEC_P(eh_region
);
210 DEF_VEC_ALLOC_P(eh_region
, gc
);
212 /* Used to save exception status for each function. */
213 struct eh_status
GTY(())
215 /* The tree of all regions for this function. */
216 struct eh_region
*region_tree
;
218 /* The same information as an indexable array. */
219 VEC(eh_region
,gc
) *region_array
;
220 int last_region_number
;
222 htab_t
GTY((param_is (struct throw_stmt_node
))) throw_stmt_table
;
225 static int t2r_eq (const void *, const void *);
226 static hashval_t
t2r_hash (const void *);
227 static void add_type_for_runtime (tree
);
228 static tree
lookup_type_for_runtime (tree
);
230 static void remove_unreachable_regions (rtx
);
232 static int ttypes_filter_eq (const void *, const void *);
233 static hashval_t
ttypes_filter_hash (const void *);
234 static int ehspec_filter_eq (const void *, const void *);
235 static hashval_t
ehspec_filter_hash (const void *);
236 static int add_ttypes_entry (htab_t
, tree
);
237 static int add_ehspec_entry (htab_t
, htab_t
, tree
);
238 static void assign_filter_values (void);
239 static void build_post_landing_pads (void);
240 static void connect_post_landing_pads (void);
241 static void dw2_build_landing_pads (void);
244 static bool sjlj_find_directly_reachable_regions (struct sjlj_lp_info
*);
245 static void sjlj_assign_call_site_values (rtx
, struct sjlj_lp_info
*);
246 static void sjlj_mark_call_sites (struct sjlj_lp_info
*);
247 static void sjlj_emit_function_enter (rtx
);
248 static void sjlj_emit_function_exit (void);
249 static void sjlj_emit_dispatch_table (rtx
, struct sjlj_lp_info
*);
250 static void sjlj_build_landing_pads (void);
252 static hashval_t
ehl_hash (const void *);
253 static int ehl_eq (const void *, const void *);
254 static void add_ehl_entry (rtx
, struct eh_region
*);
255 static void remove_exception_handler_label (rtx
);
256 static void remove_eh_handler (struct eh_region
*);
257 static int for_each_eh_label_1 (void **, void *);
259 /* The return value of reachable_next_level. */
262 /* The given exception is not processed by the given region. */
264 /* The given exception may need processing by the given region. */
266 /* The given exception is completely processed by the given region. */
268 /* The given exception is completely processed by the runtime. */
272 struct reachable_info
;
273 static enum reachable_code
reachable_next_level (struct eh_region
*, tree
,
274 struct reachable_info
*);
276 static int action_record_eq (const void *, const void *);
277 static hashval_t
action_record_hash (const void *);
278 static int add_action_record (htab_t
, int, int);
279 static int collect_one_action_chain (htab_t
, struct eh_region
*);
280 static int add_call_site (rtx
, int);
282 static void push_uleb128 (varray_type
*, unsigned int);
283 static void push_sleb128 (varray_type
*, int);
284 #ifndef HAVE_AS_LEB128
285 static int dw2_size_of_call_site_table (void);
286 static int sjlj_size_of_call_site_table (void);
288 static void dw2_output_call_site_table (void);
289 static void sjlj_output_call_site_table (void);
292 /* Routine to see if exception handling is turned on.
293 DO_WARN is nonzero if we want to inform the user that exception
294 handling is turned off.
296 This is used to ensure that -fexceptions has been specified if the
297 compiler tries to use any exception-specific functions. */
300 doing_eh (int do_warn
)
302 if (! flag_exceptions
)
304 static int warned
= 0;
305 if (! warned
&& do_warn
)
307 error ("exception handling disabled, use -fexceptions to enable");
319 if (! flag_exceptions
)
322 type_to_runtime_map
= htab_create_ggc (31, t2r_hash
, t2r_eq
, NULL
);
324 /* Create the SjLj_Function_Context structure. This should match
325 the definition in unwind-sjlj.c. */
326 if (USING_SJLJ_EXCEPTIONS
)
328 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
330 sjlj_fc_type_node
= lang_hooks
.types
.make_type (RECORD_TYPE
);
332 f_prev
= build_decl (FIELD_DECL
, get_identifier ("__prev"),
333 build_pointer_type (sjlj_fc_type_node
));
334 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
336 f_cs
= build_decl (FIELD_DECL
, get_identifier ("__call_site"),
338 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
340 tmp
= build_index_type (build_int_cst (NULL_TREE
, 4 - 1));
341 tmp
= build_array_type (lang_hooks
.types
.type_for_mode (word_mode
, 1),
343 f_data
= build_decl (FIELD_DECL
, get_identifier ("__data"), tmp
);
344 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
346 f_per
= build_decl (FIELD_DECL
, get_identifier ("__personality"),
348 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
350 f_lsda
= build_decl (FIELD_DECL
, get_identifier ("__lsda"),
352 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
354 #ifdef DONT_USE_BUILTIN_SETJMP
356 tmp
= build_int_cst (NULL_TREE
, JMP_BUF_SIZE
- 1);
358 /* Should be large enough for most systems, if it is not,
359 JMP_BUF_SIZE should be defined with the proper value. It will
360 also tend to be larger than necessary for most systems, a more
361 optimal port will define JMP_BUF_SIZE. */
362 tmp
= build_int_cst (NULL_TREE
, FIRST_PSEUDO_REGISTER
+ 2 - 1);
365 /* builtin_setjmp takes a pointer to 5 words. */
366 tmp
= build_int_cst (NULL_TREE
, 5 * BITS_PER_WORD
/ POINTER_SIZE
- 1);
368 tmp
= build_index_type (tmp
);
369 tmp
= build_array_type (ptr_type_node
, tmp
);
370 f_jbuf
= build_decl (FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
371 #ifdef DONT_USE_BUILTIN_SETJMP
372 /* We don't know what the alignment requirements of the
373 runtime's jmp_buf has. Overestimate. */
374 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
375 DECL_USER_ALIGN (f_jbuf
) = 1;
377 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
379 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
380 TREE_CHAIN (f_prev
) = f_cs
;
381 TREE_CHAIN (f_cs
) = f_data
;
382 TREE_CHAIN (f_data
) = f_per
;
383 TREE_CHAIN (f_per
) = f_lsda
;
384 TREE_CHAIN (f_lsda
) = f_jbuf
;
386 layout_type (sjlj_fc_type_node
);
388 /* Cache the interesting field offsets so that we have
389 easy access from rtl. */
390 sjlj_fc_call_site_ofs
391 = (tree_low_cst (DECL_FIELD_OFFSET (f_cs
), 1)
392 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs
), 1) / BITS_PER_UNIT
);
394 = (tree_low_cst (DECL_FIELD_OFFSET (f_data
), 1)
395 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data
), 1) / BITS_PER_UNIT
);
396 sjlj_fc_personality_ofs
397 = (tree_low_cst (DECL_FIELD_OFFSET (f_per
), 1)
398 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per
), 1) / BITS_PER_UNIT
);
400 = (tree_low_cst (DECL_FIELD_OFFSET (f_lsda
), 1)
401 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda
), 1) / BITS_PER_UNIT
);
403 = (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf
), 1)
404 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf
), 1) / BITS_PER_UNIT
);
409 init_eh_for_function (void)
411 cfun
->eh
= ggc_alloc_cleared (sizeof (struct eh_status
));
414 /* Routines to generate the exception tree somewhat directly.
415 These are used from tree-eh.c when processing exception related
416 nodes during tree optimization. */
418 static struct eh_region
*
419 gen_eh_region (enum eh_region_type type
, struct eh_region
*outer
)
421 struct eh_region
*new;
423 #ifdef ENABLE_CHECKING
424 gcc_assert (doing_eh (0));
427 /* Insert a new blank region as a leaf in the tree. */
428 new = ggc_alloc_cleared (sizeof (*new));
433 new->next_peer
= outer
->inner
;
438 new->next_peer
= cfun
->eh
->region_tree
;
439 cfun
->eh
->region_tree
= new;
442 new->region_number
= ++cfun
->eh
->last_region_number
;
448 gen_eh_region_cleanup (struct eh_region
*outer
, struct eh_region
*prev_try
)
450 struct eh_region
*cleanup
= gen_eh_region (ERT_CLEANUP
, outer
);
451 cleanup
->u
.cleanup
.prev_try
= prev_try
;
456 gen_eh_region_try (struct eh_region
*outer
)
458 return gen_eh_region (ERT_TRY
, outer
);
462 gen_eh_region_catch (struct eh_region
*t
, tree type_or_list
)
464 struct eh_region
*c
, *l
;
465 tree type_list
, type_node
;
467 /* Ensure to always end up with a type list to normalize further
468 processing, then register each type against the runtime types map. */
469 type_list
= type_or_list
;
472 if (TREE_CODE (type_or_list
) != TREE_LIST
)
473 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
475 type_node
= type_list
;
476 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
477 add_type_for_runtime (TREE_VALUE (type_node
));
480 c
= gen_eh_region (ERT_CATCH
, t
->outer
);
481 c
->u
.catch.type_list
= type_list
;
482 l
= t
->u
.try.last_catch
;
483 c
->u
.catch.prev_catch
= l
;
485 l
->u
.catch.next_catch
= c
;
488 t
->u
.try.last_catch
= c
;
494 gen_eh_region_allowed (struct eh_region
*outer
, tree allowed
)
496 struct eh_region
*region
= gen_eh_region (ERT_ALLOWED_EXCEPTIONS
, outer
);
497 region
->u
.allowed
.type_list
= allowed
;
499 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
500 add_type_for_runtime (TREE_VALUE (allowed
));
506 gen_eh_region_must_not_throw (struct eh_region
*outer
)
508 return gen_eh_region (ERT_MUST_NOT_THROW
, outer
);
512 get_eh_region_number (struct eh_region
*region
)
514 return region
->region_number
;
518 get_eh_region_may_contain_throw (struct eh_region
*region
)
520 return region
->may_contain_throw
;
524 get_eh_region_tree_label (struct eh_region
*region
)
526 return region
->tree_label
;
530 set_eh_region_tree_label (struct eh_region
*region
, tree lab
)
532 region
->tree_label
= lab
;
536 expand_resx_expr (tree exp
)
538 int region_nr
= TREE_INT_CST_LOW (TREE_OPERAND (exp
, 0));
539 struct eh_region
*reg
= VEC_index (eh_region
,
540 cfun
->eh
->region_array
, region_nr
);
542 gcc_assert (!reg
->resume
);
543 reg
->resume
= emit_jump_insn (gen_rtx_RESX (VOIDmode
, region_nr
));
547 /* Note that the current EH region (if any) may contain a throw, or a
548 call to a function which itself may contain a throw. */
551 note_eh_region_may_contain_throw (struct eh_region
*region
)
553 while (region
&& !region
->may_contain_throw
)
555 region
->may_contain_throw
= 1;
556 region
= region
->outer
;
561 /* Return an rtl expression for a pointer to the exception object
565 get_exception_pointer (void)
567 if (! crtl
->eh
.exc_ptr
)
568 crtl
->eh
.exc_ptr
= gen_reg_rtx (ptr_mode
);
569 return crtl
->eh
.exc_ptr
;
572 /* Return an rtl expression for the exception dispatch filter
576 get_exception_filter (void)
578 if (! crtl
->eh
.filter
)
579 crtl
->eh
.filter
= gen_reg_rtx (targetm
.eh_return_filter_mode ());
580 return crtl
->eh
.filter
;
583 /* This section is for the exception handling specific optimization pass. */
585 /* Random access the exception region tree. */
588 collect_eh_region_array (void)
592 i
= cfun
->eh
->region_tree
;
596 VEC_safe_grow (eh_region
, gc
, cfun
->eh
->region_array
,
597 cfun
->eh
->last_region_number
+ 1);
598 VEC_replace (eh_region
, cfun
->eh
->region_array
, 0, 0);
602 VEC_replace (eh_region
, cfun
->eh
->region_array
, i
->region_number
, i
);
604 /* If there are sub-regions, process them. */
607 /* If there are peers, process them. */
608 else if (i
->next_peer
)
610 /* Otherwise, step back up the tree to the next peer. */
617 } while (i
->next_peer
== NULL
);
623 /* Remove all regions whose labels are not reachable from insns. */
626 remove_unreachable_regions (rtx insns
)
628 int i
, *uid_region_num
;
633 uid_region_num
= xcalloc (get_max_uid (), sizeof(int));
634 reachable
= xcalloc (cfun
->eh
->last_region_number
+ 1, sizeof(bool));
636 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
638 r
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
639 if (!r
|| r
->region_number
!= i
)
644 gcc_assert (!uid_region_num
[INSN_UID (r
->resume
)]);
645 uid_region_num
[INSN_UID (r
->resume
)] = i
;
649 gcc_assert (!uid_region_num
[INSN_UID (r
->label
)]);
650 uid_region_num
[INSN_UID (r
->label
)] = i
;
654 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
655 reachable
[uid_region_num
[INSN_UID (insn
)]] = true;
657 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
659 r
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
660 if (r
&& r
->region_number
== i
&& !reachable
[i
])
666 /* Don't remove ERT_THROW regions if their outer region
668 if (r
->outer
&& reachable
[r
->outer
->region_number
])
672 case ERT_MUST_NOT_THROW
:
673 /* MUST_NOT_THROW regions are implementable solely in the
674 runtime, but their existence continues to affect calls
675 within that region. Never delete them here. */
681 /* TRY regions are reachable if any of its CATCH regions
684 for (c
= r
->u
.try.catch; c
; c
= c
->u
.catch.next_catch
)
685 if (reachable
[c
->region_number
])
698 remove_eh_handler (r
);
703 free (uid_region_num
);
706 /* Set up EH labels for RTL. */
709 convert_from_eh_region_ranges (void)
711 rtx insns
= get_insns ();
712 int i
, n
= cfun
->eh
->last_region_number
;
714 /* Most of the work is already done at the tree level. All we need to
715 do is collect the rtl labels that correspond to the tree labels that
716 collect the rtl labels that correspond to the tree labels
717 we allocated earlier. */
718 for (i
= 1; i
<= n
; ++i
)
720 struct eh_region
*region
;
722 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
723 if (region
&& region
->tree_label
)
724 region
->label
= DECL_RTL_IF_SET (region
->tree_label
);
727 remove_unreachable_regions (insns
);
731 add_ehl_entry (rtx label
, struct eh_region
*region
)
733 struct ehl_map_entry
**slot
, *entry
;
735 LABEL_PRESERVE_P (label
) = 1;
737 entry
= ggc_alloc (sizeof (*entry
));
738 entry
->label
= label
;
739 entry
->region
= region
;
741 slot
= (struct ehl_map_entry
**)
742 htab_find_slot (crtl
->eh
.exception_handler_label_map
, entry
, INSERT
);
744 /* Before landing pad creation, each exception handler has its own
745 label. After landing pad creation, the exception handlers may
746 share landing pads. This is ok, since maybe_remove_eh_handler
747 only requires the 1-1 mapping before landing pad creation. */
748 gcc_assert (!*slot
|| crtl
->eh
.built_landing_pads
);
754 find_exception_handler_labels (void)
758 if (crtl
->eh
.exception_handler_label_map
)
759 htab_empty (crtl
->eh
.exception_handler_label_map
);
762 /* ??? The expansion factor here (3/2) must be greater than the htab
763 occupancy factor (4/3) to avoid unnecessary resizing. */
764 crtl
->eh
.exception_handler_label_map
765 = htab_create_ggc (cfun
->eh
->last_region_number
* 3 / 2,
766 ehl_hash
, ehl_eq
, NULL
);
769 if (cfun
->eh
->region_tree
== NULL
)
772 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
774 struct eh_region
*region
;
777 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
778 if (! region
|| region
->region_number
!= i
)
780 if (crtl
->eh
.built_landing_pads
)
781 lab
= region
->landing_pad
;
786 add_ehl_entry (lab
, region
);
789 /* For sjlj exceptions, need the return label to remain live until
790 after landing pad generation. */
791 if (USING_SJLJ_EXCEPTIONS
&& ! crtl
->eh
.built_landing_pads
)
792 add_ehl_entry (return_label
, NULL
);
795 /* Returns true if the current function has exception handling regions. */
798 current_function_has_exception_handlers (void)
802 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
804 struct eh_region
*region
;
806 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
808 && region
->region_number
== i
809 && region
->type
!= ERT_THROW
)
816 /* A subroutine of duplicate_eh_regions. Search the region tree under O
817 for the minimum and maximum region numbers. Update *MIN and *MAX. */
820 duplicate_eh_regions_0 (eh_region o
, int *min
, int *max
)
822 if (o
->region_number
< *min
)
823 *min
= o
->region_number
;
824 if (o
->region_number
> *max
)
825 *max
= o
->region_number
;
830 duplicate_eh_regions_0 (o
, min
, max
);
834 duplicate_eh_regions_0 (o
, min
, max
);
839 /* A subroutine of duplicate_eh_regions. Copy the region tree under OLD.
840 Root it at OUTER, and apply EH_OFFSET to the region number. Don't worry
841 about the other internal pointers just yet, just the tree-like pointers. */
844 duplicate_eh_regions_1 (eh_region old
, eh_region outer
, int eh_offset
)
848 ret
= n
= ggc_alloc (sizeof (struct eh_region
));
853 gcc_assert (!old
->aka
);
855 n
->region_number
+= eh_offset
;
856 VEC_replace (eh_region
, cfun
->eh
->region_array
, n
->region_number
, n
);
861 n
= n
->inner
= duplicate_eh_regions_1 (old
, ret
, eh_offset
);
862 while (old
->next_peer
)
864 old
= old
->next_peer
;
865 n
= n
->next_peer
= duplicate_eh_regions_1 (old
, ret
, eh_offset
);
872 /* Duplicate the EH regions of IFUN, rooted at COPY_REGION, into current
873 function and root the tree below OUTER_REGION. Remap labels using MAP
874 callback. The special case of COPY_REGION of 0 means all regions. */
877 duplicate_eh_regions (struct function
*ifun
, duplicate_eh_regions_map map
,
878 void *data
, int copy_region
, int outer_region
)
880 eh_region cur
, prev_try
, outer
, *splice
;
881 int i
, min_region
, max_region
, eh_offset
, cfun_last_region_number
;
884 if (!ifun
->eh
->region_tree
)
887 /* Find the range of region numbers to be copied. The interface we
888 provide here mandates a single offset to find new number from old,
889 which means we must look at the numbers present, instead of the
890 count or something else. */
893 min_region
= INT_MAX
;
896 cur
= VEC_index (eh_region
, ifun
->eh
->region_array
, copy_region
);
897 duplicate_eh_regions_0 (cur
, &min_region
, &max_region
);
900 min_region
= 1, max_region
= ifun
->eh
->last_region_number
;
901 num_regions
= max_region
- min_region
+ 1;
902 cfun_last_region_number
= cfun
->eh
->last_region_number
;
903 eh_offset
= cfun_last_region_number
+ 1 - min_region
;
905 /* If we've not yet created a region array, do so now. */
906 VEC_safe_grow (eh_region
, gc
, cfun
->eh
->region_array
,
907 cfun_last_region_number
+ 1 + num_regions
);
908 cfun
->eh
->last_region_number
= max_region
+ eh_offset
;
910 /* We may have just allocated the array for the first time.
911 Make sure that element zero is null. */
912 VEC_replace (eh_region
, cfun
->eh
->region_array
, 0, 0);
914 /* Zero all entries in the range allocated. */
915 memset (VEC_address (eh_region
, cfun
->eh
->region_array
)
916 + cfun_last_region_number
+ 1, 0, num_regions
* sizeof (eh_region
));
918 /* Locate the spot at which to insert the new tree. */
919 if (outer_region
> 0)
921 outer
= VEC_index (eh_region
, cfun
->eh
->region_array
, outer_region
);
922 splice
= &outer
->inner
;
927 splice
= &cfun
->eh
->region_tree
;
930 splice
= &(*splice
)->next_peer
;
932 /* Copy all the regions in the subtree. */
935 cur
= VEC_index (eh_region
, ifun
->eh
->region_array
, copy_region
);
936 *splice
= duplicate_eh_regions_1 (cur
, outer
, eh_offset
);
942 cur
= ifun
->eh
->region_tree
;
943 *splice
= n
= duplicate_eh_regions_1 (cur
, outer
, eh_offset
);
944 while (cur
->next_peer
)
946 cur
= cur
->next_peer
;
947 n
= n
->next_peer
= duplicate_eh_regions_1 (cur
, outer
, eh_offset
);
951 /* Remap all the labels in the new regions. */
952 for (i
= cfun_last_region_number
+ 1;
953 VEC_iterate (eh_region
, cfun
->eh
->region_array
, i
, cur
); ++i
)
954 if (cur
&& cur
->tree_label
)
955 cur
->tree_label
= map (cur
->tree_label
, data
);
957 /* Search for the containing ERT_TRY region to fix up
958 the prev_try short-cuts for ERT_CLEANUP regions. */
960 if (outer_region
> 0)
961 for (prev_try
= VEC_index (eh_region
, cfun
->eh
->region_array
, outer_region
);
962 prev_try
&& prev_try
->type
!= ERT_TRY
;
963 prev_try
= prev_try
->outer
)
964 if (prev_try
->type
== ERT_MUST_NOT_THROW
965 || (prev_try
->type
== ERT_ALLOWED_EXCEPTIONS
966 && !prev_try
->u
.allowed
.type_list
))
972 /* Remap all of the internal catch and cleanup linkages. Since we
973 duplicate entire subtrees, all of the referenced regions will have
974 been copied too. And since we renumbered them as a block, a simple
975 bit of arithmetic finds us the index for the replacement region. */
976 for (i
= cfun_last_region_number
+ 1;
977 VEC_iterate (eh_region
, cfun
->eh
->region_array
, i
, cur
); ++i
)
983 (REG) = VEC_index (eh_region, cfun->eh->region_array, \
984 (REG)->region_number + eh_offset)
989 if (cur
->u
.try.catch)
990 REMAP (cur
->u
.try.catch);
991 if (cur
->u
.try.last_catch
)
992 REMAP (cur
->u
.try.last_catch
);
996 if (cur
->u
.catch.next_catch
)
997 REMAP (cur
->u
.catch.next_catch
);
998 if (cur
->u
.catch.prev_catch
)
999 REMAP (cur
->u
.catch.prev_catch
);
1003 if (cur
->u
.cleanup
.prev_try
)
1004 REMAP (cur
->u
.cleanup
.prev_try
);
1006 cur
->u
.cleanup
.prev_try
= prev_try
;
1019 /* Return true if REGION_A is outer to REGION_B in IFUN. */
1022 eh_region_outer_p (struct function
*ifun
, int region_a
, int region_b
)
1024 struct eh_region
*rp_a
, *rp_b
;
1026 gcc_assert (ifun
->eh
->last_region_number
> 0);
1027 gcc_assert (ifun
->eh
->region_tree
);
1029 rp_a
= VEC_index (eh_region
, ifun
->eh
->region_array
, region_a
);
1030 rp_b
= VEC_index (eh_region
, ifun
->eh
->region_array
, region_b
);
1031 gcc_assert (rp_a
!= NULL
);
1032 gcc_assert (rp_b
!= NULL
);
1045 /* Return region number of region that is outer to both if REGION_A and
1046 REGION_B in IFUN. */
1049 eh_region_outermost (struct function
*ifun
, int region_a
, int region_b
)
1051 struct eh_region
*rp_a
, *rp_b
;
1054 gcc_assert (ifun
->eh
->last_region_number
> 0);
1055 gcc_assert (ifun
->eh
->region_tree
);
1057 rp_a
= VEC_index (eh_region
, ifun
->eh
->region_array
, region_a
);
1058 rp_b
= VEC_index (eh_region
, ifun
->eh
->region_array
, region_b
);
1059 gcc_assert (rp_a
!= NULL
);
1060 gcc_assert (rp_b
!= NULL
);
1062 b_outer
= sbitmap_alloc (ifun
->eh
->last_region_number
+ 1);
1063 sbitmap_zero (b_outer
);
1067 SET_BIT (b_outer
, rp_b
->region_number
);
1074 if (TEST_BIT (b_outer
, rp_a
->region_number
))
1076 sbitmap_free (b_outer
);
1077 return rp_a
->region_number
;
1083 sbitmap_free (b_outer
);
1088 t2r_eq (const void *pentry
, const void *pdata
)
1090 const_tree
const entry
= (const_tree
) pentry
;
1091 const_tree
const data
= (const_tree
) pdata
;
1093 return TREE_PURPOSE (entry
) == data
;
1097 t2r_hash (const void *pentry
)
1099 const_tree
const entry
= (const_tree
) pentry
;
1100 return TREE_HASH (TREE_PURPOSE (entry
));
1104 add_type_for_runtime (tree type
)
1108 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
1109 TREE_HASH (type
), INSERT
);
1112 tree runtime
= (*lang_eh_runtime_type
) (type
);
1113 *slot
= tree_cons (type
, runtime
, NULL_TREE
);
1118 lookup_type_for_runtime (tree type
)
1122 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
1123 TREE_HASH (type
), NO_INSERT
);
1125 /* We should have always inserted the data earlier. */
1126 return TREE_VALUE (*slot
);
1130 /* Represent an entry in @TTypes for either catch actions
1131 or exception filter actions. */
1132 struct ttypes_filter
GTY(())
1138 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
1139 (a tree) for a @TTypes type node we are thinking about adding. */
1142 ttypes_filter_eq (const void *pentry
, const void *pdata
)
1144 const struct ttypes_filter
*const entry
1145 = (const struct ttypes_filter
*) pentry
;
1146 const_tree
const data
= (const_tree
) pdata
;
1148 return entry
->t
== data
;
1152 ttypes_filter_hash (const void *pentry
)
1154 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1155 return TREE_HASH (entry
->t
);
1158 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
1159 exception specification list we are thinking about adding. */
1160 /* ??? Currently we use the type lists in the order given. Someone
1161 should put these in some canonical order. */
1164 ehspec_filter_eq (const void *pentry
, const void *pdata
)
1166 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1167 const struct ttypes_filter
*data
= (const struct ttypes_filter
*) pdata
;
1169 return type_list_equal (entry
->t
, data
->t
);
1172 /* Hash function for exception specification lists. */
1175 ehspec_filter_hash (const void *pentry
)
1177 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1181 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
1182 h
= (h
<< 5) + (h
>> 27) + TREE_HASH (TREE_VALUE (list
));
1186 /* Add TYPE (which may be NULL) to crtl->eh.ttype_data, using TYPES_HASH
1187 to speed up the search. Return the filter value to be used. */
1190 add_ttypes_entry (htab_t ttypes_hash
, tree type
)
1192 struct ttypes_filter
**slot
, *n
;
1194 slot
= (struct ttypes_filter
**)
1195 htab_find_slot_with_hash (ttypes_hash
, type
, TREE_HASH (type
), INSERT
);
1197 if ((n
= *slot
) == NULL
)
1199 /* Filter value is a 1 based table index. */
1201 n
= XNEW (struct ttypes_filter
);
1203 n
->filter
= VEC_length (tree
, crtl
->eh
.ttype_data
) + 1;
1206 VEC_safe_push (tree
, gc
, crtl
->eh
.ttype_data
, type
);
1212 /* Add LIST to crtl->eh.ehspec_data, using EHSPEC_HASH and TYPES_HASH
1213 to speed up the search. Return the filter value to be used. */
1216 add_ehspec_entry (htab_t ehspec_hash
, htab_t ttypes_hash
, tree list
)
1218 struct ttypes_filter
**slot
, *n
;
1219 struct ttypes_filter dummy
;
1222 slot
= (struct ttypes_filter
**)
1223 htab_find_slot (ehspec_hash
, &dummy
, INSERT
);
1225 if ((n
= *slot
) == NULL
)
1227 /* Filter value is a -1 based byte index into a uleb128 buffer. */
1229 n
= XNEW (struct ttypes_filter
);
1231 n
->filter
= -(VARRAY_ACTIVE_SIZE (crtl
->eh
.ehspec_data
) + 1);
1234 /* Generate a 0 terminated list of filter values. */
1235 for (; list
; list
= TREE_CHAIN (list
))
1237 if (targetm
.arm_eabi_unwinder
)
1238 VARRAY_PUSH_TREE (crtl
->eh
.ehspec_data
, TREE_VALUE (list
));
1241 /* Look up each type in the list and encode its filter
1242 value as a uleb128. */
1243 push_uleb128 (&crtl
->eh
.ehspec_data
,
1244 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
1247 if (targetm
.arm_eabi_unwinder
)
1248 VARRAY_PUSH_TREE (crtl
->eh
.ehspec_data
, NULL_TREE
);
1250 VARRAY_PUSH_UCHAR (crtl
->eh
.ehspec_data
, 0);
1256 /* Generate the action filter values to be used for CATCH and
1257 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
1258 we use lots of landing pads, and so every type or list can share
1259 the same filter value, which saves table space. */
1262 assign_filter_values (void)
1265 htab_t ttypes
, ehspec
;
1267 crtl
->eh
.ttype_data
= VEC_alloc (tree
, gc
, 16);
1268 if (targetm
.arm_eabi_unwinder
)
1269 VARRAY_TREE_INIT (crtl
->eh
.ehspec_data
, 64, "ehspec_data");
1271 VARRAY_UCHAR_INIT (crtl
->eh
.ehspec_data
, 64, "ehspec_data");
1273 ttypes
= htab_create (31, ttypes_filter_hash
, ttypes_filter_eq
, free
);
1274 ehspec
= htab_create (31, ehspec_filter_hash
, ehspec_filter_eq
, free
);
1276 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1278 struct eh_region
*r
;
1280 r
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
1282 /* Mind we don't process a region more than once. */
1283 if (!r
|| r
->region_number
!= i
)
1289 /* Whatever type_list is (NULL or true list), we build a list
1290 of filters for the region. */
1291 r
->u
.catch.filter_list
= NULL_TREE
;
1293 if (r
->u
.catch.type_list
!= NULL
)
1295 /* Get a filter value for each of the types caught and store
1296 them in the region's dedicated list. */
1297 tree tp_node
= r
->u
.catch.type_list
;
1299 for (;tp_node
; tp_node
= TREE_CHAIN (tp_node
))
1301 int flt
= add_ttypes_entry (ttypes
, TREE_VALUE (tp_node
));
1302 tree flt_node
= build_int_cst (NULL_TREE
, flt
);
1304 r
->u
.catch.filter_list
1305 = tree_cons (NULL_TREE
, flt_node
, r
->u
.catch.filter_list
);
1310 /* Get a filter value for the NULL list also since it will need
1311 an action record anyway. */
1312 int flt
= add_ttypes_entry (ttypes
, NULL
);
1313 tree flt_node
= build_int_cst (NULL_TREE
, flt
);
1315 r
->u
.catch.filter_list
1316 = tree_cons (NULL_TREE
, flt_node
, r
->u
.catch.filter_list
);
1321 case ERT_ALLOWED_EXCEPTIONS
:
1323 = add_ehspec_entry (ehspec
, ttypes
, r
->u
.allowed
.type_list
);
1331 htab_delete (ttypes
);
1332 htab_delete (ehspec
);
1335 /* Emit SEQ into basic block just before INSN (that is assumed to be
1336 first instruction of some existing BB and return the newly
1339 emit_to_new_bb_before (rtx seq
, rtx insn
)
1346 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
1347 call), we don't want it to go into newly created landing pad or other EH
1349 for (ei
= ei_start (BLOCK_FOR_INSN (insn
)->preds
); (e
= ei_safe_edge (ei
)); )
1350 if (e
->flags
& EDGE_FALLTHRU
)
1351 force_nonfallthru (e
);
1354 last
= emit_insn_before (seq
, insn
);
1355 if (BARRIER_P (last
))
1356 last
= PREV_INSN (last
);
1357 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
1358 update_bb_for_insn (bb
);
1359 bb
->flags
|= BB_SUPERBLOCK
;
1363 /* Generate the code to actually handle exceptions, which will follow the
1367 build_post_landing_pads (void)
1371 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1373 struct eh_region
*region
;
1376 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
1377 /* Mind we don't process a region more than once. */
1378 if (!region
|| region
->region_number
!= i
)
1381 switch (region
->type
)
1384 /* ??? Collect the set of all non-overlapping catch handlers
1385 all the way up the chain until blocked by a cleanup. */
1386 /* ??? Outer try regions can share landing pads with inner
1387 try regions if the types are completely non-overlapping,
1388 and there are no intervening cleanups. */
1390 region
->post_landing_pad
= gen_label_rtx ();
1394 emit_label (region
->post_landing_pad
);
1396 /* ??? It is mighty inconvenient to call back into the
1397 switch statement generation code in expand_end_case.
1398 Rapid prototyping sez a sequence of ifs. */
1400 struct eh_region
*c
;
1401 for (c
= region
->u
.try.catch; c
; c
= c
->u
.catch.next_catch
)
1403 if (c
->u
.catch.type_list
== NULL
)
1404 emit_jump (c
->label
);
1407 /* Need for one cmp/jump per type caught. Each type
1408 list entry has a matching entry in the filter list
1409 (see assign_filter_values). */
1410 tree tp_node
= c
->u
.catch.type_list
;
1411 tree flt_node
= c
->u
.catch.filter_list
;
1415 emit_cmp_and_jump_insns
1417 GEN_INT (tree_low_cst (TREE_VALUE (flt_node
), 0)),
1419 targetm
.eh_return_filter_mode (), 0, c
->label
);
1421 tp_node
= TREE_CHAIN (tp_node
);
1422 flt_node
= TREE_CHAIN (flt_node
);
1428 /* We delay the generation of the _Unwind_Resume until we generate
1429 landing pads. We emit a marker here so as to get good control
1430 flow data in the meantime. */
1432 = emit_jump_insn (gen_rtx_RESX (VOIDmode
, region
->region_number
));
1438 emit_to_new_bb_before (seq
, region
->u
.try.catch->label
);
1442 case ERT_ALLOWED_EXCEPTIONS
:
1443 region
->post_landing_pad
= gen_label_rtx ();
1447 emit_label (region
->post_landing_pad
);
1449 emit_cmp_and_jump_insns (crtl
->eh
.filter
,
1450 GEN_INT (region
->u
.allowed
.filter
),
1452 targetm
.eh_return_filter_mode (), 0, region
->label
);
1454 /* We delay the generation of the _Unwind_Resume until we generate
1455 landing pads. We emit a marker here so as to get good control
1456 flow data in the meantime. */
1458 = emit_jump_insn (gen_rtx_RESX (VOIDmode
, region
->region_number
));
1464 emit_to_new_bb_before (seq
, region
->label
);
1468 case ERT_MUST_NOT_THROW
:
1469 region
->post_landing_pad
= region
->label
;
1474 /* Nothing to do. */
1483 /* Replace RESX patterns with jumps to the next handler if any, or calls to
1484 _Unwind_Resume otherwise. */
1487 connect_post_landing_pads (void)
1491 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1493 struct eh_region
*region
;
1494 struct eh_region
*outer
;
1498 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
1499 /* Mind we don't process a region more than once. */
1500 if (!region
|| region
->region_number
!= i
)
1503 /* If there is no RESX, or it has been deleted by flow, there's
1504 nothing to fix up. */
1505 if (! region
->resume
|| INSN_DELETED_P (region
->resume
))
1508 /* Search for another landing pad in this function. */
1509 for (outer
= region
->outer
; outer
; outer
= outer
->outer
)
1510 if (outer
->post_landing_pad
)
1518 basic_block src
, dest
;
1520 emit_jump (outer
->post_landing_pad
);
1521 src
= BLOCK_FOR_INSN (region
->resume
);
1522 dest
= BLOCK_FOR_INSN (outer
->post_landing_pad
);
1523 while (EDGE_COUNT (src
->succs
) > 0)
1524 remove_edge (EDGE_SUCC (src
, 0));
1525 e
= make_edge (src
, dest
, 0);
1526 e
->probability
= REG_BR_PROB_BASE
;
1527 e
->count
= src
->count
;
1531 emit_library_call (unwind_resume_libfunc
, LCT_THROW
,
1532 VOIDmode
, 1, crtl
->eh
.exc_ptr
, ptr_mode
);
1534 /* What we just emitted was a throwing libcall, so it got a
1535 barrier automatically added after it. If the last insn in
1536 the libcall sequence isn't the barrier, it's because the
1537 target emits multiple insns for a call, and there are insns
1538 after the actual call insn (which are redundant and would be
1539 optimized away). The barrier is inserted exactly after the
1540 call insn, so let's go get that and delete the insns after
1541 it, because below we need the barrier to be the last insn in
1543 delete_insns_since (NEXT_INSN (last_call_insn ()));
1548 barrier
= emit_insn_before (seq
, region
->resume
);
1549 /* Avoid duplicate barrier. */
1550 gcc_assert (BARRIER_P (barrier
));
1551 delete_insn (barrier
);
1552 delete_insn (region
->resume
);
1554 /* ??? From tree-ssa we can wind up with catch regions whose
1555 label is not instantiated, but whose resx is present. Now
1556 that we've dealt with the resx, kill the region. */
1557 if (region
->label
== NULL
&& region
->type
== ERT_CLEANUP
)
1558 remove_eh_handler (region
);
1564 dw2_build_landing_pads (void)
1568 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1570 struct eh_region
*region
;
1575 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
1576 /* Mind we don't process a region more than once. */
1577 if (!region
|| region
->region_number
!= i
)
1580 if (region
->type
!= ERT_CLEANUP
1581 && region
->type
!= ERT_TRY
1582 && region
->type
!= ERT_ALLOWED_EXCEPTIONS
)
1587 region
->landing_pad
= gen_label_rtx ();
1588 emit_label (region
->landing_pad
);
1590 #ifdef HAVE_exception_receiver
1591 if (HAVE_exception_receiver
)
1592 emit_insn (gen_exception_receiver ());
1595 #ifdef HAVE_nonlocal_goto_receiver
1596 if (HAVE_nonlocal_goto_receiver
)
1597 emit_insn (gen_nonlocal_goto_receiver ());
1602 emit_move_insn (crtl
->eh
.exc_ptr
,
1603 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
1604 emit_move_insn (crtl
->eh
.filter
,
1605 gen_rtx_REG (targetm
.eh_return_filter_mode (),
1606 EH_RETURN_DATA_REGNO (1)));
1611 bb
= emit_to_new_bb_before (seq
, region
->post_landing_pad
);
1612 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1613 e
->count
= bb
->count
;
1614 e
->probability
= REG_BR_PROB_BASE
;
1621 int directly_reachable
;
1624 int call_site_index
;
1628 sjlj_find_directly_reachable_regions (struct sjlj_lp_info
*lp_info
)
1631 bool found_one
= false;
1633 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1635 struct eh_region
*region
;
1636 enum reachable_code rc
;
1640 if (! INSN_P (insn
))
1643 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1644 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
1647 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, INTVAL (XEXP (note
, 0)));
1649 type_thrown
= NULL_TREE
;
1650 if (region
->type
== ERT_THROW
)
1652 type_thrown
= region
->u
.throw.type
;
1653 region
= region
->outer
;
1656 /* Find the first containing region that might handle the exception.
1657 That's the landing pad to which we will transfer control. */
1658 rc
= RNL_NOT_CAUGHT
;
1659 for (; region
; region
= region
->outer
)
1661 rc
= reachable_next_level (region
, type_thrown
, NULL
);
1662 if (rc
!= RNL_NOT_CAUGHT
)
1665 if (rc
== RNL_MAYBE_CAUGHT
|| rc
== RNL_CAUGHT
)
1667 lp_info
[region
->region_number
].directly_reachable
= 1;
1676 sjlj_assign_call_site_values (rtx dispatch_label
, struct sjlj_lp_info
*lp_info
)
1681 /* First task: build the action table. */
1683 VARRAY_UCHAR_INIT (crtl
->eh
.action_record_data
, 64, "action_record_data");
1684 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
1686 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1687 if (lp_info
[i
].directly_reachable
)
1689 struct eh_region
*r
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
1691 r
->landing_pad
= dispatch_label
;
1692 lp_info
[i
].action_index
= collect_one_action_chain (ar_hash
, r
);
1693 if (lp_info
[i
].action_index
!= -1)
1694 crtl
->uses_eh_lsda
= 1;
1697 htab_delete (ar_hash
);
1699 /* Next: assign dispatch values. In dwarf2 terms, this would be the
1700 landing pad label for the region. For sjlj though, there is one
1701 common landing pad from which we dispatch to the post-landing pads.
1703 A region receives a dispatch index if it is directly reachable
1704 and requires in-function processing. Regions that share post-landing
1705 pads may share dispatch indices. */
1706 /* ??? Post-landing pad sharing doesn't actually happen at the moment
1707 (see build_post_landing_pads) so we don't bother checking for it. */
1710 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1711 if (lp_info
[i
].directly_reachable
)
1712 lp_info
[i
].dispatch_index
= index
++;
1714 /* Finally: assign call-site values. If dwarf2 terms, this would be
1715 the region number assigned by convert_to_eh_region_ranges, but
1716 handles no-action and must-not-throw differently. */
1719 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1720 if (lp_info
[i
].directly_reachable
)
1722 int action
= lp_info
[i
].action_index
;
1724 /* Map must-not-throw to otherwise unused call-site index 0. */
1727 /* Map no-action to otherwise unused call-site index -1. */
1728 else if (action
== -1)
1730 /* Otherwise, look it up in the table. */
1732 index
= add_call_site (GEN_INT (lp_info
[i
].dispatch_index
), action
);
1734 lp_info
[i
].call_site_index
= index
;
1739 sjlj_mark_call_sites (struct sjlj_lp_info
*lp_info
)
1741 int last_call_site
= -2;
1744 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1746 struct eh_region
*region
;
1748 rtx note
, before
, p
;
1750 /* Reset value tracking at extended basic block boundaries. */
1752 last_call_site
= -2;
1754 if (! INSN_P (insn
))
1757 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1760 /* Calls (and trapping insns) without notes are outside any
1761 exception handling region in this function. Mark them as
1764 || (flag_non_call_exceptions
1765 && may_trap_p (PATTERN (insn
))))
1766 this_call_site
= -1;
1772 /* Calls that are known to not throw need not be marked. */
1773 if (INTVAL (XEXP (note
, 0)) <= 0)
1776 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, INTVAL (XEXP (note
, 0)));
1777 this_call_site
= lp_info
[region
->region_number
].call_site_index
;
1780 if (this_call_site
== last_call_site
)
1783 /* Don't separate a call from it's argument loads. */
1786 before
= find_first_parameter_load (insn
, NULL_RTX
);
1789 mem
= adjust_address (crtl
->eh
.sjlj_fc
, TYPE_MODE (integer_type_node
),
1790 sjlj_fc_call_site_ofs
);
1791 emit_move_insn (mem
, GEN_INT (this_call_site
));
1795 emit_insn_before (p
, before
);
1796 last_call_site
= this_call_site
;
1800 /* Construct the SjLj_Function_Context. */
1803 sjlj_emit_function_enter (rtx dispatch_label
)
1805 rtx fn_begin
, fc
, mem
, seq
;
1806 bool fn_begin_outside_block
;
1808 fc
= crtl
->eh
.sjlj_fc
;
1812 /* We're storing this libcall's address into memory instead of
1813 calling it directly. Thus, we must call assemble_external_libcall
1814 here, as we can not depend on emit_library_call to do it for us. */
1815 assemble_external_libcall (eh_personality_libfunc
);
1816 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
1817 emit_move_insn (mem
, eh_personality_libfunc
);
1819 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
1820 if (crtl
->uses_eh_lsda
)
1825 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
1826 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
1827 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
1828 emit_move_insn (mem
, sym
);
1831 emit_move_insn (mem
, const0_rtx
);
1833 #ifdef DONT_USE_BUILTIN_SETJMP
1836 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
1837 TYPE_MODE (integer_type_node
), 1,
1838 plus_constant (XEXP (fc
, 0),
1839 sjlj_fc_jbuf_ofs
), Pmode
);
1841 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
1842 TYPE_MODE (integer_type_node
), 0, dispatch_label
);
1843 add_reg_br_prob_note (get_insns (), REG_BR_PROB_BASE
/100);
1846 expand_builtin_setjmp_setup (plus_constant (XEXP (fc
, 0), sjlj_fc_jbuf_ofs
),
1850 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
1851 1, XEXP (fc
, 0), Pmode
);
1856 /* ??? Instead of doing this at the beginning of the function,
1857 do this in a block that is at loop level 0 and dominates all
1858 can_throw_internal instructions. */
1860 fn_begin_outside_block
= true;
1861 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
1862 if (NOTE_P (fn_begin
))
1864 if (NOTE_KIND (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
1866 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin
))
1867 fn_begin_outside_block
= false;
1870 if (fn_begin_outside_block
)
1871 insert_insn_on_edge (seq
, single_succ_edge (ENTRY_BLOCK_PTR
));
1873 emit_insn_after (seq
, fn_begin
);
1876 /* Call back from expand_function_end to know where we should put
1877 the call to unwind_sjlj_unregister_libfunc if needed. */
1880 sjlj_emit_function_exit_after (rtx after
)
1882 crtl
->eh
.sjlj_exit_after
= after
;
1886 sjlj_emit_function_exit (void)
1894 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
1895 1, XEXP (crtl
->eh
.sjlj_fc
, 0), Pmode
);
1900 /* ??? Really this can be done in any block at loop level 0 that
1901 post-dominates all can_throw_internal instructions. This is
1902 the last possible moment. */
1904 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
1905 if (e
->flags
& EDGE_FALLTHRU
)
1911 /* Figure out whether the place we are supposed to insert libcall
1912 is inside the last basic block or after it. In the other case
1913 we need to emit to edge. */
1914 gcc_assert (e
->src
->next_bb
== EXIT_BLOCK_PTR
);
1915 for (insn
= BB_HEAD (e
->src
); ; insn
= NEXT_INSN (insn
))
1917 if (insn
== crtl
->eh
.sjlj_exit_after
)
1920 insn
= NEXT_INSN (insn
);
1921 emit_insn_after (seq
, insn
);
1924 if (insn
== BB_END (e
->src
))
1927 insert_insn_on_edge (seq
, e
);
1932 sjlj_emit_dispatch_table (rtx dispatch_label
, struct sjlj_lp_info
*lp_info
)
1934 int i
, first_reachable
;
1935 rtx mem
, dispatch
, seq
, fc
;
1940 fc
= crtl
->eh
.sjlj_fc
;
1944 emit_label (dispatch_label
);
1946 #ifndef DONT_USE_BUILTIN_SETJMP
1947 expand_builtin_setjmp_receiver (dispatch_label
);
1950 /* Load up dispatch index, exc_ptr and filter values from the
1951 function context. */
1952 mem
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
1953 sjlj_fc_call_site_ofs
);
1954 dispatch
= copy_to_reg (mem
);
1956 mem
= adjust_address (fc
, word_mode
, sjlj_fc_data_ofs
);
1957 if (word_mode
!= ptr_mode
)
1959 #ifdef POINTERS_EXTEND_UNSIGNED
1960 mem
= convert_memory_address (ptr_mode
, mem
);
1962 mem
= convert_to_mode (ptr_mode
, mem
, 0);
1965 emit_move_insn (crtl
->eh
.exc_ptr
, mem
);
1967 mem
= adjust_address (fc
, word_mode
, sjlj_fc_data_ofs
+ UNITS_PER_WORD
);
1968 emit_move_insn (crtl
->eh
.filter
, mem
);
1970 /* Jump to one of the directly reachable regions. */
1971 /* ??? This really ought to be using a switch statement. */
1973 first_reachable
= 0;
1974 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1976 if (! lp_info
[i
].directly_reachable
)
1979 if (! first_reachable
)
1981 first_reachable
= i
;
1985 emit_cmp_and_jump_insns (dispatch
, GEN_INT (lp_info
[i
].dispatch_index
),
1986 EQ
, NULL_RTX
, TYPE_MODE (integer_type_node
), 0,
1987 ((struct eh_region
*)VEC_index (eh_region
, cfun
->eh
->region_array
, i
))
1988 ->post_landing_pad
);
1994 before
= (((struct eh_region
*)VEC_index (eh_region
, cfun
->eh
->region_array
, first_reachable
))
1995 ->post_landing_pad
);
1997 bb
= emit_to_new_bb_before (seq
, before
);
1998 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1999 e
->count
= bb
->count
;
2000 e
->probability
= REG_BR_PROB_BASE
;
2004 sjlj_build_landing_pads (void)
2006 struct sjlj_lp_info
*lp_info
;
2008 lp_info
= XCNEWVEC (struct sjlj_lp_info
, cfun
->eh
->last_region_number
+ 1);
2010 if (sjlj_find_directly_reachable_regions (lp_info
))
2012 rtx dispatch_label
= gen_label_rtx ();
2015 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
2016 int_size_in_bytes (sjlj_fc_type_node
),
2017 TYPE_ALIGN (sjlj_fc_type_node
));
2019 sjlj_assign_call_site_values (dispatch_label
, lp_info
);
2020 sjlj_mark_call_sites (lp_info
);
2022 sjlj_emit_function_enter (dispatch_label
);
2023 sjlj_emit_dispatch_table (dispatch_label
, lp_info
);
2024 sjlj_emit_function_exit ();
2031 finish_eh_generation (void)
2035 /* Nothing to do if no regions created. */
2036 if (cfun
->eh
->region_tree
== NULL
)
2039 /* The object here is to provide find_basic_blocks with detailed
2040 information (via reachable_handlers) on how exception control
2041 flows within the function. In this first pass, we can include
2042 type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS
2043 regions, and hope that it will be useful in deleting unreachable
2044 handlers. Subsequently, we will generate landing pads which will
2045 connect many of the handlers, and then type information will not
2046 be effective. Still, this is a win over previous implementations. */
2048 /* These registers are used by the landing pads. Make sure they
2049 have been generated. */
2050 get_exception_pointer ();
2051 get_exception_filter ();
2053 /* Construct the landing pads. */
2055 assign_filter_values ();
2056 build_post_landing_pads ();
2057 connect_post_landing_pads ();
2058 if (USING_SJLJ_EXCEPTIONS
)
2059 sjlj_build_landing_pads ();
2061 dw2_build_landing_pads ();
2063 crtl
->eh
.built_landing_pads
= 1;
2065 /* We've totally changed the CFG. Start over. */
2066 find_exception_handler_labels ();
2067 break_superblocks ();
2068 if (USING_SJLJ_EXCEPTIONS
2069 /* Kludge for Alpha/Tru64 (see alpha_gp_save_rtx). */
2070 || single_succ_edge (ENTRY_BLOCK_PTR
)->insns
.r
)
2071 commit_edge_insertions ();
2077 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
2079 if (e
->flags
& EDGE_EH
)
2088 rtl_make_eh_edge (NULL
, bb
, BB_END (bb
));
2093 ehl_hash (const void *pentry
)
2095 const struct ehl_map_entry
*const entry
2096 = (const struct ehl_map_entry
*) pentry
;
2098 /* 2^32 * ((sqrt(5) - 1) / 2) */
2099 const hashval_t scaled_golden_ratio
= 0x9e3779b9;
2100 return CODE_LABEL_NUMBER (entry
->label
) * scaled_golden_ratio
;
2104 ehl_eq (const void *pentry
, const void *pdata
)
2106 const struct ehl_map_entry
*const entry
2107 = (const struct ehl_map_entry
*) pentry
;
2108 const struct ehl_map_entry
*const data
2109 = (const struct ehl_map_entry
*) pdata
;
2111 return entry
->label
== data
->label
;
2114 /* This section handles removing dead code for flow. */
2116 /* Remove LABEL from exception_handler_label_map. */
2119 remove_exception_handler_label (rtx label
)
2121 struct ehl_map_entry
**slot
, tmp
;
2123 /* If exception_handler_label_map was not built yet,
2124 there is nothing to do. */
2125 if (crtl
->eh
.exception_handler_label_map
== NULL
)
2129 slot
= (struct ehl_map_entry
**)
2130 htab_find_slot (crtl
->eh
.exception_handler_label_map
, &tmp
, NO_INSERT
);
2133 htab_clear_slot (crtl
->eh
.exception_handler_label_map
, (void **) slot
);
2136 /* Splice REGION from the region tree etc. */
2139 remove_eh_handler (struct eh_region
*region
)
2141 struct eh_region
**pp
, **pp_start
, *p
, *outer
, *inner
;
2144 /* For the benefit of efficiently handling REG_EH_REGION notes,
2145 replace this region in the region array with its containing
2146 region. Note that previous region deletions may result in
2147 multiple copies of this region in the array, so we have a
2148 list of alternate numbers by which we are known. */
2150 outer
= region
->outer
;
2151 VEC_replace (eh_region
, cfun
->eh
->region_array
, region
->region_number
, outer
);
2157 EXECUTE_IF_SET_IN_BITMAP (region
->aka
, 0, i
, bi
)
2159 VEC_replace (eh_region
, cfun
->eh
->region_array
, i
, outer
);
2166 outer
->aka
= BITMAP_GGC_ALLOC ();
2168 bitmap_ior_into (outer
->aka
, region
->aka
);
2169 bitmap_set_bit (outer
->aka
, region
->region_number
);
2172 if (crtl
->eh
.built_landing_pads
)
2173 lab
= region
->landing_pad
;
2175 lab
= region
->label
;
2177 remove_exception_handler_label (lab
);
2180 pp_start
= &outer
->inner
;
2182 pp_start
= &cfun
->eh
->region_tree
;
2183 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
2185 *pp
= region
->next_peer
;
2187 inner
= region
->inner
;
2190 for (p
= inner
; p
->next_peer
; p
= p
->next_peer
)
2194 p
->next_peer
= *pp_start
;
2198 if (region
->type
== ERT_CATCH
)
2200 struct eh_region
*try, *next
, *prev
;
2202 for (try = region
->next_peer
;
2203 try->type
== ERT_CATCH
;
2204 try = try->next_peer
)
2206 gcc_assert (try->type
== ERT_TRY
);
2208 next
= region
->u
.catch.next_catch
;
2209 prev
= region
->u
.catch.prev_catch
;
2212 next
->u
.catch.prev_catch
= prev
;
2214 try->u
.try.last_catch
= prev
;
2216 prev
->u
.catch.next_catch
= next
;
2219 try->u
.try.catch = next
;
2221 remove_eh_handler (try);
2226 /* LABEL heads a basic block that is about to be deleted. If this
2227 label corresponds to an exception region, we may be able to
2228 delete the region. */
2231 maybe_remove_eh_handler (rtx label
)
2233 struct ehl_map_entry
**slot
, tmp
;
2234 struct eh_region
*region
;
2236 /* ??? After generating landing pads, it's not so simple to determine
2237 if the region data is completely unused. One must examine the
2238 landing pad and the post landing pad, and whether an inner try block
2239 is referencing the catch handlers directly. */
2240 if (crtl
->eh
.built_landing_pads
)
2244 slot
= (struct ehl_map_entry
**)
2245 htab_find_slot (crtl
->eh
.exception_handler_label_map
, &tmp
, NO_INSERT
);
2248 region
= (*slot
)->region
;
2252 /* Flow will want to remove MUST_NOT_THROW regions as unreachable
2253 because there is no path to the fallback call to terminate.
2254 But the region continues to affect call-site data until there
2255 are no more contained calls, which we don't see here. */
2256 if (region
->type
== ERT_MUST_NOT_THROW
)
2258 htab_clear_slot (crtl
->eh
.exception_handler_label_map
, (void **) slot
);
2259 region
->label
= NULL_RTX
;
2262 remove_eh_handler (region
);
2265 /* Invokes CALLBACK for every exception handler label. Only used by old
2266 loop hackery; should not be used by new code. */
2269 for_each_eh_label (void (*callback
) (rtx
))
2271 htab_traverse (crtl
->eh
.exception_handler_label_map
, for_each_eh_label_1
,
2272 (void *) &callback
);
2276 for_each_eh_label_1 (void **pentry
, void *data
)
2278 struct ehl_map_entry
*entry
= *(struct ehl_map_entry
**)pentry
;
2279 void (*callback
) (rtx
) = *(void (**) (rtx
)) data
;
2281 (*callback
) (entry
->label
);
2285 /* Invoke CALLBACK for every exception region in the current function. */
2288 for_each_eh_region (void (*callback
) (struct eh_region
*))
2290 int i
, n
= cfun
->eh
->last_region_number
;
2291 for (i
= 1; i
<= n
; ++i
)
2293 struct eh_region
*region
;
2295 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, i
);
2297 (*callback
) (region
);
2301 /* This section describes CFG exception edges for flow. */
2303 /* For communicating between calls to reachable_next_level. */
2304 struct reachable_info
2308 void (*callback
) (struct eh_region
*, void *);
2309 void *callback_data
;
2310 bool saw_any_handlers
;
2313 /* A subroutine of reachable_next_level. Return true if TYPE, or a
2314 base class of TYPE, is in HANDLED. */
2317 check_handled (tree handled
, tree type
)
2321 /* We can check for exact matches without front-end help. */
2322 if (! lang_eh_type_covers
)
2324 for (t
= handled
; t
; t
= TREE_CHAIN (t
))
2325 if (TREE_VALUE (t
) == type
)
2330 for (t
= handled
; t
; t
= TREE_CHAIN (t
))
2331 if ((*lang_eh_type_covers
) (TREE_VALUE (t
), type
))
2338 /* A subroutine of reachable_next_level. If we are collecting a list
2339 of handlers, add one. After landing pad generation, reference
2340 it instead of the handlers themselves. Further, the handlers are
2341 all wired together, so by referencing one, we've got them all.
2342 Before landing pad generation we reference each handler individually.
2344 LP_REGION contains the landing pad; REGION is the handler. */
2347 add_reachable_handler (struct reachable_info
*info
,
2348 struct eh_region
*lp_region
, struct eh_region
*region
)
2353 info
->saw_any_handlers
= true;
2355 if (crtl
->eh
.built_landing_pads
)
2356 info
->callback (lp_region
, info
->callback_data
);
2358 info
->callback (region
, info
->callback_data
);
2361 /* Process one level of exception regions for reachability.
2362 If TYPE_THROWN is non-null, then it is the *exact* type being
2363 propagated. If INFO is non-null, then collect handler labels
2364 and caught/allowed type information between invocations. */
2366 static enum reachable_code
2367 reachable_next_level (struct eh_region
*region
, tree type_thrown
,
2368 struct reachable_info
*info
)
2370 switch (region
->type
)
2373 /* Before landing-pad generation, we model control flow
2374 directly to the individual handlers. In this way we can
2375 see that catch handler types may shadow one another. */
2376 add_reachable_handler (info
, region
, region
);
2377 return RNL_MAYBE_CAUGHT
;
2381 struct eh_region
*c
;
2382 enum reachable_code ret
= RNL_NOT_CAUGHT
;
2384 for (c
= region
->u
.try.catch; c
; c
= c
->u
.catch.next_catch
)
2386 /* A catch-all handler ends the search. */
2387 if (c
->u
.catch.type_list
== NULL
)
2389 add_reachable_handler (info
, region
, c
);
2395 /* If we have at least one type match, end the search. */
2396 tree tp_node
= c
->u
.catch.type_list
;
2398 for (; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
2400 tree type
= TREE_VALUE (tp_node
);
2402 if (type
== type_thrown
2403 || (lang_eh_type_covers
2404 && (*lang_eh_type_covers
) (type
, type_thrown
)))
2406 add_reachable_handler (info
, region
, c
);
2411 /* If we have definitive information of a match failure,
2412 the catch won't trigger. */
2413 if (lang_eh_type_covers
)
2414 return RNL_NOT_CAUGHT
;
2417 /* At this point, we either don't know what type is thrown or
2418 don't have front-end assistance to help deciding if it is
2419 covered by one of the types in the list for this region.
2421 We'd then like to add this region to the list of reachable
2422 handlers since it is indeed potentially reachable based on the
2423 information we have.
2425 Actually, this handler is for sure not reachable if all the
2426 types it matches have already been caught. That is, it is only
2427 potentially reachable if at least one of the types it catches
2428 has not been previously caught. */
2431 ret
= RNL_MAYBE_CAUGHT
;
2434 tree tp_node
= c
->u
.catch.type_list
;
2435 bool maybe_reachable
= false;
2437 /* Compute the potential reachability of this handler and
2438 update the list of types caught at the same time. */
2439 for (; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
2441 tree type
= TREE_VALUE (tp_node
);
2443 if (! check_handled (info
->types_caught
, type
))
2446 = tree_cons (NULL
, type
, info
->types_caught
);
2448 maybe_reachable
= true;
2452 if (maybe_reachable
)
2454 add_reachable_handler (info
, region
, c
);
2456 /* ??? If the catch type is a base class of every allowed
2457 type, then we know we can stop the search. */
2458 ret
= RNL_MAYBE_CAUGHT
;
2466 case ERT_ALLOWED_EXCEPTIONS
:
2467 /* An empty list of types definitely ends the search. */
2468 if (region
->u
.allowed
.type_list
== NULL_TREE
)
2470 add_reachable_handler (info
, region
, region
);
2474 /* Collect a list of lists of allowed types for use in detecting
2475 when a catch may be transformed into a catch-all. */
2477 info
->types_allowed
= tree_cons (NULL_TREE
,
2478 region
->u
.allowed
.type_list
,
2479 info
->types_allowed
);
2481 /* If we have definitive information about the type hierarchy,
2482 then we can tell if the thrown type will pass through the
2484 if (type_thrown
&& lang_eh_type_covers
)
2486 if (check_handled (region
->u
.allowed
.type_list
, type_thrown
))
2487 return RNL_NOT_CAUGHT
;
2490 add_reachable_handler (info
, region
, region
);
2495 add_reachable_handler (info
, region
, region
);
2496 return RNL_MAYBE_CAUGHT
;
2499 /* Catch regions are handled by their controlling try region. */
2500 return RNL_NOT_CAUGHT
;
2502 case ERT_MUST_NOT_THROW
:
2503 /* Here we end our search, since no exceptions may propagate.
2504 If we've touched down at some landing pad previous, then the
2505 explicit function call we generated may be used. Otherwise
2506 the call is made by the runtime.
2508 Before inlining, do not perform this optimization. We may
2509 inline a subroutine that contains handlers, and that will
2510 change the value of saw_any_handlers. */
2512 if ((info
&& info
->saw_any_handlers
) || !cfun
->after_inlining
)
2514 add_reachable_handler (info
, region
, region
);
2522 /* Shouldn't see these here. */
2530 /* Invoke CALLBACK on each region reachable from REGION_NUMBER. */
2533 foreach_reachable_handler (int region_number
, bool is_resx
,
2534 void (*callback
) (struct eh_region
*, void *),
2535 void *callback_data
)
2537 struct reachable_info info
;
2538 struct eh_region
*region
;
2541 memset (&info
, 0, sizeof (info
));
2542 info
.callback
= callback
;
2543 info
.callback_data
= callback_data
;
2545 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, region_number
);
2547 type_thrown
= NULL_TREE
;
2550 /* A RESX leaves a region instead of entering it. Thus the
2551 region itself may have been deleted out from under us. */
2554 region
= region
->outer
;
2556 else if (region
->type
== ERT_THROW
)
2558 type_thrown
= region
->u
.throw.type
;
2559 region
= region
->outer
;
2564 if (reachable_next_level (region
, type_thrown
, &info
) >= RNL_CAUGHT
)
2566 /* If we have processed one cleanup, there is no point in
2567 processing any more of them. Each cleanup will have an edge
2568 to the next outer cleanup region, so the flow graph will be
2570 if (region
->type
== ERT_CLEANUP
)
2571 region
= region
->u
.cleanup
.prev_try
;
2573 region
= region
->outer
;
2577 /* Retrieve a list of labels of exception handlers which can be
2578 reached by a given insn. */
2581 arh_to_landing_pad (struct eh_region
*region
, void *data
)
2583 rtx
*p_handlers
= data
;
2585 *p_handlers
= alloc_INSN_LIST (region
->landing_pad
, NULL_RTX
);
2589 arh_to_label (struct eh_region
*region
, void *data
)
2591 rtx
*p_handlers
= data
;
2592 *p_handlers
= alloc_INSN_LIST (region
->label
, *p_handlers
);
2596 reachable_handlers (rtx insn
)
2598 bool is_resx
= false;
2599 rtx handlers
= NULL
;
2603 && GET_CODE (PATTERN (insn
)) == RESX
)
2605 region_number
= XINT (PATTERN (insn
), 0);
2610 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2611 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
2613 region_number
= INTVAL (XEXP (note
, 0));
2616 foreach_reachable_handler (region_number
, is_resx
,
2617 (crtl
->eh
.built_landing_pads
2618 ? arh_to_landing_pad
2625 /* Determine if the given INSN can throw an exception that is caught
2626 within the function. */
2629 can_throw_internal_1 (int region_number
, bool is_resx
)
2631 struct eh_region
*region
;
2634 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, region_number
);
2636 type_thrown
= NULL_TREE
;
2638 region
= region
->outer
;
2639 else if (region
->type
== ERT_THROW
)
2641 type_thrown
= region
->u
.throw.type
;
2642 region
= region
->outer
;
2645 /* If this exception is ignored by each and every containing region,
2646 then control passes straight out. The runtime may handle some
2647 regions, which also do not require processing internally. */
2648 for (; region
; region
= region
->outer
)
2650 enum reachable_code how
= reachable_next_level (region
, type_thrown
, 0);
2651 if (how
== RNL_BLOCKED
)
2653 if (how
!= RNL_NOT_CAUGHT
)
2661 can_throw_internal (const_rtx insn
)
2665 if (! INSN_P (insn
))
2669 && GET_CODE (PATTERN (insn
)) == RESX
2670 && XINT (PATTERN (insn
), 0) > 0)
2671 return can_throw_internal_1 (XINT (PATTERN (insn
), 0), true);
2673 if (NONJUMP_INSN_P (insn
)
2674 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2675 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2677 /* Every insn that might throw has an EH_REGION note. */
2678 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2679 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
2682 return can_throw_internal_1 (INTVAL (XEXP (note
, 0)), false);
2685 /* Determine if the given INSN can throw an exception that is
2686 visible outside the function. */
2689 can_throw_external_1 (int region_number
, bool is_resx
)
2691 struct eh_region
*region
;
2694 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, region_number
);
2696 type_thrown
= NULL_TREE
;
2698 region
= region
->outer
;
2699 else if (region
->type
== ERT_THROW
)
2701 type_thrown
= region
->u
.throw.type
;
2702 region
= region
->outer
;
2705 /* If the exception is caught or blocked by any containing region,
2706 then it is not seen by any calling function. */
2707 for (; region
; region
= region
->outer
)
2708 if (reachable_next_level (region
, type_thrown
, NULL
) >= RNL_CAUGHT
)
2715 can_throw_external (const_rtx insn
)
2719 if (! INSN_P (insn
))
2723 && GET_CODE (PATTERN (insn
)) == RESX
2724 && XINT (PATTERN (insn
), 0) > 0)
2725 return can_throw_external_1 (XINT (PATTERN (insn
), 0), true);
2727 if (NONJUMP_INSN_P (insn
)
2728 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2729 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2731 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2734 /* Calls (and trapping insns) without notes are outside any
2735 exception handling region in this function. We have to
2736 assume it might throw. Given that the front end and middle
2737 ends mark known NOTHROW functions, this isn't so wildly
2739 return (CALL_P (insn
)
2740 || (flag_non_call_exceptions
2741 && may_trap_p (PATTERN (insn
))));
2743 if (INTVAL (XEXP (note
, 0)) <= 0)
2746 return can_throw_external_1 (INTVAL (XEXP (note
, 0)), false);
2749 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
2752 set_nothrow_function_flags (void)
2756 /* If we don't know that this implementation of the function will
2757 actually be used, then we must not set TREE_NOTHROW, since
2758 callers must not assume that this function does not throw. */
2759 if (DECL_REPLACEABLE_P (current_function_decl
))
2762 TREE_NOTHROW (current_function_decl
) = 1;
2764 /* Assume crtl->all_throwers_are_sibcalls until we encounter
2765 something that can throw an exception. We specifically exempt
2766 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
2767 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
2770 crtl
->all_throwers_are_sibcalls
= 1;
2772 if (! flag_exceptions
)
2775 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
2776 if (can_throw_external (insn
))
2778 TREE_NOTHROW (current_function_decl
) = 0;
2780 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
2782 crtl
->all_throwers_are_sibcalls
= 0;
2787 for (insn
= crtl
->epilogue_delay_list
; insn
;
2788 insn
= XEXP (insn
, 1))
2789 if (can_throw_external (insn
))
2791 TREE_NOTHROW (current_function_decl
) = 0;
2793 if (!CALL_P (insn
) || !SIBLING_CALL_P (insn
))
2795 crtl
->all_throwers_are_sibcalls
= 0;
2802 struct rtl_opt_pass pass_set_nothrow_function_flags
=
2808 set_nothrow_function_flags
, /* execute */
2811 0, /* static_pass_number */
2813 0, /* properties_required */
2814 0, /* properties_provided */
2815 0, /* properties_destroyed */
2816 0, /* todo_flags_start */
2817 0, /* todo_flags_finish */
2822 /* Various hooks for unwind library. */
2824 /* Do any necessary initialization to access arbitrary stack frames.
2825 On the SPARC, this means flushing the register windows. */
2828 expand_builtin_unwind_init (void)
2830 /* Set this so all the registers get saved in our frame; we need to be
2831 able to copy the saved values for any registers from frames we unwind. */
2832 crtl
->saves_all_registers
= 1;
2834 #ifdef SETUP_FRAME_ADDRESSES
2835 SETUP_FRAME_ADDRESSES ();
2840 expand_builtin_eh_return_data_regno (tree exp
)
2842 tree which
= CALL_EXPR_ARG (exp
, 0);
2843 unsigned HOST_WIDE_INT iwhich
;
2845 if (TREE_CODE (which
) != INTEGER_CST
)
2847 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2851 iwhich
= tree_low_cst (which
, 1);
2852 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
2853 if (iwhich
== INVALID_REGNUM
)
2856 #ifdef DWARF_FRAME_REGNUM
2857 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
2859 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
2862 return GEN_INT (iwhich
);
2865 /* Given a value extracted from the return address register or stack slot,
2866 return the actual address encoded in that value. */
2869 expand_builtin_extract_return_addr (tree addr_tree
)
2871 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, EXPAND_NORMAL
);
2873 if (GET_MODE (addr
) != Pmode
2874 && GET_MODE (addr
) != VOIDmode
)
2876 #ifdef POINTERS_EXTEND_UNSIGNED
2877 addr
= convert_memory_address (Pmode
, addr
);
2879 addr
= convert_to_mode (Pmode
, addr
, 0);
2883 /* First mask out any unwanted bits. */
2884 #ifdef MASK_RETURN_ADDR
2885 expand_and (Pmode
, addr
, MASK_RETURN_ADDR
, addr
);
2888 /* Then adjust to find the real return address. */
2889 #if defined (RETURN_ADDR_OFFSET)
2890 addr
= plus_constant (addr
, RETURN_ADDR_OFFSET
);
2896 /* Given an actual address in addr_tree, do any necessary encoding
2897 and return the value to be stored in the return address register or
2898 stack slot so the epilogue will return to that address. */
2901 expand_builtin_frob_return_addr (tree addr_tree
)
2903 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2905 addr
= convert_memory_address (Pmode
, addr
);
2907 #ifdef RETURN_ADDR_OFFSET
2908 addr
= force_reg (Pmode
, addr
);
2909 addr
= plus_constant (addr
, -RETURN_ADDR_OFFSET
);
2915 /* Set up the epilogue with the magic bits we'll need to return to the
2916 exception handler. */
2919 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
2924 #ifdef EH_RETURN_STACKADJ_RTX
2925 tmp
= expand_expr (stackadj_tree
, crtl
->eh
.ehr_stackadj
,
2926 VOIDmode
, EXPAND_NORMAL
);
2927 tmp
= convert_memory_address (Pmode
, tmp
);
2928 if (!crtl
->eh
.ehr_stackadj
)
2929 crtl
->eh
.ehr_stackadj
= copy_to_reg (tmp
);
2930 else if (tmp
!= crtl
->eh
.ehr_stackadj
)
2931 emit_move_insn (crtl
->eh
.ehr_stackadj
, tmp
);
2934 tmp
= expand_expr (handler_tree
, crtl
->eh
.ehr_handler
,
2935 VOIDmode
, EXPAND_NORMAL
);
2936 tmp
= convert_memory_address (Pmode
, tmp
);
2937 if (!crtl
->eh
.ehr_handler
)
2938 crtl
->eh
.ehr_handler
= copy_to_reg (tmp
);
2939 else if (tmp
!= crtl
->eh
.ehr_handler
)
2940 emit_move_insn (crtl
->eh
.ehr_handler
, tmp
);
2942 if (!crtl
->eh
.ehr_label
)
2943 crtl
->eh
.ehr_label
= gen_label_rtx ();
2944 emit_jump (crtl
->eh
.ehr_label
);
2948 expand_eh_return (void)
2952 if (! crtl
->eh
.ehr_label
)
2955 crtl
->calls_eh_return
= 1;
2957 #ifdef EH_RETURN_STACKADJ_RTX
2958 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
2961 around_label
= gen_label_rtx ();
2962 emit_jump (around_label
);
2964 emit_label (crtl
->eh
.ehr_label
);
2965 clobber_return_register ();
2967 #ifdef EH_RETURN_STACKADJ_RTX
2968 emit_move_insn (EH_RETURN_STACKADJ_RTX
, crtl
->eh
.ehr_stackadj
);
2971 #ifdef HAVE_eh_return
2973 emit_insn (gen_eh_return (crtl
->eh
.ehr_handler
));
2977 #ifdef EH_RETURN_HANDLER_RTX
2978 emit_move_insn (EH_RETURN_HANDLER_RTX
, crtl
->eh
.ehr_handler
);
2980 error ("__builtin_eh_return not supported on this target");
2984 emit_label (around_label
);
2987 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2988 POINTERS_EXTEND_UNSIGNED and return it. */
2991 expand_builtin_extend_pointer (tree addr_tree
)
2993 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, EXPAND_NORMAL
);
2996 #ifdef POINTERS_EXTEND_UNSIGNED
2997 extend
= POINTERS_EXTEND_UNSIGNED
;
2999 /* The previous EH code did an unsigned extend by default, so we do this also
3004 return convert_modes (word_mode
, ptr_mode
, addr
, extend
);
3007 /* In the following functions, we represent entries in the action table
3008 as 1-based indices. Special cases are:
3010 0: null action record, non-null landing pad; implies cleanups
3011 -1: null action record, null landing pad; implies no action
3012 -2: no call-site entry; implies must_not_throw
3013 -3: we have yet to process outer regions
3015 Further, no special cases apply to the "next" field of the record.
3016 For next, 0 means end of list. */
3018 struct action_record
3026 action_record_eq (const void *pentry
, const void *pdata
)
3028 const struct action_record
*entry
= (const struct action_record
*) pentry
;
3029 const struct action_record
*data
= (const struct action_record
*) pdata
;
3030 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
3034 action_record_hash (const void *pentry
)
3036 const struct action_record
*entry
= (const struct action_record
*) pentry
;
3037 return entry
->next
* 1009 + entry
->filter
;
3041 add_action_record (htab_t ar_hash
, int filter
, int next
)
3043 struct action_record
**slot
, *new, tmp
;
3045 tmp
.filter
= filter
;
3047 slot
= (struct action_record
**) htab_find_slot (ar_hash
, &tmp
, INSERT
);
3049 if ((new = *slot
) == NULL
)
3051 new = xmalloc (sizeof (*new));
3052 new->offset
= VARRAY_ACTIVE_SIZE (crtl
->eh
.action_record_data
) + 1;
3053 new->filter
= filter
;
3057 /* The filter value goes in untouched. The link to the next
3058 record is a "self-relative" byte offset, or zero to indicate
3059 that there is no next record. So convert the absolute 1 based
3060 indices we've been carrying around into a displacement. */
3062 push_sleb128 (&crtl
->eh
.action_record_data
, filter
);
3064 next
-= VARRAY_ACTIVE_SIZE (crtl
->eh
.action_record_data
) + 1;
3065 push_sleb128 (&crtl
->eh
.action_record_data
, next
);
3072 collect_one_action_chain (htab_t ar_hash
, struct eh_region
*region
)
3074 struct eh_region
*c
;
3077 /* If we've reached the top of the region chain, then we have
3078 no actions, and require no landing pad. */
3082 switch (region
->type
)
3085 /* A cleanup adds a zero filter to the beginning of the chain, but
3086 there are special cases to look out for. If there are *only*
3087 cleanups along a path, then it compresses to a zero action.
3088 Further, if there are multiple cleanups along a path, we only
3089 need to represent one of them, as that is enough to trigger
3090 entry to the landing pad at runtime. */
3091 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3094 for (c
= region
->outer
; c
; c
= c
->outer
)
3095 if (c
->type
== ERT_CLEANUP
)
3097 return add_action_record (ar_hash
, 0, next
);
3100 /* Process the associated catch regions in reverse order.
3101 If there's a catch-all handler, then we don't need to
3102 search outer regions. Use a magic -3 value to record
3103 that we haven't done the outer search. */
3105 for (c
= region
->u
.try.last_catch
; c
; c
= c
->u
.catch.prev_catch
)
3107 if (c
->u
.catch.type_list
== NULL
)
3109 /* Retrieve the filter from the head of the filter list
3110 where we have stored it (see assign_filter_values). */
3112 = TREE_INT_CST_LOW (TREE_VALUE (c
->u
.catch.filter_list
));
3114 next
= add_action_record (ar_hash
, filter
, 0);
3118 /* Once the outer search is done, trigger an action record for
3119 each filter we have. */
3124 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3126 /* If there is no next action, terminate the chain. */
3129 /* If all outer actions are cleanups or must_not_throw,
3130 we'll have no action record for it, since we had wanted
3131 to encode these states in the call-site record directly.
3132 Add a cleanup action to the chain to catch these. */
3134 next
= add_action_record (ar_hash
, 0, 0);
3137 flt_node
= c
->u
.catch.filter_list
;
3138 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
3140 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
3141 next
= add_action_record (ar_hash
, filter
, next
);
3147 case ERT_ALLOWED_EXCEPTIONS
:
3148 /* An exception specification adds its filter to the
3149 beginning of the chain. */
3150 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3152 /* If there is no next action, terminate the chain. */
3155 /* If all outer actions are cleanups or must_not_throw,
3156 we'll have no action record for it, since we had wanted
3157 to encode these states in the call-site record directly.
3158 Add a cleanup action to the chain to catch these. */
3160 next
= add_action_record (ar_hash
, 0, 0);
3162 return add_action_record (ar_hash
, region
->u
.allowed
.filter
, next
);
3164 case ERT_MUST_NOT_THROW
:
3165 /* A must-not-throw region with no inner handlers or cleanups
3166 requires no call-site entry. Note that this differs from
3167 the no handler or cleanup case in that we do require an lsda
3168 to be generated. Return a magic -2 value to record this. */
3173 /* CATCH regions are handled in TRY above. THROW regions are
3174 for optimization information only and produce no output. */
3175 return collect_one_action_chain (ar_hash
, region
->outer
);
3183 add_call_site (rtx landing_pad
, int action
)
3185 call_site_record record
;
3187 record
= ggc_alloc (sizeof (struct call_site_record
));
3188 record
->landing_pad
= landing_pad
;
3189 record
->action
= action
;
3191 VEC_safe_push (call_site_record
, gc
, crtl
->eh
.call_site_record
, record
);
3193 return call_site_base
+ VEC_length (call_site_record
, crtl
->eh
.call_site_record
) - 1;
3196 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
3197 The new note numbers will not refer to region numbers, but
3198 instead to call site entries. */
3201 convert_to_eh_region_ranges (void)
3203 rtx insn
, iter
, note
;
3205 int last_action
= -3;
3206 rtx last_action_insn
= NULL_RTX
;
3207 rtx last_landing_pad
= NULL_RTX
;
3208 rtx first_no_action_insn
= NULL_RTX
;
3211 if (USING_SJLJ_EXCEPTIONS
|| cfun
->eh
->region_tree
== NULL
)
3214 VARRAY_UCHAR_INIT (crtl
->eh
.action_record_data
, 64, "action_record_data");
3216 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
3218 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
3221 struct eh_region
*region
;
3223 rtx this_landing_pad
;
3226 if (NONJUMP_INSN_P (insn
)
3227 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
3228 insn
= XVECEXP (PATTERN (insn
), 0, 0);
3230 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
3233 if (! (CALL_P (insn
)
3234 || (flag_non_call_exceptions
3235 && may_trap_p (PATTERN (insn
)))))
3242 if (INTVAL (XEXP (note
, 0)) <= 0)
3244 region
= VEC_index (eh_region
, cfun
->eh
->region_array
, INTVAL (XEXP (note
, 0)));
3245 this_action
= collect_one_action_chain (ar_hash
, region
);
3248 /* Existence of catch handlers, or must-not-throw regions
3249 implies that an lsda is needed (even if empty). */
3250 if (this_action
!= -1)
3251 crtl
->uses_eh_lsda
= 1;
3253 /* Delay creation of region notes for no-action regions
3254 until we're sure that an lsda will be required. */
3255 else if (last_action
== -3)
3257 first_no_action_insn
= iter
;
3261 /* Cleanups and handlers may share action chains but not
3262 landing pads. Collect the landing pad for this region. */
3263 if (this_action
>= 0)
3265 struct eh_region
*o
;
3266 for (o
= region
; ! o
->landing_pad
; o
= o
->outer
)
3268 this_landing_pad
= o
->landing_pad
;
3271 this_landing_pad
= NULL_RTX
;
3273 /* Differing actions or landing pads implies a change in call-site
3274 info, which implies some EH_REGION note should be emitted. */
3275 if (last_action
!= this_action
3276 || last_landing_pad
!= this_landing_pad
)
3278 /* If we'd not seen a previous action (-3) or the previous
3279 action was must-not-throw (-2), then we do not need an
3281 if (last_action
>= -1)
3283 /* If we delayed the creation of the begin, do it now. */
3284 if (first_no_action_insn
)
3286 call_site
= add_call_site (NULL_RTX
, 0);
3287 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
3288 first_no_action_insn
);
3289 NOTE_EH_HANDLER (note
) = call_site
;
3290 first_no_action_insn
= NULL_RTX
;
3293 note
= emit_note_after (NOTE_INSN_EH_REGION_END
,
3295 NOTE_EH_HANDLER (note
) = call_site
;
3298 /* If the new action is must-not-throw, then no region notes
3300 if (this_action
>= -1)
3302 call_site
= add_call_site (this_landing_pad
,
3303 this_action
< 0 ? 0 : this_action
);
3304 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
3305 NOTE_EH_HANDLER (note
) = call_site
;
3308 last_action
= this_action
;
3309 last_landing_pad
= this_landing_pad
;
3311 last_action_insn
= iter
;
3314 if (last_action
>= -1 && ! first_no_action_insn
)
3316 note
= emit_note_after (NOTE_INSN_EH_REGION_END
, last_action_insn
);
3317 NOTE_EH_HANDLER (note
) = call_site
;
3320 htab_delete (ar_hash
);
3324 struct rtl_opt_pass pass_convert_to_eh_region_ranges
=
3328 "eh-ranges", /* name */
3330 convert_to_eh_region_ranges
, /* execute */
3333 0, /* static_pass_number */
3335 0, /* properties_required */
3336 0, /* properties_provided */
3337 0, /* properties_destroyed */
3338 0, /* todo_flags_start */
3339 TODO_dump_func
, /* todo_flags_finish */
3345 push_uleb128 (varray_type
*data_area
, unsigned int value
)
3349 unsigned char byte
= value
& 0x7f;
3353 VARRAY_PUSH_UCHAR (*data_area
, byte
);
3359 push_sleb128 (varray_type
*data_area
, int value
)
3366 byte
= value
& 0x7f;
3368 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
3369 || (value
== -1 && (byte
& 0x40) != 0));
3372 VARRAY_PUSH_UCHAR (*data_area
, byte
);
3378 #ifndef HAVE_AS_LEB128
3380 dw2_size_of_call_site_table (void)
3382 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
);
3383 int size
= n
* (4 + 4 + 4);
3386 for (i
= 0; i
< n
; ++i
)
3388 struct call_site_record
*cs
= VEC_index (call_site_record
, crtl
->eh
.call_site_record
, i
);
3389 size
+= size_of_uleb128 (cs
->action
);
3396 sjlj_size_of_call_site_table (void)
3398 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
);
3402 for (i
= 0; i
< n
; ++i
)
3404 struct call_site_record
*cs
= VEC_index (call_site_record
, crtl
->eh
.call_site_record
, i
);
3405 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
3406 size
+= size_of_uleb128 (cs
->action
);
3414 dw2_output_call_site_table (void)
3416 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
);
3419 for (i
= 0; i
< n
; ++i
)
3421 struct call_site_record
*cs
= VEC_index (call_site_record
, crtl
->eh
.call_site_record
, i
);
3422 char reg_start_lab
[32];
3423 char reg_end_lab
[32];
3424 char landing_pad_lab
[32];
3426 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
3427 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
3429 if (cs
->landing_pad
)
3430 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
3431 CODE_LABEL_NUMBER (cs
->landing_pad
));
3433 /* ??? Perhaps use insn length scaling if the assembler supports
3434 generic arithmetic. */
3435 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
3436 data4 if the function is small enough. */
3437 #ifdef HAVE_AS_LEB128
3438 dw2_asm_output_delta_uleb128 (reg_start_lab
,
3439 current_function_func_begin_label
,
3440 "region %d start", i
);
3441 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
3443 if (cs
->landing_pad
)
3444 dw2_asm_output_delta_uleb128 (landing_pad_lab
,
3445 current_function_func_begin_label
,
3448 dw2_asm_output_data_uleb128 (0, "landing pad");
3450 dw2_asm_output_delta (4, reg_start_lab
,
3451 current_function_func_begin_label
,
3452 "region %d start", i
);
3453 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
3454 if (cs
->landing_pad
)
3455 dw2_asm_output_delta (4, landing_pad_lab
,
3456 current_function_func_begin_label
,
3459 dw2_asm_output_data (4, 0, "landing pad");
3461 dw2_asm_output_data_uleb128 (cs
->action
, "action");
3464 call_site_base
+= n
;
3468 sjlj_output_call_site_table (void)
3470 int n
= VEC_length (call_site_record
, crtl
->eh
.call_site_record
);
3473 for (i
= 0; i
< n
; ++i
)
3475 struct call_site_record
*cs
= VEC_index (call_site_record
, crtl
->eh
.call_site_record
, i
);
3477 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
3478 "region %d landing pad", i
);
3479 dw2_asm_output_data_uleb128 (cs
->action
, "action");
3482 call_site_base
+= n
;
3485 #ifndef TARGET_UNWIND_INFO
3486 /* Switch to the section that should be used for exception tables. */
3489 switch_to_exception_section (const char * ARG_UNUSED (fnname
))
3493 if (exception_section
)
3494 s
= exception_section
;
3497 /* Compute the section and cache it into exception_section,
3498 unless it depends on the function name. */
3499 if (targetm
.have_named_sections
)
3503 if (EH_TABLES_CAN_BE_READ_ONLY
)
3506 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
3507 flags
= ((! flag_pic
3508 || ((tt_format
& 0x70) != DW_EH_PE_absptr
3509 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
3510 ? 0 : SECTION_WRITE
);
3513 flags
= SECTION_WRITE
;
3515 #ifdef HAVE_LD_EH_GC_SECTIONS
3516 if (flag_function_sections
)
3518 char *section_name
= xmalloc (strlen (fnname
) + 32);
3519 sprintf (section_name
, ".gcc_except_table.%s", fnname
);
3520 s
= get_section (section_name
, flags
, NULL
);
3521 free (section_name
);
3526 = s
= get_section (".gcc_except_table", flags
, NULL
);
3530 = s
= flag_pic
? data_section
: readonly_data_section
;
3533 switch_to_section (s
);
3538 /* Output a reference from an exception table to the type_info object TYPE.
3539 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
3543 output_ttype (tree type
, int tt_format
, int tt_format_size
)
3548 if (type
== NULL_TREE
)
3552 struct varpool_node
*node
;
3554 type
= lookup_type_for_runtime (type
);
3555 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
3557 /* Let cgraph know that the rtti decl is used. Not all of the
3558 paths below go through assemble_integer, which would take
3559 care of this for us. */
3561 if (TREE_CODE (type
) == ADDR_EXPR
)
3563 type
= TREE_OPERAND (type
, 0);
3564 if (TREE_CODE (type
) == VAR_DECL
)
3566 node
= varpool_node (type
);
3568 varpool_mark_needed_node (node
);
3569 public = TREE_PUBLIC (type
);
3573 gcc_assert (TREE_CODE (type
) == INTEGER_CST
);
3576 /* Allow the target to override the type table entry format. */
3577 if (targetm
.asm_out
.ttype (value
))
3580 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
3581 assemble_integer (value
, tt_format_size
,
3582 tt_format_size
* BITS_PER_UNIT
, 1);
3584 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, public, NULL
);
3588 output_function_exception_table (const char * ARG_UNUSED (fnname
))
3590 int tt_format
, cs_format
, lp_format
, i
, n
;
3591 #ifdef HAVE_AS_LEB128
3592 char ttype_label
[32];
3593 char cs_after_size_label
[32];
3594 char cs_end_label
[32];
3599 int tt_format_size
= 0;
3601 /* Not all functions need anything. */
3602 if (! crtl
->uses_eh_lsda
)
3605 if (eh_personality_libfunc
)
3606 assemble_external_libcall (eh_personality_libfunc
);
3608 #ifdef TARGET_UNWIND_INFO
3609 /* TODO: Move this into target file. */
3610 fputs ("\t.personality\t", asm_out_file
);
3611 output_addr_const (asm_out_file
, eh_personality_libfunc
);
3612 fputs ("\n\t.handlerdata\n", asm_out_file
);
3613 /* Note that varasm still thinks we're in the function's code section.
3614 The ".endp" directive that will immediately follow will take us back. */
3616 switch_to_exception_section (fnname
);
3619 /* If the target wants a label to begin the table, emit it here. */
3620 targetm
.asm_out
.except_table_label (asm_out_file
);
3622 have_tt_data
= (VEC_length (tree
, crtl
->eh
.ttype_data
) > 0
3623 || VARRAY_ACTIVE_SIZE (crtl
->eh
.ehspec_data
) > 0);
3625 /* Indicate the format of the @TType entries. */
3627 tt_format
= DW_EH_PE_omit
;
3630 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
3631 #ifdef HAVE_AS_LEB128
3632 ASM_GENERATE_INTERNAL_LABEL (ttype_label
, "LLSDATT",
3633 current_function_funcdef_no
);
3635 tt_format_size
= size_of_encoded_value (tt_format
);
3637 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3640 targetm
.asm_out
.internal_label (asm_out_file
, "LLSDA",
3641 current_function_funcdef_no
);
3643 /* The LSDA header. */
3645 /* Indicate the format of the landing pad start pointer. An omitted
3646 field implies @LPStart == @Start. */
3647 /* Currently we always put @LPStart == @Start. This field would
3648 be most useful in moving the landing pads completely out of
3649 line to another section, but it could also be used to minimize
3650 the size of uleb128 landing pad offsets. */
3651 lp_format
= DW_EH_PE_omit
;
3652 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
3653 eh_data_format_name (lp_format
));
3655 /* @LPStart pointer would go here. */
3657 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
3658 eh_data_format_name (tt_format
));
3660 #ifndef HAVE_AS_LEB128
3661 if (USING_SJLJ_EXCEPTIONS
)
3662 call_site_len
= sjlj_size_of_call_site_table ();
3664 call_site_len
= dw2_size_of_call_site_table ();
3667 /* A pc-relative 4-byte displacement to the @TType data. */
3670 #ifdef HAVE_AS_LEB128
3671 char ttype_after_disp_label
[32];
3672 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
, "LLSDATTD",
3673 current_function_funcdef_no
);
3674 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3675 "@TType base offset");
3676 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3678 /* Ug. Alignment queers things. */
3679 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3681 before_disp
= 1 + 1;
3682 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3684 + VARRAY_ACTIVE_SIZE (crtl
->eh
.action_record_data
)
3685 + (VEC_length (tree
, crtl
->eh
.ttype_data
)
3691 unsigned int disp_size
, pad
;
3694 disp_size
= size_of_uleb128 (disp
);
3695 pad
= before_disp
+ disp_size
+ after_disp
;
3696 if (pad
% tt_format_size
)
3697 pad
= tt_format_size
- (pad
% tt_format_size
);
3700 disp
= after_disp
+ pad
;
3702 while (disp
!= last_disp
);
3704 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3708 /* Indicate the format of the call-site offsets. */
3709 #ifdef HAVE_AS_LEB128
3710 cs_format
= DW_EH_PE_uleb128
;
3712 cs_format
= DW_EH_PE_udata4
;
3714 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3715 eh_data_format_name (cs_format
));
3717 #ifdef HAVE_AS_LEB128
3718 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
, "LLSDACSB",
3719 current_function_funcdef_no
);
3720 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
, "LLSDACSE",
3721 current_function_funcdef_no
);
3722 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3723 "Call-site table length");
3724 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3725 if (USING_SJLJ_EXCEPTIONS
)
3726 sjlj_output_call_site_table ();
3728 dw2_output_call_site_table ();
3729 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3731 dw2_asm_output_data_uleb128 (call_site_len
,"Call-site table length");
3732 if (USING_SJLJ_EXCEPTIONS
)
3733 sjlj_output_call_site_table ();
3735 dw2_output_call_site_table ();
3738 /* ??? Decode and interpret the data for flag_debug_asm. */
3739 n
= VARRAY_ACTIVE_SIZE (crtl
->eh
.action_record_data
);
3740 for (i
= 0; i
< n
; ++i
)
3741 dw2_asm_output_data (1, VARRAY_UCHAR (crtl
->eh
.action_record_data
, i
),
3742 (i
? NULL
: "Action record table"));
3745 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3747 i
= VEC_length (tree
, crtl
->eh
.ttype_data
);
3750 tree type
= VEC_index (tree
, crtl
->eh
.ttype_data
, i
);
3751 output_ttype (type
, tt_format
, tt_format_size
);
3754 #ifdef HAVE_AS_LEB128
3756 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3759 /* ??? Decode and interpret the data for flag_debug_asm. */
3760 n
= VARRAY_ACTIVE_SIZE (crtl
->eh
.ehspec_data
);
3761 for (i
= 0; i
< n
; ++i
)
3763 if (targetm
.arm_eabi_unwinder
)
3765 tree type
= VARRAY_TREE (crtl
->eh
.ehspec_data
, i
);
3766 output_ttype (type
, tt_format
, tt_format_size
);
3769 dw2_asm_output_data (1, VARRAY_UCHAR (crtl
->eh
.ehspec_data
, i
),
3770 (i
? NULL
: "Exception specification table"));
3773 switch_to_section (current_function_section ());
3777 set_eh_throw_stmt_table (struct function
*fun
, struct htab
*table
)
3779 fun
->eh
->throw_stmt_table
= table
;
3783 get_eh_throw_stmt_table (struct function
*fun
)
3785 return fun
->eh
->throw_stmt_table
;
3788 /* Dump EH information to OUT. */
3790 dump_eh_tree (FILE *out
, struct function
*fun
)
3792 struct eh_region
*i
;
3794 static const char * const type_name
[] = {"unknown", "cleanup", "try", "catch",
3795 "allowed_exceptions", "must_not_throw",
3798 i
= fun
->eh
->region_tree
;
3802 fprintf (out
, "Eh tree:\n");
3805 fprintf (out
, " %*s %i %s", depth
* 2, "",
3806 i
->region_number
, type_name
[(int)i
->type
]);
3809 fprintf (out
, " tree_label:");
3810 print_generic_expr (out
, i
->tree_label
, 0);
3812 fprintf (out
, "\n");
3813 /* If there are sub-regions, process them. */
3815 i
= i
->inner
, depth
++;
3816 /* If there are peers, process them. */
3817 else if (i
->next_peer
)
3819 /* Otherwise, step back up the tree to the next peer. */
3827 } while (i
->next_peer
== NULL
);
3833 /* Verify some basic invariants on EH datastructures. Could be extended to
3836 verify_eh_tree (struct function
*fun
)
3838 struct eh_region
*i
, *outer
= NULL
;
3845 i
= fun
->eh
->region_tree
;
3848 for (j
= fun
->eh
->last_region_number
; j
> 0; --j
)
3849 if ((i
= VEC_index (eh_region
, cfun
->eh
->region_array
, j
)))
3852 if (i
->region_number
!= j
)
3854 error ("region_array is corrupted for region %i", i
->region_number
);
3861 if (VEC_index (eh_region
, cfun
->eh
->region_array
, i
->region_number
) != i
)
3863 error ("region_array is corrupted for region %i", i
->region_number
);
3866 if (i
->outer
!= outer
)
3868 error ("outer block of region %i is wrong", i
->region_number
);
3871 if (i
->may_contain_throw
&& outer
&& !outer
->may_contain_throw
)
3873 error ("region %i may contain throw and is contained in region that may not",
3879 error ("negative nesting depth of region %i", i
->region_number
);
3883 /* If there are sub-regions, process them. */
3885 outer
= i
, i
= i
->inner
, depth
++;
3886 /* If there are peers, process them. */
3887 else if (i
->next_peer
)
3889 /* Otherwise, step back up the tree to the next peer. */
3899 error ("tree list ends on depth %i", depth
+ 1);
3902 if (count
!= nvisited
)
3904 error ("array does not match the region tree");
3909 dump_eh_tree (stderr
, fun
);
3910 internal_error ("verify_eh_tree failed");
3915 } while (i
->next_peer
== NULL
);
3921 /* Initialize unwind_resume_libfunc. */
3924 default_init_unwind_resume_libfunc (void)
3926 /* The default c++ routines aren't actually c++ specific, so use those. */
3927 unwind_resume_libfunc
=
3928 init_one_libfunc ( USING_SJLJ_EXCEPTIONS
? "_Unwind_SjLj_Resume"
3929 : "_Unwind_Resume");
3934 gate_handle_eh (void)
3936 return doing_eh (0);
3939 /* Complete generation of exception handling code. */
3941 rest_of_handle_eh (void)
3943 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
3944 finish_eh_generation ();
3945 cleanup_cfg (CLEANUP_NO_INSN_DEL
);
3949 struct rtl_opt_pass pass_rtl_eh
=
3954 gate_handle_eh
, /* gate */
3955 rest_of_handle_eh
, /* execute */
3958 0, /* static_pass_number */
3959 TV_JUMP
, /* tv_id */
3960 0, /* properties_required */
3961 0, /* properties_provided */
3962 0, /* properties_destroyed */
3963 0, /* todo_flags_start */
3964 TODO_dump_func
/* todo_flags_finish */
3968 #include "gt-except.h"