1 /* Implements exception handling.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Contributed by Mike Stump <mrs@cygnus.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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. ] */
58 #include "insn-config.h"
60 #include "integrate.h"
61 #include "hard-reg-set.h"
62 #include "basic-block.h"
64 #include "dwarf2asm.h"
65 #include "dwarf2out.h"
73 #include "langhooks.h"
75 /* Provide defaults for stuff that may not be defined when using
77 #ifndef EH_RETURN_STACKADJ_RTX
78 #define EH_RETURN_STACKADJ_RTX 0
80 #ifndef EH_RETURN_HANDLER_RTX
81 #define EH_RETURN_HANDLER_RTX 0
83 #ifndef EH_RETURN_DATA_REGNO
84 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
88 /* Nonzero means enable synchronous exceptions for non-call instructions. */
89 int flag_non_call_exceptions
;
91 /* Protect cleanup actions with must-not-throw regions, with a call
92 to the given failure handler. */
93 tree (*lang_protect_cleanup_actions
) PARAMS ((void));
95 /* Return true if type A catches type B. */
96 int (*lang_eh_type_covers
) PARAMS ((tree a
, tree b
));
98 /* Map a type to a runtime object to match type. */
99 tree (*lang_eh_runtime_type
) PARAMS ((tree
));
101 /* A hash table of label to region number. */
106 struct eh_region
*region
;
109 static htab_t exception_handler_label_map
;
111 static int call_site_base
;
112 static unsigned int sjlj_funcdef_number
;
113 static htab_t type_to_runtime_map
;
115 /* Describe the SjLj_Function_Context structure. */
116 static tree sjlj_fc_type_node
;
117 static int sjlj_fc_call_site_ofs
;
118 static int sjlj_fc_data_ofs
;
119 static int sjlj_fc_personality_ofs
;
120 static int sjlj_fc_lsda_ofs
;
121 static int sjlj_fc_jbuf_ofs
;
123 /* Describes one exception region. */
126 /* The immediately surrounding region. */
127 struct eh_region
*outer
;
129 /* The list of immediately contained regions. */
130 struct eh_region
*inner
;
131 struct eh_region
*next_peer
;
133 /* An identifier for this region. */
136 /* When a region is deleted, its parents inherit the REG_EH_REGION
137 numbers already assigned. */
140 /* Each region does exactly one thing. */
147 ERT_ALLOWED_EXCEPTIONS
,
153 /* Holds the action to perform based on the preceding type. */
155 /* A list of catch blocks, a surrounding try block,
156 and the label for continuing after a catch. */
158 struct eh_region
*catch;
159 struct eh_region
*last_catch
;
160 struct eh_region
*prev_try
;
164 /* The list through the catch handlers, the list of type objects
165 matched, and the list of associated filters. */
167 struct eh_region
*next_catch
;
168 struct eh_region
*prev_catch
;
173 /* A tree_list of allowed types. */
179 /* The type given by a call to "throw foo();", or discovered
185 /* Retain the cleanup expression even after expansion so that
186 we can match up fixup regions. */
191 /* The real region (by expression and by pointer) that fixup code
195 struct eh_region
*real_region
;
199 /* Entry point for this region's handler before landing pads are built. */
202 /* Entry point for this region's handler from the runtime eh library. */
205 /* Entry point for this region's handler from an inner region. */
206 rtx post_landing_pad
;
208 /* The RESX insn for handing off control to the next outermost handler,
213 /* Used to save exception status for each function. */
216 /* The tree of all regions for this function. */
217 struct eh_region
*region_tree
;
219 /* The same information as an indexable array. */
220 struct eh_region
**region_array
;
222 /* The most recently open region. */
223 struct eh_region
*cur_region
;
225 /* This is the region for which we are processing catch blocks. */
226 struct eh_region
*try_region
;
231 int built_landing_pads
;
232 int last_region_number
;
234 varray_type ttype_data
;
235 varray_type ehspec_data
;
236 varray_type action_record_data
;
238 struct call_site_record
243 int call_site_data_used
;
244 int call_site_data_size
;
255 static void mark_eh_region
PARAMS ((struct eh_region
*));
256 static int mark_ehl_map_entry
PARAMS ((PTR
*, PTR
));
257 static void mark_ehl_map
PARAMS ((void *));
259 static void free_region
PARAMS ((struct eh_region
*));
261 static int t2r_eq
PARAMS ((const PTR
,
263 static hashval_t t2r_hash
PARAMS ((const PTR
));
264 static int t2r_mark_1
PARAMS ((PTR
*, PTR
));
265 static void t2r_mark
PARAMS ((PTR
));
266 static void add_type_for_runtime
PARAMS ((tree
));
267 static tree lookup_type_for_runtime
PARAMS ((tree
));
269 static struct eh_region
*expand_eh_region_end
PARAMS ((void));
271 static rtx get_exception_filter
PARAMS ((struct function
*));
273 static void collect_eh_region_array
PARAMS ((void));
274 static void resolve_fixup_regions
PARAMS ((void));
275 static void remove_fixup_regions
PARAMS ((void));
276 static void remove_unreachable_regions
PARAMS ((rtx
));
277 static void convert_from_eh_region_ranges_1
PARAMS ((rtx
*, int *, int));
279 static struct eh_region
*duplicate_eh_region_1
PARAMS ((struct eh_region
*,
280 struct inline_remap
*));
281 static void duplicate_eh_region_2
PARAMS ((struct eh_region
*,
282 struct eh_region
**));
283 static int ttypes_filter_eq
PARAMS ((const PTR
,
285 static hashval_t ttypes_filter_hash
PARAMS ((const PTR
));
286 static int ehspec_filter_eq
PARAMS ((const PTR
,
288 static hashval_t ehspec_filter_hash
PARAMS ((const PTR
));
289 static int add_ttypes_entry
PARAMS ((htab_t
, tree
));
290 static int add_ehspec_entry
PARAMS ((htab_t
, htab_t
,
292 static void assign_filter_values
PARAMS ((void));
293 static void build_post_landing_pads
PARAMS ((void));
294 static void connect_post_landing_pads
PARAMS ((void));
295 static void dw2_build_landing_pads
PARAMS ((void));
298 static bool sjlj_find_directly_reachable_regions
299 PARAMS ((struct sjlj_lp_info
*));
300 static void sjlj_assign_call_site_values
301 PARAMS ((rtx
, struct sjlj_lp_info
*));
302 static void sjlj_mark_call_sites
303 PARAMS ((struct sjlj_lp_info
*));
304 static void sjlj_emit_function_enter
PARAMS ((rtx
));
305 static void sjlj_emit_function_exit
PARAMS ((void));
306 static void sjlj_emit_dispatch_table
307 PARAMS ((rtx
, struct sjlj_lp_info
*));
308 static void sjlj_build_landing_pads
PARAMS ((void));
310 static hashval_t ehl_hash
PARAMS ((const PTR
));
311 static int ehl_eq
PARAMS ((const PTR
,
313 static void ehl_free
PARAMS ((PTR
));
314 static void add_ehl_entry
PARAMS ((rtx
,
315 struct eh_region
*));
316 static void remove_exception_handler_label
PARAMS ((rtx
));
317 static void remove_eh_handler
PARAMS ((struct eh_region
*));
318 static int for_each_eh_label_1
PARAMS ((PTR
*, PTR
));
320 struct reachable_info
;
322 /* The return value of reachable_next_level. */
325 /* The given exception is not processed by the given region. */
327 /* The given exception may need processing by the given region. */
329 /* The given exception is completely processed by the given region. */
331 /* The given exception is completely processed by the runtime. */
335 static int check_handled
PARAMS ((tree
, tree
));
336 static void add_reachable_handler
337 PARAMS ((struct reachable_info
*, struct eh_region
*,
338 struct eh_region
*));
339 static enum reachable_code reachable_next_level
340 PARAMS ((struct eh_region
*, tree
, struct reachable_info
*));
342 static int action_record_eq
PARAMS ((const PTR
,
344 static hashval_t action_record_hash
PARAMS ((const PTR
));
345 static int add_action_record
PARAMS ((htab_t
, int, int));
346 static int collect_one_action_chain
PARAMS ((htab_t
,
347 struct eh_region
*));
348 static int add_call_site
PARAMS ((rtx
, int));
350 static void push_uleb128
PARAMS ((varray_type
*,
352 static void push_sleb128
PARAMS ((varray_type
*, int));
353 #ifndef HAVE_AS_LEB128
354 static int dw2_size_of_call_site_table
PARAMS ((void));
355 static int sjlj_size_of_call_site_table
PARAMS ((void));
357 static void dw2_output_call_site_table
PARAMS ((void));
358 static void sjlj_output_call_site_table
PARAMS ((void));
361 /* Routine to see if exception handling is turned on.
362 DO_WARN is non-zero if we want to inform the user that exception
363 handling is turned off.
365 This is used to ensure that -fexceptions has been specified if the
366 compiler tries to use any exception-specific functions. */
372 if (! flag_exceptions
)
374 static int warned
= 0;
375 if (! warned
&& do_warn
)
377 error ("exception handling disabled, use -fexceptions to enable");
389 ggc_add_root (&exception_handler_label_map
, 1, 1, mark_ehl_map
);
391 if (! flag_exceptions
)
394 type_to_runtime_map
= htab_create (31, t2r_hash
, t2r_eq
, NULL
);
395 ggc_add_root (&type_to_runtime_map
, 1, sizeof (htab_t
), t2r_mark
);
397 /* Create the SjLj_Function_Context structure. This should match
398 the definition in unwind-sjlj.c. */
399 if (USING_SJLJ_EXCEPTIONS
)
401 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
403 sjlj_fc_type_node
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
404 ggc_add_tree_root (&sjlj_fc_type_node
, 1);
406 f_prev
= build_decl (FIELD_DECL
, get_identifier ("__prev"),
407 build_pointer_type (sjlj_fc_type_node
));
408 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
410 f_cs
= build_decl (FIELD_DECL
, get_identifier ("__call_site"),
412 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
414 tmp
= build_index_type (build_int_2 (4 - 1, 0));
415 tmp
= build_array_type ((*lang_hooks
.types
.type_for_mode
) (word_mode
, 1),
417 f_data
= build_decl (FIELD_DECL
, get_identifier ("__data"), tmp
);
418 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
420 f_per
= build_decl (FIELD_DECL
, get_identifier ("__personality"),
422 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
424 f_lsda
= build_decl (FIELD_DECL
, get_identifier ("__lsda"),
426 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
428 #ifdef DONT_USE_BUILTIN_SETJMP
430 tmp
= build_int_2 (JMP_BUF_SIZE
- 1, 0);
432 /* Should be large enough for most systems, if it is not,
433 JMP_BUF_SIZE should be defined with the proper value. It will
434 also tend to be larger than necessary for most systems, a more
435 optimal port will define JMP_BUF_SIZE. */
436 tmp
= build_int_2 (FIRST_PSEUDO_REGISTER
+ 2 - 1, 0);
439 /* This is 2 for builtin_setjmp, plus whatever the target requires
440 via STACK_SAVEAREA_MODE (SAVE_NONLOCAL). */
441 tmp
= build_int_2 ((GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
))
442 / GET_MODE_SIZE (Pmode
)) + 2 - 1, 0);
444 tmp
= build_index_type (tmp
);
445 tmp
= build_array_type (ptr_type_node
, tmp
);
446 f_jbuf
= build_decl (FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
447 #ifdef DONT_USE_BUILTIN_SETJMP
448 /* We don't know what the alignment requirements of the
449 runtime's jmp_buf has. Overestimate. */
450 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
451 DECL_USER_ALIGN (f_jbuf
) = 1;
453 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
455 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
456 TREE_CHAIN (f_prev
) = f_cs
;
457 TREE_CHAIN (f_cs
) = f_data
;
458 TREE_CHAIN (f_data
) = f_per
;
459 TREE_CHAIN (f_per
) = f_lsda
;
460 TREE_CHAIN (f_lsda
) = f_jbuf
;
462 layout_type (sjlj_fc_type_node
);
464 /* Cache the interesting field offsets so that we have
465 easy access from rtl. */
466 sjlj_fc_call_site_ofs
467 = (tree_low_cst (DECL_FIELD_OFFSET (f_cs
), 1)
468 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs
), 1) / BITS_PER_UNIT
);
470 = (tree_low_cst (DECL_FIELD_OFFSET (f_data
), 1)
471 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data
), 1) / BITS_PER_UNIT
);
472 sjlj_fc_personality_ofs
473 = (tree_low_cst (DECL_FIELD_OFFSET (f_per
), 1)
474 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per
), 1) / BITS_PER_UNIT
);
476 = (tree_low_cst (DECL_FIELD_OFFSET (f_lsda
), 1)
477 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda
), 1) / BITS_PER_UNIT
);
479 = (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf
), 1)
480 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf
), 1) / BITS_PER_UNIT
);
485 init_eh_for_function ()
487 cfun
->eh
= (struct eh_status
*) xcalloc (1, sizeof (struct eh_status
));
490 /* Mark EH for GC. */
493 mark_eh_region (region
)
494 struct eh_region
*region
;
499 switch (region
->type
)
502 /* This can happen if a nested function is inside the body of a region
503 and we do a GC as part of processing it. */
506 ggc_mark_tree (region
->u
.cleanup
.exp
);
509 ggc_mark_rtx (region
->u
.try.continue_label
);
512 ggc_mark_tree (region
->u
.catch.type_list
);
513 ggc_mark_tree (region
->u
.catch.filter_list
);
515 case ERT_ALLOWED_EXCEPTIONS
:
516 ggc_mark_tree (region
->u
.allowed
.type_list
);
518 case ERT_MUST_NOT_THROW
:
521 ggc_mark_tree (region
->u
.throw.type
);
524 ggc_mark_tree (region
->u
.fixup
.cleanup_exp
);
530 ggc_mark_rtx (region
->label
);
531 ggc_mark_rtx (region
->resume
);
532 ggc_mark_rtx (region
->landing_pad
);
533 ggc_mark_rtx (region
->post_landing_pad
);
537 mark_ehl_map_entry (pentry
, data
)
539 PTR data ATTRIBUTE_UNUSED
;
541 struct ehl_map_entry
*entry
= *(struct ehl_map_entry
**) pentry
;
542 ggc_mark_rtx (entry
->label
);
550 htab_t map
= *(htab_t
*) pp
;
552 htab_traverse (map
, mark_ehl_map_entry
, NULL
);
557 struct eh_status
*eh
;
564 /* If we've called collect_eh_region_array, use it. Otherwise walk
565 the tree non-recursively. */
566 if (eh
->region_array
)
568 for (i
= eh
->last_region_number
; i
> 0; --i
)
570 struct eh_region
*r
= eh
->region_array
[i
];
571 if (r
&& r
->region_number
== i
)
575 else if (eh
->region_tree
)
577 struct eh_region
*r
= eh
->region_tree
;
583 else if (r
->next_peer
)
591 } while (r
->next_peer
== NULL
);
598 ggc_mark_rtx (eh
->filter
);
599 ggc_mark_rtx (eh
->exc_ptr
);
600 ggc_mark_tree_varray (eh
->ttype_data
);
602 if (eh
->call_site_data
)
604 for (i
= eh
->call_site_data_used
- 1; i
>= 0; --i
)
605 ggc_mark_rtx (eh
->call_site_data
[i
].landing_pad
);
608 ggc_mark_rtx (eh
->ehr_stackadj
);
609 ggc_mark_rtx (eh
->ehr_handler
);
610 ggc_mark_rtx (eh
->ehr_label
);
612 ggc_mark_rtx (eh
->sjlj_fc
);
613 ggc_mark_rtx (eh
->sjlj_exit_after
);
620 /* Note that the aka bitmap is freed by regset_release_memory. But if
621 we ever replace with a non-obstack implementation, this would be
622 the place to do it. */
630 struct eh_status
*eh
= f
->eh
;
632 if (eh
->region_array
)
635 for (i
= eh
->last_region_number
; i
> 0; --i
)
637 struct eh_region
*r
= eh
->region_array
[i
];
638 /* Mind we don't free a region struct more than once. */
639 if (r
&& r
->region_number
== i
)
642 free (eh
->region_array
);
644 else if (eh
->region_tree
)
646 struct eh_region
*next
, *r
= eh
->region_tree
;
651 else if (r
->next_peer
)
665 } while (r
->next_peer
== NULL
);
674 VARRAY_FREE (eh
->ttype_data
);
675 VARRAY_FREE (eh
->ehspec_data
);
676 VARRAY_FREE (eh
->action_record_data
);
677 if (eh
->call_site_data
)
678 free (eh
->call_site_data
);
683 if (exception_handler_label_map
)
685 htab_delete (exception_handler_label_map
);
686 exception_handler_label_map
= NULL
;
691 /* Start an exception handling region. All instructions emitted
692 after this point are considered to be part of the region until
693 expand_eh_region_end is invoked. */
696 expand_eh_region_start ()
698 struct eh_region
*new_region
;
699 struct eh_region
*cur_region
;
705 /* Insert a new blank region as a leaf in the tree. */
706 new_region
= (struct eh_region
*) xcalloc (1, sizeof (*new_region
));
707 cur_region
= cfun
->eh
->cur_region
;
708 new_region
->outer
= cur_region
;
711 new_region
->next_peer
= cur_region
->inner
;
712 cur_region
->inner
= new_region
;
716 new_region
->next_peer
= cfun
->eh
->region_tree
;
717 cfun
->eh
->region_tree
= new_region
;
719 cfun
->eh
->cur_region
= new_region
;
721 /* Create a note marking the start of this region. */
722 new_region
->region_number
= ++cfun
->eh
->last_region_number
;
723 note
= emit_note (NULL
, NOTE_INSN_EH_REGION_BEG
);
724 NOTE_EH_HANDLER (note
) = new_region
->region_number
;
727 /* Common code to end a region. Returns the region just ended. */
729 static struct eh_region
*
730 expand_eh_region_end ()
732 struct eh_region
*cur_region
= cfun
->eh
->cur_region
;
735 /* Create a note marking the end of this region. */
736 note
= emit_note (NULL
, NOTE_INSN_EH_REGION_END
);
737 NOTE_EH_HANDLER (note
) = cur_region
->region_number
;
740 cfun
->eh
->cur_region
= cur_region
->outer
;
745 /* End an exception handling region for a cleanup. HANDLER is an
746 expression to expand for the cleanup. */
749 expand_eh_region_end_cleanup (handler
)
752 struct eh_region
*region
;
753 tree protect_cleanup_actions
;
760 region
= expand_eh_region_end ();
761 region
->type
= ERT_CLEANUP
;
762 region
->label
= gen_label_rtx ();
763 region
->u
.cleanup
.exp
= handler
;
765 around_label
= gen_label_rtx ();
766 emit_jump (around_label
);
768 emit_label (region
->label
);
770 /* Give the language a chance to specify an action to be taken if an
771 exception is thrown that would propagate out of the HANDLER. */
772 protect_cleanup_actions
773 = (lang_protect_cleanup_actions
774 ? (*lang_protect_cleanup_actions
) ()
777 if (protect_cleanup_actions
)
778 expand_eh_region_start ();
780 /* In case this cleanup involves an inline destructor with a try block in
781 it, we need to save the EH return data registers around it. */
782 data_save
[0] = gen_reg_rtx (Pmode
);
783 emit_move_insn (data_save
[0], get_exception_pointer (cfun
));
784 data_save
[1] = gen_reg_rtx (word_mode
);
785 emit_move_insn (data_save
[1], get_exception_filter (cfun
));
787 expand_expr (handler
, const0_rtx
, VOIDmode
, 0);
789 emit_move_insn (cfun
->eh
->exc_ptr
, data_save
[0]);
790 emit_move_insn (cfun
->eh
->filter
, data_save
[1]);
792 if (protect_cleanup_actions
)
793 expand_eh_region_end_must_not_throw (protect_cleanup_actions
);
795 /* We need any stack adjustment complete before the around_label. */
796 do_pending_stack_adjust ();
798 /* We delay the generation of the _Unwind_Resume until we generate
799 landing pads. We emit a marker here so as to get good control
800 flow data in the meantime. */
802 = emit_jump_insn (gen_rtx_RESX (VOIDmode
, region
->region_number
));
805 emit_label (around_label
);
808 /* End an exception handling region for a try block, and prepares
809 for subsequent calls to expand_start_catch. */
812 expand_start_all_catch ()
814 struct eh_region
*region
;
819 region
= expand_eh_region_end ();
820 region
->type
= ERT_TRY
;
821 region
->u
.try.prev_try
= cfun
->eh
->try_region
;
822 region
->u
.try.continue_label
= gen_label_rtx ();
824 cfun
->eh
->try_region
= region
;
826 emit_jump (region
->u
.try.continue_label
);
829 /* Begin a catch clause. TYPE is the type caught, a list of such types, or
830 null if this is a catch-all clause. Providing a type list enables to
831 associate the catch region with potentially several exception types, which
832 is useful e.g. for Ada. */
835 expand_start_catch (type_or_list
)
838 struct eh_region
*t
, *c
, *l
;
844 type_list
= type_or_list
;
848 /* Ensure to always end up with a type list to normalize further
849 processing, then register each type against the runtime types
853 if (TREE_CODE (type_or_list
) != TREE_LIST
)
854 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
856 type_node
= type_list
;
857 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
858 add_type_for_runtime (TREE_VALUE (type_node
));
861 expand_eh_region_start ();
863 t
= cfun
->eh
->try_region
;
864 c
= cfun
->eh
->cur_region
;
866 c
->u
.catch.type_list
= type_list
;
867 c
->label
= gen_label_rtx ();
869 l
= t
->u
.try.last_catch
;
870 c
->u
.catch.prev_catch
= l
;
872 l
->u
.catch.next_catch
= c
;
875 t
->u
.try.last_catch
= c
;
877 emit_label (c
->label
);
880 /* End a catch clause. Control will resume after the try/catch block. */
885 struct eh_region
*try_region
, *catch_region
;
890 catch_region
= expand_eh_region_end ();
891 try_region
= cfun
->eh
->try_region
;
893 emit_jump (try_region
->u
.try.continue_label
);
896 /* End a sequence of catch handlers for a try block. */
899 expand_end_all_catch ()
901 struct eh_region
*try_region
;
906 try_region
= cfun
->eh
->try_region
;
907 cfun
->eh
->try_region
= try_region
->u
.try.prev_try
;
909 emit_label (try_region
->u
.try.continue_label
);
912 /* End an exception region for an exception type filter. ALLOWED is a
913 TREE_LIST of types to be matched by the runtime. FAILURE is an
914 expression to invoke if a mismatch occurs.
916 ??? We could use these semantics for calls to rethrow, too; if we can
917 see the surrounding catch clause, we know that the exception we're
918 rethrowing satisfies the "filter" of the catch type. */
921 expand_eh_region_end_allowed (allowed
, failure
)
922 tree allowed
, failure
;
924 struct eh_region
*region
;
930 region
= expand_eh_region_end ();
931 region
->type
= ERT_ALLOWED_EXCEPTIONS
;
932 region
->u
.allowed
.type_list
= allowed
;
933 region
->label
= gen_label_rtx ();
935 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
936 add_type_for_runtime (TREE_VALUE (allowed
));
938 /* We must emit the call to FAILURE here, so that if this function
939 throws a different exception, that it will be processed by the
942 around_label
= gen_label_rtx ();
943 emit_jump (around_label
);
945 emit_label (region
->label
);
946 expand_expr (failure
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
947 /* We must adjust the stack before we reach the AROUND_LABEL because
948 the call to FAILURE does not occur on all paths to the
950 do_pending_stack_adjust ();
952 emit_label (around_label
);
955 /* End an exception region for a must-not-throw filter. FAILURE is an
956 expression invoke if an uncaught exception propagates this far.
958 This is conceptually identical to expand_eh_region_end_allowed with
959 an empty allowed list (if you passed "std::terminate" instead of
960 "__cxa_call_unexpected"), but they are represented differently in
964 expand_eh_region_end_must_not_throw (failure
)
967 struct eh_region
*region
;
973 region
= expand_eh_region_end ();
974 region
->type
= ERT_MUST_NOT_THROW
;
975 region
->label
= gen_label_rtx ();
977 /* We must emit the call to FAILURE here, so that if this function
978 throws a different exception, that it will be processed by the
981 around_label
= gen_label_rtx ();
982 emit_jump (around_label
);
984 emit_label (region
->label
);
985 expand_expr (failure
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
987 emit_label (around_label
);
990 /* End an exception region for a throw. No handling goes on here,
991 but it's the easiest way for the front-end to indicate what type
995 expand_eh_region_end_throw (type
)
998 struct eh_region
*region
;
1003 region
= expand_eh_region_end ();
1004 region
->type
= ERT_THROW
;
1005 region
->u
.throw.type
= type
;
1008 /* End a fixup region. Within this region the cleanups for the immediately
1009 enclosing region are _not_ run. This is used for goto cleanup to avoid
1010 destroying an object twice.
1012 This would be an extraordinarily simple prospect, were it not for the
1013 fact that we don't actually know what the immediately enclosing region
1014 is. This surprising fact is because expand_cleanups is currently
1015 generating a sequence that it will insert somewhere else. We collect
1016 the proper notion of "enclosing" in convert_from_eh_region_ranges. */
1019 expand_eh_region_end_fixup (handler
)
1022 struct eh_region
*fixup
;
1027 fixup
= expand_eh_region_end ();
1028 fixup
->type
= ERT_FIXUP
;
1029 fixup
->u
.fixup
.cleanup_exp
= handler
;
1032 /* Return an rtl expression for a pointer to the exception object
1033 within a handler. */
1036 get_exception_pointer (fun
)
1037 struct function
*fun
;
1039 rtx exc_ptr
= fun
->eh
->exc_ptr
;
1040 if (fun
== cfun
&& ! exc_ptr
)
1042 exc_ptr
= gen_reg_rtx (Pmode
);
1043 fun
->eh
->exc_ptr
= exc_ptr
;
1048 /* Return an rtl expression for the exception dispatch filter
1049 within a handler. */
1052 get_exception_filter (fun
)
1053 struct function
*fun
;
1055 rtx filter
= fun
->eh
->filter
;
1056 if (fun
== cfun
&& ! filter
)
1058 filter
= gen_reg_rtx (word_mode
);
1059 fun
->eh
->filter
= filter
;
1064 /* This section is for the exception handling specific optimization pass. */
1066 /* Random access the exception region tree. It's just as simple to
1067 collect the regions this way as in expand_eh_region_start, but
1068 without having to realloc memory. */
1071 collect_eh_region_array ()
1073 struct eh_region
**array
, *i
;
1075 i
= cfun
->eh
->region_tree
;
1079 array
= xcalloc (cfun
->eh
->last_region_number
+ 1, sizeof (*array
));
1080 cfun
->eh
->region_array
= array
;
1084 array
[i
->region_number
] = i
;
1086 /* If there are sub-regions, process them. */
1089 /* If there are peers, process them. */
1090 else if (i
->next_peer
)
1092 /* Otherwise, step back up the tree to the next peer. */
1099 } while (i
->next_peer
== NULL
);
1106 resolve_fixup_regions ()
1108 int i
, j
, n
= cfun
->eh
->last_region_number
;
1110 for (i
= 1; i
<= n
; ++i
)
1112 struct eh_region
*fixup
= cfun
->eh
->region_array
[i
];
1113 struct eh_region
*cleanup
= 0;
1115 if (! fixup
|| fixup
->type
!= ERT_FIXUP
)
1118 for (j
= 1; j
<= n
; ++j
)
1120 cleanup
= cfun
->eh
->region_array
[j
];
1121 if (cleanup
->type
== ERT_CLEANUP
1122 && cleanup
->u
.cleanup
.exp
== fixup
->u
.fixup
.cleanup_exp
)
1128 fixup
->u
.fixup
.real_region
= cleanup
->outer
;
1132 /* Now that we've discovered what region actually encloses a fixup,
1133 we can shuffle pointers and remove them from the tree. */
1136 remove_fixup_regions ()
1140 struct eh_region
*fixup
;
1142 /* Walk the insn chain and adjust the REG_EH_REGION numbers
1143 for instructions referencing fixup regions. This is only
1144 strictly necessary for fixup regions with no parent, but
1145 doesn't hurt to do it for all regions. */
1146 for (insn
= get_insns(); insn
; insn
= NEXT_INSN (insn
))
1148 && (note
= find_reg_note (insn
, REG_EH_REGION
, NULL
))
1149 && INTVAL (XEXP (note
, 0)) > 0
1150 && (fixup
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))])
1151 && fixup
->type
== ERT_FIXUP
)
1153 if (fixup
->u
.fixup
.real_region
)
1154 XEXP (note
, 0) = GEN_INT (fixup
->u
.fixup
.real_region
->region_number
);
1156 remove_note (insn
, note
);
1159 /* Remove the fixup regions from the tree. */
1160 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1162 fixup
= cfun
->eh
->region_array
[i
];
1166 /* Allow GC to maybe free some memory. */
1167 if (fixup
->type
== ERT_CLEANUP
)
1168 fixup
->u
.cleanup
.exp
= NULL_TREE
;
1170 if (fixup
->type
!= ERT_FIXUP
)
1175 struct eh_region
*parent
, *p
, **pp
;
1177 parent
= fixup
->u
.fixup
.real_region
;
1179 /* Fix up the children's parent pointers; find the end of
1181 for (p
= fixup
->inner
; ; p
= p
->next_peer
)
1188 /* In the tree of cleanups, only outer-inner ordering matters.
1189 So link the children back in anywhere at the correct level. */
1191 pp
= &parent
->inner
;
1193 pp
= &cfun
->eh
->region_tree
;
1196 fixup
->inner
= NULL
;
1199 remove_eh_handler (fixup
);
1203 /* Remove all regions whose labels are not reachable from insns. */
1206 remove_unreachable_regions (insns
)
1209 int i
, *uid_region_num
;
1211 struct eh_region
*r
;
1214 uid_region_num
= xcalloc (get_max_uid (), sizeof(int));
1215 reachable
= xcalloc (cfun
->eh
->last_region_number
+ 1, sizeof(bool));
1217 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1219 r
= cfun
->eh
->region_array
[i
];
1220 if (!r
|| r
->region_number
!= i
)
1225 if (uid_region_num
[INSN_UID (r
->resume
)])
1227 uid_region_num
[INSN_UID (r
->resume
)] = i
;
1231 if (uid_region_num
[INSN_UID (r
->label
)])
1233 uid_region_num
[INSN_UID (r
->label
)] = i
;
1235 if (r
->type
== ERT_TRY
&& r
->u
.try.continue_label
)
1237 if (uid_region_num
[INSN_UID (r
->u
.try.continue_label
)])
1239 uid_region_num
[INSN_UID (r
->u
.try.continue_label
)] = i
;
1243 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
1244 reachable
[uid_region_num
[INSN_UID (insn
)]] = true;
1246 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1248 r
= cfun
->eh
->region_array
[i
];
1249 if (r
&& r
->region_number
== i
&& !reachable
[i
])
1251 /* Don't remove ERT_THROW regions if their outer region
1253 if (r
->type
== ERT_THROW
1255 && reachable
[r
->outer
->region_number
])
1258 remove_eh_handler (r
);
1263 free (uid_region_num
);
1266 /* Turn NOTE_INSN_EH_REGION notes into REG_EH_REGION notes for each
1267 can_throw instruction in the region. */
1270 convert_from_eh_region_ranges_1 (pinsns
, orig_sp
, cur
)
1278 for (insn
= *pinsns
; insn
; insn
= next
)
1280 next
= NEXT_INSN (insn
);
1281 if (GET_CODE (insn
) == NOTE
)
1283 int kind
= NOTE_LINE_NUMBER (insn
);
1284 if (kind
== NOTE_INSN_EH_REGION_BEG
1285 || kind
== NOTE_INSN_EH_REGION_END
)
1287 if (kind
== NOTE_INSN_EH_REGION_BEG
)
1289 struct eh_region
*r
;
1292 cur
= NOTE_EH_HANDLER (insn
);
1294 r
= cfun
->eh
->region_array
[cur
];
1295 if (r
->type
== ERT_FIXUP
)
1297 r
= r
->u
.fixup
.real_region
;
1298 cur
= r
? r
->region_number
: 0;
1300 else if (r
->type
== ERT_CATCH
)
1303 cur
= r
? r
->region_number
: 0;
1309 /* Removing the first insn of a CALL_PLACEHOLDER sequence
1310 requires extra care to adjust sequence start. */
1311 if (insn
== *pinsns
)
1317 else if (INSN_P (insn
))
1320 && ! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1321 /* Calls can always potentially throw exceptions, unless
1322 they have a REG_EH_REGION note with a value of 0 or less.
1323 Which should be the only possible kind so far. */
1324 && (GET_CODE (insn
) == CALL_INSN
1325 /* If we wanted exceptions for non-call insns, then
1326 any may_trap_p instruction could throw. */
1327 || (flag_non_call_exceptions
1328 && GET_CODE (PATTERN (insn
)) != CLOBBER
1329 && GET_CODE (PATTERN (insn
)) != USE
1330 && may_trap_p (PATTERN (insn
)))))
1332 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_EH_REGION
, GEN_INT (cur
),
1336 if (GET_CODE (insn
) == CALL_INSN
1337 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
1339 convert_from_eh_region_ranges_1 (&XEXP (PATTERN (insn
), 0),
1341 convert_from_eh_region_ranges_1 (&XEXP (PATTERN (insn
), 1),
1343 convert_from_eh_region_ranges_1 (&XEXP (PATTERN (insn
), 2),
1354 convert_from_eh_region_ranges ()
1359 collect_eh_region_array ();
1360 resolve_fixup_regions ();
1362 stack
= xmalloc (sizeof (int) * (cfun
->eh
->last_region_number
+ 1));
1363 insns
= get_insns ();
1364 convert_from_eh_region_ranges_1 (&insns
, stack
, 0);
1367 remove_fixup_regions ();
1368 remove_unreachable_regions (insns
);
1372 add_ehl_entry (label
, region
)
1374 struct eh_region
*region
;
1376 struct ehl_map_entry
**slot
, *entry
;
1378 LABEL_PRESERVE_P (label
) = 1;
1380 entry
= (struct ehl_map_entry
*) xmalloc (sizeof (*entry
));
1381 entry
->label
= label
;
1382 entry
->region
= region
;
1384 slot
= (struct ehl_map_entry
**)
1385 htab_find_slot (exception_handler_label_map
, entry
, INSERT
);
1395 struct ehl_map_entry
*entry
= (struct ehl_map_entry
*)pentry
;
1396 LABEL_PRESERVE_P (entry
->label
) = 0;
1401 find_exception_handler_labels ()
1405 if (exception_handler_label_map
)
1406 htab_empty (exception_handler_label_map
);
1409 /* ??? The expansion factor here (3/2) must be greater than the htab
1410 occupancy factor (4/3) to avoid unnecessary resizing. */
1411 exception_handler_label_map
1412 = htab_create (cfun
->eh
->last_region_number
* 3 / 2,
1413 ehl_hash
, ehl_eq
, ehl_free
);
1416 if (cfun
->eh
->region_tree
== NULL
)
1419 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1421 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
1424 if (! region
|| region
->region_number
!= i
)
1426 if (cfun
->eh
->built_landing_pads
)
1427 lab
= region
->landing_pad
;
1429 lab
= region
->label
;
1432 add_ehl_entry (lab
, region
);
1435 /* For sjlj exceptions, need the return label to remain live until
1436 after landing pad generation. */
1437 if (USING_SJLJ_EXCEPTIONS
&& ! cfun
->eh
->built_landing_pads
)
1438 add_ehl_entry (return_label
, NULL
);
1442 current_function_has_exception_handlers ()
1446 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1448 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
1450 if (! region
|| region
->region_number
!= i
)
1452 if (region
->type
!= ERT_THROW
)
1459 static struct eh_region
*
1460 duplicate_eh_region_1 (o
, map
)
1461 struct eh_region
*o
;
1462 struct inline_remap
*map
;
1465 = (struct eh_region
*) xcalloc (1, sizeof (struct eh_region
));
1467 n
->region_number
= o
->region_number
+ cfun
->eh
->last_region_number
;
1473 case ERT_MUST_NOT_THROW
:
1477 if (o
->u
.try.continue_label
)
1478 n
->u
.try.continue_label
1479 = get_label_from_map (map
,
1480 CODE_LABEL_NUMBER (o
->u
.try.continue_label
));
1484 n
->u
.catch.type_list
= o
->u
.catch.type_list
;
1487 case ERT_ALLOWED_EXCEPTIONS
:
1488 n
->u
.allowed
.type_list
= o
->u
.allowed
.type_list
;
1492 n
->u
.throw.type
= o
->u
.throw.type
;
1499 n
->label
= get_label_from_map (map
, CODE_LABEL_NUMBER (o
->label
));
1502 n
->resume
= map
->insn_map
[INSN_UID (o
->resume
)];
1503 if (n
->resume
== NULL
)
1511 duplicate_eh_region_2 (o
, n_array
)
1512 struct eh_region
*o
;
1513 struct eh_region
**n_array
;
1515 struct eh_region
*n
= n_array
[o
->region_number
];
1520 n
->u
.try.catch = n_array
[o
->u
.try.catch->region_number
];
1521 n
->u
.try.last_catch
= n_array
[o
->u
.try.last_catch
->region_number
];
1525 if (o
->u
.catch.next_catch
)
1526 n
->u
.catch.next_catch
= n_array
[o
->u
.catch.next_catch
->region_number
];
1527 if (o
->u
.catch.prev_catch
)
1528 n
->u
.catch.prev_catch
= n_array
[o
->u
.catch.prev_catch
->region_number
];
1536 n
->outer
= n_array
[o
->outer
->region_number
];
1538 n
->inner
= n_array
[o
->inner
->region_number
];
1540 n
->next_peer
= n_array
[o
->next_peer
->region_number
];
1544 duplicate_eh_regions (ifun
, map
)
1545 struct function
*ifun
;
1546 struct inline_remap
*map
;
1548 int ifun_last_region_number
= ifun
->eh
->last_region_number
;
1549 struct eh_region
**n_array
, *root
, *cur
;
1552 if (ifun_last_region_number
== 0)
1555 n_array
= xcalloc (ifun_last_region_number
+ 1, sizeof (*n_array
));
1557 for (i
= 1; i
<= ifun_last_region_number
; ++i
)
1559 cur
= ifun
->eh
->region_array
[i
];
1560 if (!cur
|| cur
->region_number
!= i
)
1562 n_array
[i
] = duplicate_eh_region_1 (cur
, map
);
1564 for (i
= 1; i
<= ifun_last_region_number
; ++i
)
1566 cur
= ifun
->eh
->region_array
[i
];
1567 if (!cur
|| cur
->region_number
!= i
)
1569 duplicate_eh_region_2 (cur
, n_array
);
1572 root
= n_array
[ifun
->eh
->region_tree
->region_number
];
1573 cur
= cfun
->eh
->cur_region
;
1576 struct eh_region
*p
= cur
->inner
;
1579 while (p
->next_peer
)
1581 p
->next_peer
= root
;
1586 for (i
= 1; i
<= ifun_last_region_number
; ++i
)
1587 if (n_array
[i
] && n_array
[i
]->outer
== NULL
)
1588 n_array
[i
]->outer
= cur
;
1592 struct eh_region
*p
= cfun
->eh
->region_tree
;
1595 while (p
->next_peer
)
1597 p
->next_peer
= root
;
1600 cfun
->eh
->region_tree
= root
;
1605 i
= cfun
->eh
->last_region_number
;
1606 cfun
->eh
->last_region_number
= i
+ ifun_last_region_number
;
1612 t2r_eq (pentry
, pdata
)
1616 tree entry
= (tree
) pentry
;
1617 tree data
= (tree
) pdata
;
1619 return TREE_PURPOSE (entry
) == data
;
1626 tree entry
= (tree
) pentry
;
1627 return TYPE_HASH (TREE_PURPOSE (entry
));
1631 t2r_mark_1 (slot
, data
)
1633 PTR data ATTRIBUTE_UNUSED
;
1635 tree contents
= (tree
) *slot
;
1636 ggc_mark_tree (contents
);
1644 htab_traverse (*(htab_t
*)addr
, t2r_mark_1
, NULL
);
1648 add_type_for_runtime (type
)
1653 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
1654 TYPE_HASH (type
), INSERT
);
1657 tree runtime
= (*lang_eh_runtime_type
) (type
);
1658 *slot
= tree_cons (type
, runtime
, NULL_TREE
);
1663 lookup_type_for_runtime (type
)
1668 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
1669 TYPE_HASH (type
), NO_INSERT
);
1671 /* We should have always inserted the data earlier. */
1672 return TREE_VALUE (*slot
);
1676 /* Represent an entry in @TTypes for either catch actions
1677 or exception filter actions. */
1678 struct ttypes_filter
1684 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
1685 (a tree) for a @TTypes type node we are thinking about adding. */
1688 ttypes_filter_eq (pentry
, pdata
)
1692 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1693 tree data
= (tree
) pdata
;
1695 return entry
->t
== data
;
1699 ttypes_filter_hash (pentry
)
1702 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1703 return TYPE_HASH (entry
->t
);
1706 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
1707 exception specification list we are thinking about adding. */
1708 /* ??? Currently we use the type lists in the order given. Someone
1709 should put these in some canonical order. */
1712 ehspec_filter_eq (pentry
, pdata
)
1716 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1717 const struct ttypes_filter
*data
= (const struct ttypes_filter
*) pdata
;
1719 return type_list_equal (entry
->t
, data
->t
);
1722 /* Hash function for exception specification lists. */
1725 ehspec_filter_hash (pentry
)
1728 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1732 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
1733 h
= (h
<< 5) + (h
>> 27) + TYPE_HASH (TREE_VALUE (list
));
1737 /* Add TYPE to cfun->eh->ttype_data, using TYPES_HASH to speed
1738 up the search. Return the filter value to be used. */
1741 add_ttypes_entry (ttypes_hash
, type
)
1745 struct ttypes_filter
**slot
, *n
;
1747 slot
= (struct ttypes_filter
**)
1748 htab_find_slot_with_hash (ttypes_hash
, type
, TYPE_HASH (type
), INSERT
);
1750 if ((n
= *slot
) == NULL
)
1752 /* Filter value is a 1 based table index. */
1754 n
= (struct ttypes_filter
*) xmalloc (sizeof (*n
));
1756 n
->filter
= VARRAY_ACTIVE_SIZE (cfun
->eh
->ttype_data
) + 1;
1759 VARRAY_PUSH_TREE (cfun
->eh
->ttype_data
, type
);
1765 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
1766 to speed up the search. Return the filter value to be used. */
1769 add_ehspec_entry (ehspec_hash
, ttypes_hash
, list
)
1774 struct ttypes_filter
**slot
, *n
;
1775 struct ttypes_filter dummy
;
1778 slot
= (struct ttypes_filter
**)
1779 htab_find_slot (ehspec_hash
, &dummy
, INSERT
);
1781 if ((n
= *slot
) == NULL
)
1783 /* Filter value is a -1 based byte index into a uleb128 buffer. */
1785 n
= (struct ttypes_filter
*) xmalloc (sizeof (*n
));
1787 n
->filter
= -(VARRAY_ACTIVE_SIZE (cfun
->eh
->ehspec_data
) + 1);
1790 /* Look up each type in the list and encode its filter
1791 value as a uleb128. Terminate the list with 0. */
1792 for (; list
; list
= TREE_CHAIN (list
))
1793 push_uleb128 (&cfun
->eh
->ehspec_data
,
1794 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
1795 VARRAY_PUSH_UCHAR (cfun
->eh
->ehspec_data
, 0);
1801 /* Generate the action filter values to be used for CATCH and
1802 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
1803 we use lots of landing pads, and so every type or list can share
1804 the same filter value, which saves table space. */
1807 assign_filter_values ()
1810 htab_t ttypes
, ehspec
;
1812 VARRAY_TREE_INIT (cfun
->eh
->ttype_data
, 16, "ttype_data");
1813 VARRAY_UCHAR_INIT (cfun
->eh
->ehspec_data
, 64, "ehspec_data");
1815 ttypes
= htab_create (31, ttypes_filter_hash
, ttypes_filter_eq
, free
);
1816 ehspec
= htab_create (31, ehspec_filter_hash
, ehspec_filter_eq
, free
);
1818 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1820 struct eh_region
*r
= cfun
->eh
->region_array
[i
];
1822 /* Mind we don't process a region more than once. */
1823 if (!r
|| r
->region_number
!= i
)
1829 /* Whatever type_list is (NULL or true list), we build a list
1830 of filters for the region. */
1831 r
->u
.catch.filter_list
= NULL_TREE
;
1833 if (r
->u
.catch.type_list
!= NULL
)
1835 /* Get a filter value for each of the types caught and store
1836 them in the region's dedicated list. */
1837 tree tp_node
= r
->u
.catch.type_list
;
1839 for (;tp_node
; tp_node
= TREE_CHAIN (tp_node
))
1841 int flt
= add_ttypes_entry (ttypes
, TREE_VALUE (tp_node
));
1842 tree flt_node
= build_int_2 (flt
, 0);
1844 r
->u
.catch.filter_list
1845 = tree_cons (NULL_TREE
, flt_node
, r
->u
.catch.filter_list
);
1850 /* Get a filter value for the NULL list also since it will need
1851 an action record anyway. */
1852 int flt
= add_ttypes_entry (ttypes
, NULL
);
1853 tree flt_node
= build_int_2 (flt
, 0);
1855 r
->u
.catch.filter_list
1856 = tree_cons (NULL_TREE
, flt_node
, r
->u
.catch.filter_list
);
1861 case ERT_ALLOWED_EXCEPTIONS
:
1863 = add_ehspec_entry (ehspec
, ttypes
, r
->u
.allowed
.type_list
);
1871 htab_delete (ttypes
);
1872 htab_delete (ehspec
);
1876 build_post_landing_pads ()
1880 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1882 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
1885 /* Mind we don't process a region more than once. */
1886 if (!region
|| region
->region_number
!= i
)
1889 switch (region
->type
)
1892 /* ??? Collect the set of all non-overlapping catch handlers
1893 all the way up the chain until blocked by a cleanup. */
1894 /* ??? Outer try regions can share landing pads with inner
1895 try regions if the types are completely non-overlapping,
1896 and there are no intervening cleanups. */
1898 region
->post_landing_pad
= gen_label_rtx ();
1902 emit_label (region
->post_landing_pad
);
1904 /* ??? It is mighty inconvenient to call back into the
1905 switch statement generation code in expand_end_case.
1906 Rapid prototyping sez a sequence of ifs. */
1908 struct eh_region
*c
;
1909 for (c
= region
->u
.try.catch; c
; c
= c
->u
.catch.next_catch
)
1911 /* ??? _Unwind_ForcedUnwind wants no match here. */
1912 if (c
->u
.catch.type_list
== NULL
)
1913 emit_jump (c
->label
);
1916 /* Need for one cmp/jump per type caught. Each type
1917 list entry has a matching entry in the filter list
1918 (see assign_filter_values). */
1919 tree tp_node
= c
->u
.catch.type_list
;
1920 tree flt_node
= c
->u
.catch.filter_list
;
1924 emit_cmp_and_jump_insns
1926 GEN_INT (tree_low_cst (TREE_VALUE (flt_node
), 0)),
1927 EQ
, NULL_RTX
, word_mode
, 0, c
->label
);
1929 tp_node
= TREE_CHAIN (tp_node
);
1930 flt_node
= TREE_CHAIN (flt_node
);
1936 /* We delay the generation of the _Unwind_Resume until we generate
1937 landing pads. We emit a marker here so as to get good control
1938 flow data in the meantime. */
1940 = emit_jump_insn (gen_rtx_RESX (VOIDmode
, region
->region_number
));
1946 emit_insns_before (seq
, region
->u
.try.catch->label
);
1949 case ERT_ALLOWED_EXCEPTIONS
:
1950 region
->post_landing_pad
= gen_label_rtx ();
1954 emit_label (region
->post_landing_pad
);
1956 emit_cmp_and_jump_insns (cfun
->eh
->filter
,
1957 GEN_INT (region
->u
.allowed
.filter
),
1958 EQ
, NULL_RTX
, word_mode
, 0, region
->label
);
1960 /* We delay the generation of the _Unwind_Resume until we generate
1961 landing pads. We emit a marker here so as to get good control
1962 flow data in the meantime. */
1964 = emit_jump_insn (gen_rtx_RESX (VOIDmode
, region
->region_number
));
1970 emit_insns_before (seq
, region
->label
);
1974 case ERT_MUST_NOT_THROW
:
1975 region
->post_landing_pad
= region
->label
;
1980 /* Nothing to do. */
1989 /* Replace RESX patterns with jumps to the next handler if any, or calls to
1990 _Unwind_Resume otherwise. */
1993 connect_post_landing_pads ()
1997 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1999 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
2000 struct eh_region
*outer
;
2003 /* Mind we don't process a region more than once. */
2004 if (!region
|| region
->region_number
!= i
)
2007 /* If there is no RESX, or it has been deleted by flow, there's
2008 nothing to fix up. */
2009 if (! region
->resume
|| INSN_DELETED_P (region
->resume
))
2012 /* Search for another landing pad in this function. */
2013 for (outer
= region
->outer
; outer
; outer
= outer
->outer
)
2014 if (outer
->post_landing_pad
)
2020 emit_jump (outer
->post_landing_pad
);
2022 emit_library_call (unwind_resume_libfunc
, LCT_THROW
,
2023 VOIDmode
, 1, cfun
->eh
->exc_ptr
, Pmode
);
2027 emit_insns_before (seq
, region
->resume
);
2028 delete_insn (region
->resume
);
2034 dw2_build_landing_pads ()
2039 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
2041 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
2043 bool clobbers_hard_regs
= false;
2045 /* Mind we don't process a region more than once. */
2046 if (!region
|| region
->region_number
!= i
)
2049 if (region
->type
!= ERT_CLEANUP
2050 && region
->type
!= ERT_TRY
2051 && region
->type
!= ERT_ALLOWED_EXCEPTIONS
)
2056 region
->landing_pad
= gen_label_rtx ();
2057 emit_label (region
->landing_pad
);
2059 #ifdef HAVE_exception_receiver
2060 if (HAVE_exception_receiver
)
2061 emit_insn (gen_exception_receiver ());
2064 #ifdef HAVE_nonlocal_goto_receiver
2065 if (HAVE_nonlocal_goto_receiver
)
2066 emit_insn (gen_nonlocal_goto_receiver ());
2071 /* If the eh_return data registers are call-saved, then we
2072 won't have considered them clobbered from the call that
2073 threw. Kill them now. */
2076 unsigned r
= EH_RETURN_DATA_REGNO (j
);
2077 if (r
== INVALID_REGNUM
)
2079 if (! call_used_regs
[r
])
2081 emit_insn (gen_rtx_CLOBBER (VOIDmode
, gen_rtx_REG (Pmode
, r
)));
2082 clobbers_hard_regs
= true;
2086 if (clobbers_hard_regs
)
2088 /* @@@ This is a kludge. Not all machine descriptions define a
2089 blockage insn, but we must not allow the code we just generated
2090 to be reordered by scheduling. So emit an ASM_INPUT to act as
2092 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
2095 emit_move_insn (cfun
->eh
->exc_ptr
,
2096 gen_rtx_REG (Pmode
, EH_RETURN_DATA_REGNO (0)));
2097 emit_move_insn (cfun
->eh
->filter
,
2098 gen_rtx_REG (word_mode
, EH_RETURN_DATA_REGNO (1)));
2103 emit_insns_before (seq
, region
->post_landing_pad
);
2110 int directly_reachable
;
2113 int call_site_index
;
2117 sjlj_find_directly_reachable_regions (lp_info
)
2118 struct sjlj_lp_info
*lp_info
;
2121 bool found_one
= false;
2123 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
2125 struct eh_region
*region
;
2126 enum reachable_code rc
;
2130 if (! INSN_P (insn
))
2133 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2134 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
2137 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
2139 type_thrown
= NULL_TREE
;
2140 if (region
->type
== ERT_THROW
)
2142 type_thrown
= region
->u
.throw.type
;
2143 region
= region
->outer
;
2146 /* Find the first containing region that might handle the exception.
2147 That's the landing pad to which we will transfer control. */
2148 rc
= RNL_NOT_CAUGHT
;
2149 for (; region
; region
= region
->outer
)
2151 rc
= reachable_next_level (region
, type_thrown
, 0);
2152 if (rc
!= RNL_NOT_CAUGHT
)
2155 if (rc
== RNL_MAYBE_CAUGHT
|| rc
== RNL_CAUGHT
)
2157 lp_info
[region
->region_number
].directly_reachable
= 1;
2166 sjlj_assign_call_site_values (dispatch_label
, lp_info
)
2168 struct sjlj_lp_info
*lp_info
;
2173 /* First task: build the action table. */
2175 VARRAY_UCHAR_INIT (cfun
->eh
->action_record_data
, 64, "action_record_data");
2176 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
2178 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
2179 if (lp_info
[i
].directly_reachable
)
2181 struct eh_region
*r
= cfun
->eh
->region_array
[i
];
2182 r
->landing_pad
= dispatch_label
;
2183 lp_info
[i
].action_index
= collect_one_action_chain (ar_hash
, r
);
2184 if (lp_info
[i
].action_index
!= -1)
2185 cfun
->uses_eh_lsda
= 1;
2188 htab_delete (ar_hash
);
2190 /* Next: assign dispatch values. In dwarf2 terms, this would be the
2191 landing pad label for the region. For sjlj though, there is one
2192 common landing pad from which we dispatch to the post-landing pads.
2194 A region receives a dispatch index if it is directly reachable
2195 and requires in-function processing. Regions that share post-landing
2196 pads may share dispatch indices. */
2197 /* ??? Post-landing pad sharing doesn't actually happen at the moment
2198 (see build_post_landing_pads) so we don't bother checking for it. */
2201 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
2202 if (lp_info
[i
].directly_reachable
)
2203 lp_info
[i
].dispatch_index
= index
++;
2205 /* Finally: assign call-site values. If dwarf2 terms, this would be
2206 the region number assigned by convert_to_eh_region_ranges, but
2207 handles no-action and must-not-throw differently. */
2210 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
2211 if (lp_info
[i
].directly_reachable
)
2213 int action
= lp_info
[i
].action_index
;
2215 /* Map must-not-throw to otherwise unused call-site index 0. */
2218 /* Map no-action to otherwise unused call-site index -1. */
2219 else if (action
== -1)
2221 /* Otherwise, look it up in the table. */
2223 index
= add_call_site (GEN_INT (lp_info
[i
].dispatch_index
), action
);
2225 lp_info
[i
].call_site_index
= index
;
2230 sjlj_mark_call_sites (lp_info
)
2231 struct sjlj_lp_info
*lp_info
;
2233 int last_call_site
= -2;
2236 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
2238 struct eh_region
*region
;
2240 rtx note
, before
, p
;
2242 /* Reset value tracking at extended basic block boundaries. */
2243 if (GET_CODE (insn
) == CODE_LABEL
)
2244 last_call_site
= -2;
2246 if (! INSN_P (insn
))
2249 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2252 /* Calls (and trapping insns) without notes are outside any
2253 exception handling region in this function. Mark them as
2255 if (GET_CODE (insn
) == CALL_INSN
2256 || (flag_non_call_exceptions
2257 && may_trap_p (PATTERN (insn
))))
2258 this_call_site
= -1;
2264 /* Calls that are known to not throw need not be marked. */
2265 if (INTVAL (XEXP (note
, 0)) <= 0)
2268 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
2269 this_call_site
= lp_info
[region
->region_number
].call_site_index
;
2272 if (this_call_site
== last_call_site
)
2275 /* Don't separate a call from it's argument loads. */
2277 if (GET_CODE (insn
) == CALL_INSN
)
2278 before
= find_first_parameter_load (insn
, NULL_RTX
);
2281 mem
= adjust_address (cfun
->eh
->sjlj_fc
, TYPE_MODE (integer_type_node
),
2282 sjlj_fc_call_site_ofs
);
2283 emit_move_insn (mem
, GEN_INT (this_call_site
));
2287 emit_insns_before (p
, before
);
2288 last_call_site
= this_call_site
;
2292 /* Construct the SjLj_Function_Context. */
2295 sjlj_emit_function_enter (dispatch_label
)
2298 rtx fn_begin
, fc
, mem
, seq
;
2300 fc
= cfun
->eh
->sjlj_fc
;
2304 /* We're storing this libcall's address into memory instead of
2305 calling it directly. Thus, we must call assemble_external_libcall
2306 here, as we can not depend on emit_library_call to do it for us. */
2307 assemble_external_libcall (eh_personality_libfunc
);
2308 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
2309 emit_move_insn (mem
, eh_personality_libfunc
);
2311 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
2312 if (cfun
->uses_eh_lsda
)
2315 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", sjlj_funcdef_number
);
2316 emit_move_insn (mem
, gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
)));
2319 emit_move_insn (mem
, const0_rtx
);
2321 #ifdef DONT_USE_BUILTIN_SETJMP
2324 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
2325 TYPE_MODE (integer_type_node
), 1,
2326 plus_constant (XEXP (fc
, 0),
2327 sjlj_fc_jbuf_ofs
), Pmode
);
2329 note
= emit_note (NULL
, NOTE_INSN_EXPECTED_VALUE
);
2330 NOTE_EXPECTED_VALUE (note
) = gen_rtx_EQ (VOIDmode
, x
, const0_rtx
);
2332 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
2333 TYPE_MODE (integer_type_node
), 0, dispatch_label
);
2336 expand_builtin_setjmp_setup (plus_constant (XEXP (fc
, 0), sjlj_fc_jbuf_ofs
),
2340 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
2341 1, XEXP (fc
, 0), Pmode
);
2346 /* ??? Instead of doing this at the beginning of the function,
2347 do this in a block that is at loop level 0 and dominates all
2348 can_throw_internal instructions. */
2350 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
2351 if (GET_CODE (fn_begin
) == NOTE
2352 && NOTE_LINE_NUMBER (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
2354 emit_insns_after (seq
, fn_begin
);
2357 /* Call back from expand_function_end to know where we should put
2358 the call to unwind_sjlj_unregister_libfunc if needed. */
2361 sjlj_emit_function_exit_after (after
)
2364 cfun
->eh
->sjlj_exit_after
= after
;
2368 sjlj_emit_function_exit ()
2374 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
2375 1, XEXP (cfun
->eh
->sjlj_fc
, 0), Pmode
);
2380 /* ??? Really this can be done in any block at loop level 0 that
2381 post-dominates all can_throw_internal instructions. This is
2382 the last possible moment. */
2384 emit_insns_after (seq
, cfun
->eh
->sjlj_exit_after
);
2388 sjlj_emit_dispatch_table (dispatch_label
, lp_info
)
2390 struct sjlj_lp_info
*lp_info
;
2392 int i
, first_reachable
;
2393 rtx mem
, dispatch
, seq
, fc
;
2395 fc
= cfun
->eh
->sjlj_fc
;
2399 emit_label (dispatch_label
);
2401 #ifndef DONT_USE_BUILTIN_SETJMP
2402 expand_builtin_setjmp_receiver (dispatch_label
);
2405 /* Load up dispatch index, exc_ptr and filter values from the
2406 function context. */
2407 mem
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
2408 sjlj_fc_call_site_ofs
);
2409 dispatch
= copy_to_reg (mem
);
2411 mem
= adjust_address (fc
, word_mode
, sjlj_fc_data_ofs
);
2412 if (word_mode
!= Pmode
)
2414 #ifdef POINTERS_EXTEND_UNSIGNED
2415 mem
= convert_memory_address (Pmode
, mem
);
2417 mem
= convert_to_mode (Pmode
, mem
, 0);
2420 emit_move_insn (cfun
->eh
->exc_ptr
, mem
);
2422 mem
= adjust_address (fc
, word_mode
, sjlj_fc_data_ofs
+ UNITS_PER_WORD
);
2423 emit_move_insn (cfun
->eh
->filter
, mem
);
2425 /* Jump to one of the directly reachable regions. */
2426 /* ??? This really ought to be using a switch statement. */
2428 first_reachable
= 0;
2429 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
2431 if (! lp_info
[i
].directly_reachable
)
2434 if (! first_reachable
)
2436 first_reachable
= i
;
2440 emit_cmp_and_jump_insns (dispatch
, GEN_INT (lp_info
[i
].dispatch_index
),
2441 EQ
, NULL_RTX
, TYPE_MODE (integer_type_node
), 0,
2442 cfun
->eh
->region_array
[i
]->post_landing_pad
);
2448 emit_insns_before (seq
, (cfun
->eh
->region_array
[first_reachable
]
2449 ->post_landing_pad
));
2453 sjlj_build_landing_pads ()
2455 struct sjlj_lp_info
*lp_info
;
2457 lp_info
= (struct sjlj_lp_info
*) xcalloc (cfun
->eh
->last_region_number
+ 1,
2458 sizeof (struct sjlj_lp_info
));
2460 if (sjlj_find_directly_reachable_regions (lp_info
))
2462 rtx dispatch_label
= gen_label_rtx ();
2465 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
2466 int_size_in_bytes (sjlj_fc_type_node
),
2467 TYPE_ALIGN (sjlj_fc_type_node
));
2469 sjlj_assign_call_site_values (dispatch_label
, lp_info
);
2470 sjlj_mark_call_sites (lp_info
);
2472 sjlj_emit_function_enter (dispatch_label
);
2473 sjlj_emit_dispatch_table (dispatch_label
, lp_info
);
2474 sjlj_emit_function_exit ();
2481 finish_eh_generation ()
2483 /* Nothing to do if no regions created. */
2484 if (cfun
->eh
->region_tree
== NULL
)
2487 /* The object here is to provide find_basic_blocks with detailed
2488 information (via reachable_handlers) on how exception control
2489 flows within the function. In this first pass, we can include
2490 type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS
2491 regions, and hope that it will be useful in deleting unreachable
2492 handlers. Subsequently, we will generate landing pads which will
2493 connect many of the handlers, and then type information will not
2494 be effective. Still, this is a win over previous implementations. */
2496 rebuild_jump_labels (get_insns ());
2497 find_basic_blocks (get_insns (), max_reg_num (), 0);
2498 cleanup_cfg (CLEANUP_PRE_LOOP
);
2500 /* These registers are used by the landing pads. Make sure they
2501 have been generated. */
2502 get_exception_pointer (cfun
);
2503 get_exception_filter (cfun
);
2505 /* Construct the landing pads. */
2507 assign_filter_values ();
2508 build_post_landing_pads ();
2509 connect_post_landing_pads ();
2510 if (USING_SJLJ_EXCEPTIONS
)
2511 sjlj_build_landing_pads ();
2513 dw2_build_landing_pads ();
2515 cfun
->eh
->built_landing_pads
= 1;
2517 /* We've totally changed the CFG. Start over. */
2518 find_exception_handler_labels ();
2519 rebuild_jump_labels (get_insns ());
2520 find_basic_blocks (get_insns (), max_reg_num (), 0);
2521 cleanup_cfg (CLEANUP_PRE_LOOP
);
2528 struct ehl_map_entry
*entry
= (struct ehl_map_entry
*) pentry
;
2530 /* 2^32 * ((sqrt(5) - 1) / 2) */
2531 const hashval_t scaled_golden_ratio
= 0x9e3779b9;
2532 return CODE_LABEL_NUMBER (entry
->label
) * scaled_golden_ratio
;
2536 ehl_eq (pentry
, pdata
)
2540 struct ehl_map_entry
*entry
= (struct ehl_map_entry
*) pentry
;
2541 struct ehl_map_entry
*data
= (struct ehl_map_entry
*) pdata
;
2543 return entry
->label
== data
->label
;
2546 /* This section handles removing dead code for flow. */
2548 /* Remove LABEL from exception_handler_label_map. */
2551 remove_exception_handler_label (label
)
2554 struct ehl_map_entry
**slot
, tmp
;
2556 /* If exception_handler_label_map was not built yet,
2557 there is nothing to do. */
2558 if (exception_handler_label_map
== NULL
)
2562 slot
= (struct ehl_map_entry
**)
2563 htab_find_slot (exception_handler_label_map
, &tmp
, NO_INSERT
);
2567 htab_clear_slot (exception_handler_label_map
, (void **) slot
);
2570 /* Splice REGION from the region tree etc. */
2573 remove_eh_handler (region
)
2574 struct eh_region
*region
;
2576 struct eh_region
**pp
, *p
;
2579 /* For the benefit of efficiently handling REG_EH_REGION notes,
2580 replace this region in the region array with its containing
2581 region. Note that previous region deletions may result in
2582 multiple copies of this region in the array, so we have a
2583 list of alternate numbers by which we are known. */
2585 cfun
->eh
->region_array
[region
->region_number
] = region
->outer
;
2589 EXECUTE_IF_SET_IN_BITMAP (region
->aka
, 0, i
,
2590 { cfun
->eh
->region_array
[i
] = region
->outer
; });
2595 if (!region
->outer
->aka
)
2596 region
->outer
->aka
= BITMAP_XMALLOC ();
2598 bitmap_a_or_b (region
->outer
->aka
, region
->outer
->aka
, region
->aka
);
2599 bitmap_set_bit (region
->outer
->aka
, region
->region_number
);
2602 if (cfun
->eh
->built_landing_pads
)
2603 lab
= region
->landing_pad
;
2605 lab
= region
->label
;
2607 remove_exception_handler_label (lab
);
2610 pp
= ®ion
->outer
->inner
;
2612 pp
= &cfun
->eh
->region_tree
;
2613 for (p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
2618 for (p
= region
->inner
; p
->next_peer
; p
= p
->next_peer
)
2619 p
->outer
= region
->outer
;
2620 p
->next_peer
= region
->next_peer
;
2621 p
->outer
= region
->outer
;
2622 *pp
= region
->inner
;
2625 *pp
= region
->next_peer
;
2627 if (region
->type
== ERT_CATCH
)
2629 struct eh_region
*try, *next
, *prev
;
2631 for (try = region
->next_peer
;
2632 try->type
== ERT_CATCH
;
2633 try = try->next_peer
)
2635 if (try->type
!= ERT_TRY
)
2638 next
= region
->u
.catch.next_catch
;
2639 prev
= region
->u
.catch.prev_catch
;
2642 next
->u
.catch.prev_catch
= prev
;
2644 try->u
.try.last_catch
= prev
;
2646 prev
->u
.catch.next_catch
= next
;
2649 try->u
.try.catch = next
;
2651 remove_eh_handler (try);
2655 free_region (region
);
2658 /* LABEL heads a basic block that is about to be deleted. If this
2659 label corresponds to an exception region, we may be able to
2660 delete the region. */
2663 maybe_remove_eh_handler (label
)
2666 struct ehl_map_entry
**slot
, tmp
;
2667 struct eh_region
*region
;
2669 /* ??? After generating landing pads, it's not so simple to determine
2670 if the region data is completely unused. One must examine the
2671 landing pad and the post landing pad, and whether an inner try block
2672 is referencing the catch handlers directly. */
2673 if (cfun
->eh
->built_landing_pads
)
2677 slot
= (struct ehl_map_entry
**)
2678 htab_find_slot (exception_handler_label_map
, &tmp
, NO_INSERT
);
2681 region
= (*slot
)->region
;
2685 /* Flow will want to remove MUST_NOT_THROW regions as unreachable
2686 because there is no path to the fallback call to terminate.
2687 But the region continues to affect call-site data until there
2688 are no more contained calls, which we don't see here. */
2689 if (region
->type
== ERT_MUST_NOT_THROW
)
2691 htab_clear_slot (exception_handler_label_map
, (void **) slot
);
2692 region
->label
= NULL_RTX
;
2695 remove_eh_handler (region
);
2698 /* Invokes CALLBACK for every exception handler label. Only used by old
2699 loop hackery; should not be used by new code. */
2702 for_each_eh_label (callback
)
2703 void (*callback
) PARAMS ((rtx
));
2705 htab_traverse (exception_handler_label_map
, for_each_eh_label_1
,
2710 for_each_eh_label_1 (pentry
, data
)
2714 struct ehl_map_entry
*entry
= *(struct ehl_map_entry
**)pentry
;
2715 void (*callback
) PARAMS ((rtx
)) = (void (*) PARAMS ((rtx
))) data
;
2717 (*callback
) (entry
->label
);
2721 /* This section describes CFG exception edges for flow. */
2723 /* For communicating between calls to reachable_next_level. */
2724 struct reachable_info
2731 /* A subroutine of reachable_next_level. Return true if TYPE, or a
2732 base class of TYPE, is in HANDLED. */
2735 check_handled (handled
, type
)
2740 /* We can check for exact matches without front-end help. */
2741 if (! lang_eh_type_covers
)
2743 for (t
= handled
; t
; t
= TREE_CHAIN (t
))
2744 if (TREE_VALUE (t
) == type
)
2749 for (t
= handled
; t
; t
= TREE_CHAIN (t
))
2750 if ((*lang_eh_type_covers
) (TREE_VALUE (t
), type
))
2757 /* A subroutine of reachable_next_level. If we are collecting a list
2758 of handlers, add one. After landing pad generation, reference
2759 it instead of the handlers themselves. Further, the handlers are
2760 all wired together, so by referencing one, we've got them all.
2761 Before landing pad generation we reference each handler individually.
2763 LP_REGION contains the landing pad; REGION is the handler. */
2766 add_reachable_handler (info
, lp_region
, region
)
2767 struct reachable_info
*info
;
2768 struct eh_region
*lp_region
;
2769 struct eh_region
*region
;
2774 if (cfun
->eh
->built_landing_pads
)
2776 if (! info
->handlers
)
2777 info
->handlers
= alloc_INSN_LIST (lp_region
->landing_pad
, NULL_RTX
);
2780 info
->handlers
= alloc_INSN_LIST (region
->label
, info
->handlers
);
2783 /* Process one level of exception regions for reachability.
2784 If TYPE_THROWN is non-null, then it is the *exact* type being
2785 propagated. If INFO is non-null, then collect handler labels
2786 and caught/allowed type information between invocations. */
2788 static enum reachable_code
2789 reachable_next_level (region
, type_thrown
, info
)
2790 struct eh_region
*region
;
2792 struct reachable_info
*info
;
2794 switch (region
->type
)
2797 /* Before landing-pad generation, we model control flow
2798 directly to the individual handlers. In this way we can
2799 see that catch handler types may shadow one another. */
2800 add_reachable_handler (info
, region
, region
);
2801 return RNL_MAYBE_CAUGHT
;
2805 struct eh_region
*c
;
2806 enum reachable_code ret
= RNL_NOT_CAUGHT
;
2808 for (c
= region
->u
.try.catch; c
; c
= c
->u
.catch.next_catch
)
2810 /* A catch-all handler ends the search. */
2811 /* ??? _Unwind_ForcedUnwind will want outer cleanups
2812 to be run as well. */
2813 if (c
->u
.catch.type_list
== NULL
)
2815 add_reachable_handler (info
, region
, c
);
2821 /* If we have at least one type match, end the search. */
2822 tree tp_node
= c
->u
.catch.type_list
;
2824 for (; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
2826 tree type
= TREE_VALUE (tp_node
);
2828 if (type
== type_thrown
2829 || (lang_eh_type_covers
2830 && (*lang_eh_type_covers
) (type
, type_thrown
)))
2832 add_reachable_handler (info
, region
, c
);
2837 /* If we have definitive information of a match failure,
2838 the catch won't trigger. */
2839 if (lang_eh_type_covers
)
2840 return RNL_NOT_CAUGHT
;
2843 /* At this point, we either don't know what type is thrown or
2844 don't have front-end assistance to help deciding if it is
2845 covered by one of the types in the list for this region.
2847 We'd then like to add this region to the list of reachable
2848 handlers since it is indeed potentially reachable based on the
2849 information we have.
2851 Actually, this handler is for sure not reachable if all the
2852 types it matches have already been caught. That is, it is only
2853 potentially reachable if at least one of the types it catches
2854 has not been previously caught. */
2857 ret
= RNL_MAYBE_CAUGHT
;
2860 tree tp_node
= c
->u
.catch.type_list
;
2861 bool maybe_reachable
= false;
2863 /* Compute the potential reachability of this handler and
2864 update the list of types caught at the same time. */
2865 for (; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
2867 tree type
= TREE_VALUE (tp_node
);
2869 if (! check_handled (info
->types_caught
, type
))
2872 = tree_cons (NULL
, type
, info
->types_caught
);
2874 maybe_reachable
= true;
2878 if (maybe_reachable
)
2880 add_reachable_handler (info
, region
, c
);
2882 /* ??? If the catch type is a base class of every allowed
2883 type, then we know we can stop the search. */
2884 ret
= RNL_MAYBE_CAUGHT
;
2892 case ERT_ALLOWED_EXCEPTIONS
:
2893 /* An empty list of types definitely ends the search. */
2894 if (region
->u
.allowed
.type_list
== NULL_TREE
)
2896 add_reachable_handler (info
, region
, region
);
2900 /* Collect a list of lists of allowed types for use in detecting
2901 when a catch may be transformed into a catch-all. */
2903 info
->types_allowed
= tree_cons (NULL_TREE
,
2904 region
->u
.allowed
.type_list
,
2905 info
->types_allowed
);
2907 /* If we have definitive information about the type hierarchy,
2908 then we can tell if the thrown type will pass through the
2910 if (type_thrown
&& lang_eh_type_covers
)
2912 if (check_handled (region
->u
.allowed
.type_list
, type_thrown
))
2913 return RNL_NOT_CAUGHT
;
2916 add_reachable_handler (info
, region
, region
);
2921 add_reachable_handler (info
, region
, region
);
2922 return RNL_MAYBE_CAUGHT
;
2925 /* Catch regions are handled by their controling try region. */
2926 return RNL_NOT_CAUGHT
;
2928 case ERT_MUST_NOT_THROW
:
2929 /* Here we end our search, since no exceptions may propagate.
2930 If we've touched down at some landing pad previous, then the
2931 explicit function call we generated may be used. Otherwise
2932 the call is made by the runtime. */
2933 if (info
&& info
->handlers
)
2935 add_reachable_handler (info
, region
, region
);
2944 /* Shouldn't see these here. */
2951 /* Retrieve a list of labels of exception handlers which can be
2952 reached by a given insn. */
2955 reachable_handlers (insn
)
2958 struct reachable_info info
;
2959 struct eh_region
*region
;
2963 if (GET_CODE (insn
) == JUMP_INSN
2964 && GET_CODE (PATTERN (insn
)) == RESX
)
2965 region_number
= XINT (PATTERN (insn
), 0);
2968 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2969 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
2971 region_number
= INTVAL (XEXP (note
, 0));
2974 memset (&info
, 0, sizeof (info
));
2976 region
= cfun
->eh
->region_array
[region_number
];
2978 type_thrown
= NULL_TREE
;
2979 if (GET_CODE (insn
) == JUMP_INSN
2980 && GET_CODE (PATTERN (insn
)) == RESX
)
2982 /* A RESX leaves a region instead of entering it. Thus the
2983 region itself may have been deleted out from under us. */
2986 region
= region
->outer
;
2988 else if (region
->type
== ERT_THROW
)
2990 type_thrown
= region
->u
.throw.type
;
2991 region
= region
->outer
;
2994 for (; region
; region
= region
->outer
)
2995 if (reachable_next_level (region
, type_thrown
, &info
) >= RNL_CAUGHT
)
2998 return info
.handlers
;
3001 /* Determine if the given INSN can throw an exception that is caught
3002 within the function. */
3005 can_throw_internal (insn
)
3008 struct eh_region
*region
;
3012 if (! INSN_P (insn
))
3015 if (GET_CODE (insn
) == INSN
3016 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
3017 insn
= XVECEXP (PATTERN (insn
), 0, 0);
3019 if (GET_CODE (insn
) == CALL_INSN
3020 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
3023 for (i
= 0; i
< 3; ++i
)
3025 rtx sub
= XEXP (PATTERN (insn
), i
);
3026 for (; sub
; sub
= NEXT_INSN (sub
))
3027 if (can_throw_internal (sub
))
3033 /* Every insn that might throw has an EH_REGION note. */
3034 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
3035 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
3038 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
3040 type_thrown
= NULL_TREE
;
3041 if (region
->type
== ERT_THROW
)
3043 type_thrown
= region
->u
.throw.type
;
3044 region
= region
->outer
;
3047 /* If this exception is ignored by each and every containing region,
3048 then control passes straight out. The runtime may handle some
3049 regions, which also do not require processing internally. */
3050 for (; region
; region
= region
->outer
)
3052 enum reachable_code how
= reachable_next_level (region
, type_thrown
, 0);
3053 if (how
== RNL_BLOCKED
)
3055 if (how
!= RNL_NOT_CAUGHT
)
3062 /* Determine if the given INSN can throw an exception that is
3063 visible outside the function. */
3066 can_throw_external (insn
)
3069 struct eh_region
*region
;
3073 if (! INSN_P (insn
))
3076 if (GET_CODE (insn
) == INSN
3077 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
3078 insn
= XVECEXP (PATTERN (insn
), 0, 0);
3080 if (GET_CODE (insn
) == CALL_INSN
3081 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
3084 for (i
= 0; i
< 3; ++i
)
3086 rtx sub
= XEXP (PATTERN (insn
), i
);
3087 for (; sub
; sub
= NEXT_INSN (sub
))
3088 if (can_throw_external (sub
))
3094 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
3097 /* Calls (and trapping insns) without notes are outside any
3098 exception handling region in this function. We have to
3099 assume it might throw. Given that the front end and middle
3100 ends mark known NOTHROW functions, this isn't so wildly
3102 return (GET_CODE (insn
) == CALL_INSN
3103 || (flag_non_call_exceptions
3104 && may_trap_p (PATTERN (insn
))));
3106 if (INTVAL (XEXP (note
, 0)) <= 0)
3109 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
3111 type_thrown
= NULL_TREE
;
3112 if (region
->type
== ERT_THROW
)
3114 type_thrown
= region
->u
.throw.type
;
3115 region
= region
->outer
;
3118 /* If the exception is caught or blocked by any containing region,
3119 then it is not seen by any calling function. */
3120 for (; region
; region
= region
->outer
)
3121 if (reachable_next_level (region
, type_thrown
, NULL
) >= RNL_CAUGHT
)
3127 /* True if nothing in this function can throw outside this function. */
3130 nothrow_function_p ()
3134 if (! flag_exceptions
)
3137 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3138 if (can_throw_external (insn
))
3140 for (insn
= current_function_epilogue_delay_list
; insn
;
3141 insn
= XEXP (insn
, 1))
3142 if (can_throw_external (insn
))
3149 /* Various hooks for unwind library. */
3151 /* Do any necessary initialization to access arbitrary stack frames.
3152 On the SPARC, this means flushing the register windows. */
3155 expand_builtin_unwind_init ()
3157 /* Set this so all the registers get saved in our frame; we need to be
3158 able to copy the saved values for any registers from frames we unwind. */
3159 current_function_has_nonlocal_label
= 1;
3161 #ifdef SETUP_FRAME_ADDRESSES
3162 SETUP_FRAME_ADDRESSES ();
3167 expand_builtin_eh_return_data_regno (arglist
)
3170 tree which
= TREE_VALUE (arglist
);
3171 unsigned HOST_WIDE_INT iwhich
;
3173 if (TREE_CODE (which
) != INTEGER_CST
)
3175 error ("argument of `__builtin_eh_return_regno' must be constant");
3179 iwhich
= tree_low_cst (which
, 1);
3180 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
3181 if (iwhich
== INVALID_REGNUM
)
3184 #ifdef DWARF_FRAME_REGNUM
3185 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
3187 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
3190 return GEN_INT (iwhich
);
3193 /* Given a value extracted from the return address register or stack slot,
3194 return the actual address encoded in that value. */
3197 expand_builtin_extract_return_addr (addr_tree
)
3200 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, 0);
3202 /* First mask out any unwanted bits. */
3203 #ifdef MASK_RETURN_ADDR
3204 expand_and (Pmode
, addr
, MASK_RETURN_ADDR
, addr
);
3207 /* Then adjust to find the real return address. */
3208 #if defined (RETURN_ADDR_OFFSET)
3209 addr
= plus_constant (addr
, RETURN_ADDR_OFFSET
);
3215 /* Given an actual address in addr_tree, do any necessary encoding
3216 and return the value to be stored in the return address register or
3217 stack slot so the epilogue will return to that address. */
3220 expand_builtin_frob_return_addr (addr_tree
)
3223 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, 0);
3225 #ifdef POINTERS_EXTEND_UNSIGNED
3226 if (GET_MODE (addr
) != Pmode
)
3227 addr
= convert_memory_address (Pmode
, addr
);
3230 #ifdef RETURN_ADDR_OFFSET
3231 addr
= force_reg (Pmode
, addr
);
3232 addr
= plus_constant (addr
, -RETURN_ADDR_OFFSET
);
3238 /* Set up the epilogue with the magic bits we'll need to return to the
3239 exception handler. */
3242 expand_builtin_eh_return (stackadj_tree
, handler_tree
)
3243 tree stackadj_tree
, handler_tree
;
3245 rtx stackadj
, handler
;
3247 stackadj
= expand_expr (stackadj_tree
, cfun
->eh
->ehr_stackadj
, VOIDmode
, 0);
3248 handler
= expand_expr (handler_tree
, cfun
->eh
->ehr_handler
, VOIDmode
, 0);
3250 #ifdef POINTERS_EXTEND_UNSIGNED
3251 if (GET_MODE (stackadj
) != Pmode
)
3252 stackadj
= convert_memory_address (Pmode
, stackadj
);
3254 if (GET_MODE (handler
) != Pmode
)
3255 handler
= convert_memory_address (Pmode
, handler
);
3258 if (! cfun
->eh
->ehr_label
)
3260 cfun
->eh
->ehr_stackadj
= copy_to_reg (stackadj
);
3261 cfun
->eh
->ehr_handler
= copy_to_reg (handler
);
3262 cfun
->eh
->ehr_label
= gen_label_rtx ();
3266 if (stackadj
!= cfun
->eh
->ehr_stackadj
)
3267 emit_move_insn (cfun
->eh
->ehr_stackadj
, stackadj
);
3268 if (handler
!= cfun
->eh
->ehr_handler
)
3269 emit_move_insn (cfun
->eh
->ehr_handler
, handler
);
3272 emit_jump (cfun
->eh
->ehr_label
);
3278 rtx sa
, ra
, around_label
;
3280 if (! cfun
->eh
->ehr_label
)
3283 sa
= EH_RETURN_STACKADJ_RTX
;
3286 error ("__builtin_eh_return not supported on this target");
3290 current_function_calls_eh_return
= 1;
3292 around_label
= gen_label_rtx ();
3293 emit_move_insn (sa
, const0_rtx
);
3294 emit_jump (around_label
);
3296 emit_label (cfun
->eh
->ehr_label
);
3297 clobber_return_register ();
3299 #ifdef HAVE_eh_return
3301 emit_insn (gen_eh_return (cfun
->eh
->ehr_stackadj
, cfun
->eh
->ehr_handler
));
3305 ra
= EH_RETURN_HANDLER_RTX
;
3308 error ("__builtin_eh_return not supported on this target");
3309 ra
= gen_reg_rtx (Pmode
);
3312 emit_move_insn (sa
, cfun
->eh
->ehr_stackadj
);
3313 emit_move_insn (ra
, cfun
->eh
->ehr_handler
);
3316 emit_label (around_label
);
3319 /* In the following functions, we represent entries in the action table
3320 as 1-based indices. Special cases are:
3322 0: null action record, non-null landing pad; implies cleanups
3323 -1: null action record, null landing pad; implies no action
3324 -2: no call-site entry; implies must_not_throw
3325 -3: we have yet to process outer regions
3327 Further, no special cases apply to the "next" field of the record.
3328 For next, 0 means end of list. */
3330 struct action_record
3338 action_record_eq (pentry
, pdata
)
3342 const struct action_record
*entry
= (const struct action_record
*) pentry
;
3343 const struct action_record
*data
= (const struct action_record
*) pdata
;
3344 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
3348 action_record_hash (pentry
)
3351 const struct action_record
*entry
= (const struct action_record
*) pentry
;
3352 return entry
->next
* 1009 + entry
->filter
;
3356 add_action_record (ar_hash
, filter
, next
)
3360 struct action_record
**slot
, *new, tmp
;
3362 tmp
.filter
= filter
;
3364 slot
= (struct action_record
**) htab_find_slot (ar_hash
, &tmp
, INSERT
);
3366 if ((new = *slot
) == NULL
)
3368 new = (struct action_record
*) xmalloc (sizeof (*new));
3369 new->offset
= VARRAY_ACTIVE_SIZE (cfun
->eh
->action_record_data
) + 1;
3370 new->filter
= filter
;
3374 /* The filter value goes in untouched. The link to the next
3375 record is a "self-relative" byte offset, or zero to indicate
3376 that there is no next record. So convert the absolute 1 based
3377 indices we've been carrying around into a displacement. */
3379 push_sleb128 (&cfun
->eh
->action_record_data
, filter
);
3381 next
-= VARRAY_ACTIVE_SIZE (cfun
->eh
->action_record_data
) + 1;
3382 push_sleb128 (&cfun
->eh
->action_record_data
, next
);
3389 collect_one_action_chain (ar_hash
, region
)
3391 struct eh_region
*region
;
3393 struct eh_region
*c
;
3396 /* If we've reached the top of the region chain, then we have
3397 no actions, and require no landing pad. */
3401 switch (region
->type
)
3404 /* A cleanup adds a zero filter to the beginning of the chain, but
3405 there are special cases to look out for. If there are *only*
3406 cleanups along a path, then it compresses to a zero action.
3407 Further, if there are multiple cleanups along a path, we only
3408 need to represent one of them, as that is enough to trigger
3409 entry to the landing pad at runtime. */
3410 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3413 for (c
= region
->outer
; c
; c
= c
->outer
)
3414 if (c
->type
== ERT_CLEANUP
)
3416 return add_action_record (ar_hash
, 0, next
);
3419 /* Process the associated catch regions in reverse order.
3420 If there's a catch-all handler, then we don't need to
3421 search outer regions. Use a magic -3 value to record
3422 that we haven't done the outer search. */
3424 for (c
= region
->u
.try.last_catch
; c
; c
= c
->u
.catch.prev_catch
)
3426 if (c
->u
.catch.type_list
== NULL
)
3428 /* Retrieve the filter from the head of the filter list
3429 where we have stored it (see assign_filter_values). */
3431 = TREE_INT_CST_LOW (TREE_VALUE (c
->u
.catch.filter_list
));
3433 next
= add_action_record (ar_hash
, filter
, 0);
3437 /* Once the outer search is done, trigger an action record for
3438 each filter we have. */
3443 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3445 /* If there is no next action, terminate the chain. */
3448 /* If all outer actions are cleanups or must_not_throw,
3449 we'll have no action record for it, since we had wanted
3450 to encode these states in the call-site record directly.
3451 Add a cleanup action to the chain to catch these. */
3453 next
= add_action_record (ar_hash
, 0, 0);
3456 flt_node
= c
->u
.catch.filter_list
;
3457 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
3459 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
3460 next
= add_action_record (ar_hash
, filter
, next
);
3466 case ERT_ALLOWED_EXCEPTIONS
:
3467 /* An exception specification adds its filter to the
3468 beginning of the chain. */
3469 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3470 return add_action_record (ar_hash
, region
->u
.allowed
.filter
,
3471 next
< 0 ? 0 : next
);
3473 case ERT_MUST_NOT_THROW
:
3474 /* A must-not-throw region with no inner handlers or cleanups
3475 requires no call-site entry. Note that this differs from
3476 the no handler or cleanup case in that we do require an lsda
3477 to be generated. Return a magic -2 value to record this. */
3482 /* CATCH regions are handled in TRY above. THROW regions are
3483 for optimization information only and produce no output. */
3484 return collect_one_action_chain (ar_hash
, region
->outer
);
3492 add_call_site (landing_pad
, action
)
3496 struct call_site_record
*data
= cfun
->eh
->call_site_data
;
3497 int used
= cfun
->eh
->call_site_data_used
;
3498 int size
= cfun
->eh
->call_site_data_size
;
3502 size
= (size
? size
* 2 : 64);
3503 data
= (struct call_site_record
*)
3504 xrealloc (data
, sizeof (*data
) * size
);
3505 cfun
->eh
->call_site_data
= data
;
3506 cfun
->eh
->call_site_data_size
= size
;
3509 data
[used
].landing_pad
= landing_pad
;
3510 data
[used
].action
= action
;
3512 cfun
->eh
->call_site_data_used
= used
+ 1;
3514 return used
+ call_site_base
;
3517 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
3518 The new note numbers will not refer to region numbers, but
3519 instead to call site entries. */
3522 convert_to_eh_region_ranges ()
3524 rtx insn
, iter
, note
;
3526 int last_action
= -3;
3527 rtx last_action_insn
= NULL_RTX
;
3528 rtx last_landing_pad
= NULL_RTX
;
3529 rtx first_no_action_insn
= NULL_RTX
;
3532 if (USING_SJLJ_EXCEPTIONS
|| cfun
->eh
->region_tree
== NULL
)
3535 VARRAY_UCHAR_INIT (cfun
->eh
->action_record_data
, 64, "action_record_data");
3537 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
3539 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
3542 struct eh_region
*region
;
3544 rtx this_landing_pad
;
3547 if (GET_CODE (insn
) == INSN
3548 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
3549 insn
= XVECEXP (PATTERN (insn
), 0, 0);
3551 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
3554 if (! (GET_CODE (insn
) == CALL_INSN
3555 || (flag_non_call_exceptions
3556 && may_trap_p (PATTERN (insn
)))))
3563 if (INTVAL (XEXP (note
, 0)) <= 0)
3565 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
3566 this_action
= collect_one_action_chain (ar_hash
, region
);
3569 /* Existence of catch handlers, or must-not-throw regions
3570 implies that an lsda is needed (even if empty). */
3571 if (this_action
!= -1)
3572 cfun
->uses_eh_lsda
= 1;
3574 /* Delay creation of region notes for no-action regions
3575 until we're sure that an lsda will be required. */
3576 else if (last_action
== -3)
3578 first_no_action_insn
= iter
;
3582 /* Cleanups and handlers may share action chains but not
3583 landing pads. Collect the landing pad for this region. */
3584 if (this_action
>= 0)
3586 struct eh_region
*o
;
3587 for (o
= region
; ! o
->landing_pad
; o
= o
->outer
)
3589 this_landing_pad
= o
->landing_pad
;
3592 this_landing_pad
= NULL_RTX
;
3594 /* Differing actions or landing pads implies a change in call-site
3595 info, which implies some EH_REGION note should be emitted. */
3596 if (last_action
!= this_action
3597 || last_landing_pad
!= this_landing_pad
)
3599 /* If we'd not seen a previous action (-3) or the previous
3600 action was must-not-throw (-2), then we do not need an
3602 if (last_action
>= -1)
3604 /* If we delayed the creation of the begin, do it now. */
3605 if (first_no_action_insn
)
3607 call_site
= add_call_site (NULL_RTX
, 0);
3608 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
3609 first_no_action_insn
);
3610 NOTE_EH_HANDLER (note
) = call_site
;
3611 first_no_action_insn
= NULL_RTX
;
3614 note
= emit_note_after (NOTE_INSN_EH_REGION_END
,
3616 NOTE_EH_HANDLER (note
) = call_site
;
3619 /* If the new action is must-not-throw, then no region notes
3621 if (this_action
>= -1)
3623 call_site
= add_call_site (this_landing_pad
,
3624 this_action
< 0 ? 0 : this_action
);
3625 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
3626 NOTE_EH_HANDLER (note
) = call_site
;
3629 last_action
= this_action
;
3630 last_landing_pad
= this_landing_pad
;
3632 last_action_insn
= iter
;
3635 if (last_action
>= -1 && ! first_no_action_insn
)
3637 note
= emit_note_after (NOTE_INSN_EH_REGION_END
, last_action_insn
);
3638 NOTE_EH_HANDLER (note
) = call_site
;
3641 htab_delete (ar_hash
);
3646 push_uleb128 (data_area
, value
)
3647 varray_type
*data_area
;
3652 unsigned char byte
= value
& 0x7f;
3656 VARRAY_PUSH_UCHAR (*data_area
, byte
);
3662 push_sleb128 (data_area
, value
)
3663 varray_type
*data_area
;
3671 byte
= value
& 0x7f;
3673 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
3674 || (value
== -1 && (byte
& 0x40) != 0));
3677 VARRAY_PUSH_UCHAR (*data_area
, byte
);
3683 #ifndef HAVE_AS_LEB128
3685 dw2_size_of_call_site_table ()
3687 int n
= cfun
->eh
->call_site_data_used
;
3688 int size
= n
* (4 + 4 + 4);
3691 for (i
= 0; i
< n
; ++i
)
3693 struct call_site_record
*cs
= &cfun
->eh
->call_site_data
[i
];
3694 size
+= size_of_uleb128 (cs
->action
);
3701 sjlj_size_of_call_site_table ()
3703 int n
= cfun
->eh
->call_site_data_used
;
3707 for (i
= 0; i
< n
; ++i
)
3709 struct call_site_record
*cs
= &cfun
->eh
->call_site_data
[i
];
3710 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
3711 size
+= size_of_uleb128 (cs
->action
);
3719 dw2_output_call_site_table ()
3721 const char *const function_start_lab
3722 = IDENTIFIER_POINTER (current_function_func_begin_label
);
3723 int n
= cfun
->eh
->call_site_data_used
;
3726 for (i
= 0; i
< n
; ++i
)
3728 struct call_site_record
*cs
= &cfun
->eh
->call_site_data
[i
];
3729 char reg_start_lab
[32];
3730 char reg_end_lab
[32];
3731 char landing_pad_lab
[32];
3733 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
3734 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
3736 if (cs
->landing_pad
)
3737 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
3738 CODE_LABEL_NUMBER (cs
->landing_pad
));
3740 /* ??? Perhaps use insn length scaling if the assembler supports
3741 generic arithmetic. */
3742 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
3743 data4 if the function is small enough. */
3744 #ifdef HAVE_AS_LEB128
3745 dw2_asm_output_delta_uleb128 (reg_start_lab
, function_start_lab
,
3746 "region %d start", i
);
3747 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
3749 if (cs
->landing_pad
)
3750 dw2_asm_output_delta_uleb128 (landing_pad_lab
, function_start_lab
,
3753 dw2_asm_output_data_uleb128 (0, "landing pad");
3755 dw2_asm_output_delta (4, reg_start_lab
, function_start_lab
,
3756 "region %d start", i
);
3757 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
3758 if (cs
->landing_pad
)
3759 dw2_asm_output_delta (4, landing_pad_lab
, function_start_lab
,
3762 dw2_asm_output_data (4, 0, "landing pad");
3764 dw2_asm_output_data_uleb128 (cs
->action
, "action");
3767 call_site_base
+= n
;
3771 sjlj_output_call_site_table ()
3773 int n
= cfun
->eh
->call_site_data_used
;
3776 for (i
= 0; i
< n
; ++i
)
3778 struct call_site_record
*cs
= &cfun
->eh
->call_site_data
[i
];
3780 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
3781 "region %d landing pad", i
);
3782 dw2_asm_output_data_uleb128 (cs
->action
, "action");
3785 call_site_base
+= n
;
3789 output_function_exception_table ()
3791 int tt_format
, cs_format
, lp_format
, i
, n
;
3792 #ifdef HAVE_AS_LEB128
3793 char ttype_label
[32];
3794 char cs_after_size_label
[32];
3795 char cs_end_label
[32];
3801 int tt_format_size
= 0;
3803 /* Not all functions need anything. */
3804 if (! cfun
->uses_eh_lsda
)
3807 funcdef_number
= (USING_SJLJ_EXCEPTIONS
3808 ? sjlj_funcdef_number
3809 : current_funcdef_number
);
3811 #ifdef IA64_UNWIND_INFO
3812 fputs ("\t.personality\t", asm_out_file
);
3813 output_addr_const (asm_out_file
, eh_personality_libfunc
);
3814 fputs ("\n\t.handlerdata\n", asm_out_file
);
3815 /* Note that varasm still thinks we're in the function's code section.
3816 The ".endp" directive that will immediately follow will take us back. */
3818 (*targetm
.asm_out
.exception_section
) ();
3821 have_tt_data
= (VARRAY_ACTIVE_SIZE (cfun
->eh
->ttype_data
) > 0
3822 || VARRAY_ACTIVE_SIZE (cfun
->eh
->ehspec_data
) > 0);
3824 /* Indicate the format of the @TType entries. */
3826 tt_format
= DW_EH_PE_omit
;
3829 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
3830 #ifdef HAVE_AS_LEB128
3831 ASM_GENERATE_INTERNAL_LABEL (ttype_label
, "LLSDATT", funcdef_number
);
3833 tt_format_size
= size_of_encoded_value (tt_format
);
3835 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3838 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LLSDA", funcdef_number
);
3840 /* The LSDA header. */
3842 /* Indicate the format of the landing pad start pointer. An omitted
3843 field implies @LPStart == @Start. */
3844 /* Currently we always put @LPStart == @Start. This field would
3845 be most useful in moving the landing pads completely out of
3846 line to another section, but it could also be used to minimize
3847 the size of uleb128 landing pad offsets. */
3848 lp_format
= DW_EH_PE_omit
;
3849 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
3850 eh_data_format_name (lp_format
));
3852 /* @LPStart pointer would go here. */
3854 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
3855 eh_data_format_name (tt_format
));
3857 #ifndef HAVE_AS_LEB128
3858 if (USING_SJLJ_EXCEPTIONS
)
3859 call_site_len
= sjlj_size_of_call_site_table ();
3861 call_site_len
= dw2_size_of_call_site_table ();
3864 /* A pc-relative 4-byte displacement to the @TType data. */
3867 #ifdef HAVE_AS_LEB128
3868 char ttype_after_disp_label
[32];
3869 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
, "LLSDATTD",
3871 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3872 "@TType base offset");
3873 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3875 /* Ug. Alignment queers things. */
3876 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3878 before_disp
= 1 + 1;
3879 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3881 + VARRAY_ACTIVE_SIZE (cfun
->eh
->action_record_data
)
3882 + (VARRAY_ACTIVE_SIZE (cfun
->eh
->ttype_data
)
3888 unsigned int disp_size
, pad
;
3891 disp_size
= size_of_uleb128 (disp
);
3892 pad
= before_disp
+ disp_size
+ after_disp
;
3893 if (pad
% tt_format_size
)
3894 pad
= tt_format_size
- (pad
% tt_format_size
);
3897 disp
= after_disp
+ pad
;
3899 while (disp
!= last_disp
);
3901 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3905 /* Indicate the format of the call-site offsets. */
3906 #ifdef HAVE_AS_LEB128
3907 cs_format
= DW_EH_PE_uleb128
;
3909 cs_format
= DW_EH_PE_udata4
;
3911 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3912 eh_data_format_name (cs_format
));
3914 #ifdef HAVE_AS_LEB128
3915 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
, "LLSDACSB",
3917 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
, "LLSDACSE",
3919 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3920 "Call-site table length");
3921 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3922 if (USING_SJLJ_EXCEPTIONS
)
3923 sjlj_output_call_site_table ();
3925 dw2_output_call_site_table ();
3926 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3928 dw2_asm_output_data_uleb128 (call_site_len
,"Call-site table length");
3929 if (USING_SJLJ_EXCEPTIONS
)
3930 sjlj_output_call_site_table ();
3932 dw2_output_call_site_table ();
3935 /* ??? Decode and interpret the data for flag_debug_asm. */
3936 n
= VARRAY_ACTIVE_SIZE (cfun
->eh
->action_record_data
);
3937 for (i
= 0; i
< n
; ++i
)
3938 dw2_asm_output_data (1, VARRAY_UCHAR (cfun
->eh
->action_record_data
, i
),
3939 (i
? NULL
: "Action record table"));
3942 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3944 i
= VARRAY_ACTIVE_SIZE (cfun
->eh
->ttype_data
);
3947 tree type
= VARRAY_TREE (cfun
->eh
->ttype_data
, i
);
3950 if (type
== NULL_TREE
)
3951 type
= integer_zero_node
;
3953 type
= lookup_type_for_runtime (type
);
3955 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
3956 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
3957 assemble_integer (value
, tt_format_size
,
3958 tt_format_size
* BITS_PER_UNIT
, 1);
3960 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, NULL
);
3963 #ifdef HAVE_AS_LEB128
3965 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3968 /* ??? Decode and interpret the data for flag_debug_asm. */
3969 n
= VARRAY_ACTIVE_SIZE (cfun
->eh
->ehspec_data
);
3970 for (i
= 0; i
< n
; ++i
)
3971 dw2_asm_output_data (1, VARRAY_UCHAR (cfun
->eh
->ehspec_data
, i
),
3972 (i
? NULL
: "Exception specification table"));
3974 function_section (current_function_decl
);
3976 if (USING_SJLJ_EXCEPTIONS
)
3977 sjlj_funcdef_number
+= 1;