1 /* Implements exception handling.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004 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. ] */
52 #include "coretypes.h"
60 #include "insn-config.h"
62 #include "integrate.h"
63 #include "hard-reg-set.h"
64 #include "basic-block.h"
66 #include "dwarf2asm.h"
67 #include "dwarf2out.h"
75 #include "langhooks.h"
78 /* Provide defaults for stuff that may not be defined when using
80 #ifndef EH_RETURN_DATA_REGNO
81 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
85 /* Nonzero means enable synchronous exceptions for non-call instructions. */
86 int flag_non_call_exceptions
;
88 /* Protect cleanup actions with must-not-throw regions, with a call
89 to the given failure handler. */
90 tree (*lang_protect_cleanup_actions
) (void);
92 /* Return true if type A catches type B. */
93 int (*lang_eh_type_covers
) (tree a
, tree b
);
95 /* Map a type to a runtime object to match type. */
96 tree (*lang_eh_runtime_type
) (tree
);
98 /* A hash table of label to region number. */
100 struct ehl_map_entry
GTY(())
103 struct eh_region
*region
;
106 static GTY(()) int call_site_base
;
107 static GTY ((param_is (union tree_node
)))
108 htab_t type_to_runtime_map
;
110 /* Describe the SjLj_Function_Context structure. */
111 static GTY(()) tree sjlj_fc_type_node
;
112 static int sjlj_fc_call_site_ofs
;
113 static int sjlj_fc_data_ofs
;
114 static int sjlj_fc_personality_ofs
;
115 static int sjlj_fc_lsda_ofs
;
116 static int sjlj_fc_jbuf_ofs
;
118 /* Describes one exception region. */
119 struct eh_region
GTY(())
121 /* The immediately surrounding region. */
122 struct eh_region
*outer
;
124 /* The list of immediately contained regions. */
125 struct eh_region
*inner
;
126 struct eh_region
*next_peer
;
128 /* An identifier for this region. */
131 /* When a region is deleted, its parents inherit the REG_EH_REGION
132 numbers already assigned. */
135 /* Each region does exactly one thing. */
142 ERT_ALLOWED_EXCEPTIONS
,
148 /* Holds the action to perform based on the preceding type. */
150 /* A list of catch blocks, a surrounding try block,
151 and the label for continuing after a catch. */
152 struct eh_region_u_try
{
153 struct eh_region
*catch;
154 struct eh_region
*last_catch
;
155 struct eh_region
*prev_try
;
157 } GTY ((tag ("ERT_TRY"))) try;
159 /* The list through the catch handlers, the list of type objects
160 matched, and the list of associated filters. */
161 struct eh_region_u_catch
{
162 struct eh_region
*next_catch
;
163 struct eh_region
*prev_catch
;
166 } GTY ((tag ("ERT_CATCH"))) catch;
168 /* A tree_list of allowed types. */
169 struct eh_region_u_allowed
{
172 } GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed
;
174 /* The type given by a call to "throw foo();", or discovered
176 struct eh_region_u_throw
{
178 } GTY ((tag ("ERT_THROW"))) throw;
180 /* Retain the cleanup expression even after expansion so that
181 we can match up fixup regions. */
182 struct eh_region_u_cleanup
{
184 struct eh_region
*prev_try
;
185 } GTY ((tag ("ERT_CLEANUP"))) cleanup
;
187 /* The real region (by expression and by pointer) that fixup code
189 struct eh_region_u_fixup
{
191 struct eh_region
*real_region
;
193 } GTY ((tag ("ERT_FIXUP"))) fixup
;
194 } GTY ((desc ("%0.type"))) u
;
196 /* Entry point for this region's handler before landing pads are built. */
199 /* Entry point for this region's handler from the runtime eh library. */
202 /* Entry point for this region's handler from an inner region. */
203 rtx post_landing_pad
;
205 /* The RESX insn for handing off control to the next outermost handler,
209 /* True if something in this region may throw. */
210 unsigned may_contain_throw
: 1;
213 struct call_site_record
GTY(())
219 /* Used to save exception status for each function. */
220 struct eh_status
GTY(())
222 /* The tree of all regions for this function. */
223 struct eh_region
*region_tree
;
225 /* The same information as an indexable array. */
226 struct eh_region
** GTY ((length ("%h.last_region_number"))) region_array
;
228 /* The most recently open region. */
229 struct eh_region
*cur_region
;
231 /* This is the region for which we are processing catch blocks. */
232 struct eh_region
*try_region
;
237 int built_landing_pads
;
238 int last_region_number
;
240 varray_type ttype_data
;
241 varray_type ehspec_data
;
242 varray_type action_record_data
;
244 htab_t
GTY ((param_is (struct ehl_map_entry
))) exception_handler_label_map
;
246 struct call_site_record
* GTY ((length ("%h.call_site_data_used")))
248 int call_site_data_used
;
249 int call_site_data_size
;
260 static int t2r_eq (const void *, const void *);
261 static hashval_t
t2r_hash (const void *);
262 static void add_type_for_runtime (tree
);
263 static tree
lookup_type_for_runtime (tree
);
265 static struct eh_region
*expand_eh_region_end (void);
267 static rtx
get_exception_filter (struct function
*);
269 static void collect_eh_region_array (void);
270 static void resolve_fixup_regions (void);
271 static void remove_fixup_regions (void);
272 static void remove_unreachable_regions (rtx
);
273 static void convert_from_eh_region_ranges_1 (rtx
*, int *, int);
275 static struct eh_region
*duplicate_eh_region_1 (struct eh_region
*,
276 struct inline_remap
*);
277 static void duplicate_eh_region_2 (struct eh_region
*, struct eh_region
**);
278 static int ttypes_filter_eq (const void *, const void *);
279 static hashval_t
ttypes_filter_hash (const void *);
280 static int ehspec_filter_eq (const void *, const void *);
281 static hashval_t
ehspec_filter_hash (const void *);
282 static int add_ttypes_entry (htab_t
, tree
);
283 static int add_ehspec_entry (htab_t
, htab_t
, tree
);
284 static void assign_filter_values (void);
285 static void build_post_landing_pads (void);
286 static void connect_post_landing_pads (void);
287 static void dw2_build_landing_pads (void);
290 static bool sjlj_find_directly_reachable_regions (struct sjlj_lp_info
*);
291 static void sjlj_assign_call_site_values (rtx
, struct sjlj_lp_info
*);
292 static void sjlj_mark_call_sites (struct sjlj_lp_info
*);
293 static void sjlj_emit_function_enter (rtx
);
294 static void sjlj_emit_function_exit (void);
295 static void sjlj_emit_dispatch_table (rtx
, struct sjlj_lp_info
*);
296 static void sjlj_build_landing_pads (void);
298 static hashval_t
ehl_hash (const void *);
299 static int ehl_eq (const void *, const void *);
300 static void add_ehl_entry (rtx
, struct eh_region
*);
301 static void remove_exception_handler_label (rtx
);
302 static void remove_eh_handler (struct eh_region
*);
303 static int for_each_eh_label_1 (void **, void *);
305 struct reachable_info
;
307 /* The return value of reachable_next_level. */
310 /* The given exception is not processed by the given region. */
312 /* The given exception may need processing by the given region. */
314 /* The given exception is completely processed by the given region. */
316 /* The given exception is completely processed by the runtime. */
320 static int check_handled (tree
, tree
);
321 static void add_reachable_handler (struct reachable_info
*,
322 struct eh_region
*, struct eh_region
*);
323 static enum reachable_code
reachable_next_level (struct eh_region
*, tree
,
324 struct reachable_info
*);
326 static int action_record_eq (const void *, const void *);
327 static hashval_t
action_record_hash (const void *);
328 static int add_action_record (htab_t
, int, int);
329 static int collect_one_action_chain (htab_t
, struct eh_region
*);
330 static int add_call_site (rtx
, int);
332 static void push_uleb128 (varray_type
*, unsigned int);
333 static void push_sleb128 (varray_type
*, int);
334 #ifndef HAVE_AS_LEB128
335 static int dw2_size_of_call_site_table (void);
336 static int sjlj_size_of_call_site_table (void);
338 static void dw2_output_call_site_table (void);
339 static void sjlj_output_call_site_table (void);
342 /* Routine to see if exception handling is turned on.
343 DO_WARN is nonzero if we want to inform the user that exception
344 handling is turned off.
346 This is used to ensure that -fexceptions has been specified if the
347 compiler tries to use any exception-specific functions. */
350 doing_eh (int do_warn
)
352 if (! flag_exceptions
)
354 static int warned
= 0;
355 if (! warned
&& do_warn
)
357 error ("exception handling disabled, use -fexceptions to enable");
369 if (! flag_exceptions
)
372 type_to_runtime_map
= htab_create_ggc (31, t2r_hash
, t2r_eq
, NULL
);
374 /* Create the SjLj_Function_Context structure. This should match
375 the definition in unwind-sjlj.c. */
376 if (USING_SJLJ_EXCEPTIONS
)
378 tree f_jbuf
, f_per
, f_lsda
, f_prev
, f_cs
, f_data
, tmp
;
380 sjlj_fc_type_node
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
382 f_prev
= build_decl (FIELD_DECL
, get_identifier ("__prev"),
383 build_pointer_type (sjlj_fc_type_node
));
384 DECL_FIELD_CONTEXT (f_prev
) = sjlj_fc_type_node
;
386 f_cs
= build_decl (FIELD_DECL
, get_identifier ("__call_site"),
388 DECL_FIELD_CONTEXT (f_cs
) = sjlj_fc_type_node
;
390 tmp
= build_index_type (build_int_2 (4 - 1, 0));
391 tmp
= build_array_type ((*lang_hooks
.types
.type_for_mode
) (word_mode
, 1),
393 f_data
= build_decl (FIELD_DECL
, get_identifier ("__data"), tmp
);
394 DECL_FIELD_CONTEXT (f_data
) = sjlj_fc_type_node
;
396 f_per
= build_decl (FIELD_DECL
, get_identifier ("__personality"),
398 DECL_FIELD_CONTEXT (f_per
) = sjlj_fc_type_node
;
400 f_lsda
= build_decl (FIELD_DECL
, get_identifier ("__lsda"),
402 DECL_FIELD_CONTEXT (f_lsda
) = sjlj_fc_type_node
;
404 #ifdef DONT_USE_BUILTIN_SETJMP
406 tmp
= build_int_2 (JMP_BUF_SIZE
- 1, 0);
408 /* Should be large enough for most systems, if it is not,
409 JMP_BUF_SIZE should be defined with the proper value. It will
410 also tend to be larger than necessary for most systems, a more
411 optimal port will define JMP_BUF_SIZE. */
412 tmp
= build_int_2 (FIRST_PSEUDO_REGISTER
+ 2 - 1, 0);
415 /* builtin_setjmp takes a pointer to 5 words. */
416 tmp
= build_int_2 (5 * BITS_PER_WORD
/ POINTER_SIZE
- 1, 0);
418 tmp
= build_index_type (tmp
);
419 tmp
= build_array_type (ptr_type_node
, tmp
);
420 f_jbuf
= build_decl (FIELD_DECL
, get_identifier ("__jbuf"), tmp
);
421 #ifdef DONT_USE_BUILTIN_SETJMP
422 /* We don't know what the alignment requirements of the
423 runtime's jmp_buf has. Overestimate. */
424 DECL_ALIGN (f_jbuf
) = BIGGEST_ALIGNMENT
;
425 DECL_USER_ALIGN (f_jbuf
) = 1;
427 DECL_FIELD_CONTEXT (f_jbuf
) = sjlj_fc_type_node
;
429 TYPE_FIELDS (sjlj_fc_type_node
) = f_prev
;
430 TREE_CHAIN (f_prev
) = f_cs
;
431 TREE_CHAIN (f_cs
) = f_data
;
432 TREE_CHAIN (f_data
) = f_per
;
433 TREE_CHAIN (f_per
) = f_lsda
;
434 TREE_CHAIN (f_lsda
) = f_jbuf
;
436 layout_type (sjlj_fc_type_node
);
438 /* Cache the interesting field offsets so that we have
439 easy access from rtl. */
440 sjlj_fc_call_site_ofs
441 = (tree_low_cst (DECL_FIELD_OFFSET (f_cs
), 1)
442 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs
), 1) / BITS_PER_UNIT
);
444 = (tree_low_cst (DECL_FIELD_OFFSET (f_data
), 1)
445 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data
), 1) / BITS_PER_UNIT
);
446 sjlj_fc_personality_ofs
447 = (tree_low_cst (DECL_FIELD_OFFSET (f_per
), 1)
448 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per
), 1) / BITS_PER_UNIT
);
450 = (tree_low_cst (DECL_FIELD_OFFSET (f_lsda
), 1)
451 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda
), 1) / BITS_PER_UNIT
);
453 = (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf
), 1)
454 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf
), 1) / BITS_PER_UNIT
);
459 init_eh_for_function (void)
461 cfun
->eh
= ggc_alloc_cleared (sizeof (struct eh_status
));
464 /* Start an exception handling region. All instructions emitted
465 after this point are considered to be part of the region until
466 expand_eh_region_end is invoked. */
469 expand_eh_region_start (void)
471 struct eh_region
*new_region
;
472 struct eh_region
*cur_region
;
478 /* Insert a new blank region as a leaf in the tree. */
479 new_region
= ggc_alloc_cleared (sizeof (*new_region
));
480 cur_region
= cfun
->eh
->cur_region
;
481 new_region
->outer
= cur_region
;
484 new_region
->next_peer
= cur_region
->inner
;
485 cur_region
->inner
= new_region
;
489 new_region
->next_peer
= cfun
->eh
->region_tree
;
490 cfun
->eh
->region_tree
= new_region
;
492 cfun
->eh
->cur_region
= new_region
;
494 /* Create a note marking the start of this region. */
495 new_region
->region_number
= ++cfun
->eh
->last_region_number
;
496 note
= emit_note (NOTE_INSN_EH_REGION_BEG
);
497 NOTE_EH_HANDLER (note
) = new_region
->region_number
;
500 /* Common code to end a region. Returns the region just ended. */
502 static struct eh_region
*
503 expand_eh_region_end (void)
505 struct eh_region
*cur_region
= cfun
->eh
->cur_region
;
508 /* Create a note marking the end of this region. */
509 note
= emit_note (NOTE_INSN_EH_REGION_END
);
510 NOTE_EH_HANDLER (note
) = cur_region
->region_number
;
513 cfun
->eh
->cur_region
= cur_region
->outer
;
518 /* End an exception handling region for a cleanup. HANDLER is an
519 expression to expand for the cleanup. */
522 expand_eh_region_end_cleanup (tree handler
)
524 struct eh_region
*region
;
525 tree protect_cleanup_actions
;
532 region
= expand_eh_region_end ();
533 region
->type
= ERT_CLEANUP
;
534 region
->label
= gen_label_rtx ();
535 region
->u
.cleanup
.exp
= handler
;
536 region
->u
.cleanup
.prev_try
= cfun
->eh
->try_region
;
538 around_label
= gen_label_rtx ();
539 emit_jump (around_label
);
541 emit_label (region
->label
);
543 if (flag_non_call_exceptions
|| region
->may_contain_throw
)
545 /* Give the language a chance to specify an action to be taken if an
546 exception is thrown that would propagate out of the HANDLER. */
547 protect_cleanup_actions
548 = (lang_protect_cleanup_actions
549 ? (*lang_protect_cleanup_actions
) ()
552 if (protect_cleanup_actions
)
553 expand_eh_region_start ();
555 /* In case this cleanup involves an inline destructor with a try block in
556 it, we need to save the EH return data registers around it. */
557 data_save
[0] = gen_reg_rtx (ptr_mode
);
558 emit_move_insn (data_save
[0], get_exception_pointer (cfun
));
559 data_save
[1] = gen_reg_rtx (word_mode
);
560 emit_move_insn (data_save
[1], get_exception_filter (cfun
));
562 expand_expr (handler
, const0_rtx
, VOIDmode
, 0);
564 emit_move_insn (cfun
->eh
->exc_ptr
, data_save
[0]);
565 emit_move_insn (cfun
->eh
->filter
, data_save
[1]);
567 if (protect_cleanup_actions
)
568 expand_eh_region_end_must_not_throw (protect_cleanup_actions
);
570 /* We need any stack adjustment complete before the around_label. */
571 do_pending_stack_adjust ();
574 /* We delay the generation of the _Unwind_Resume until we generate
575 landing pads. We emit a marker here so as to get good control
576 flow data in the meantime. */
578 = emit_jump_insn (gen_rtx_RESX (VOIDmode
, region
->region_number
));
581 emit_label (around_label
);
584 /* End an exception handling region for a try block, and prepares
585 for subsequent calls to expand_start_catch. */
588 expand_start_all_catch (void)
590 struct eh_region
*region
;
595 region
= expand_eh_region_end ();
596 region
->type
= ERT_TRY
;
597 region
->u
.try.prev_try
= cfun
->eh
->try_region
;
598 region
->u
.try.continue_label
= gen_label_rtx ();
600 cfun
->eh
->try_region
= region
;
602 emit_jump (region
->u
.try.continue_label
);
605 /* Begin a catch clause. TYPE is the type caught, a list of such types, or
606 null if this is a catch-all clause. Providing a type list enables to
607 associate the catch region with potentially several exception types, which
608 is useful e.g. for Ada. */
611 expand_start_catch (tree type_or_list
)
613 struct eh_region
*t
, *c
, *l
;
619 type_list
= type_or_list
;
623 /* Ensure to always end up with a type list to normalize further
624 processing, then register each type against the runtime types
628 if (TREE_CODE (type_or_list
) != TREE_LIST
)
629 type_list
= tree_cons (NULL_TREE
, type_or_list
, NULL_TREE
);
631 type_node
= type_list
;
632 for (; type_node
; type_node
= TREE_CHAIN (type_node
))
633 add_type_for_runtime (TREE_VALUE (type_node
));
636 expand_eh_region_start ();
638 t
= cfun
->eh
->try_region
;
639 c
= cfun
->eh
->cur_region
;
641 c
->u
.catch.type_list
= type_list
;
642 c
->label
= gen_label_rtx ();
644 l
= t
->u
.try.last_catch
;
645 c
->u
.catch.prev_catch
= l
;
647 l
->u
.catch.next_catch
= c
;
650 t
->u
.try.last_catch
= c
;
652 emit_label (c
->label
);
655 /* End a catch clause. Control will resume after the try/catch block. */
658 expand_end_catch (void)
660 struct eh_region
*try_region
;
665 expand_eh_region_end ();
666 try_region
= cfun
->eh
->try_region
;
668 emit_jump (try_region
->u
.try.continue_label
);
671 /* End a sequence of catch handlers for a try block. */
674 expand_end_all_catch (void)
676 struct eh_region
*try_region
;
681 try_region
= cfun
->eh
->try_region
;
682 cfun
->eh
->try_region
= try_region
->u
.try.prev_try
;
684 emit_label (try_region
->u
.try.continue_label
);
687 /* End an exception region for an exception type filter. ALLOWED is a
688 TREE_LIST of types to be matched by the runtime. FAILURE is an
689 expression to invoke if a mismatch occurs.
691 ??? We could use these semantics for calls to rethrow, too; if we can
692 see the surrounding catch clause, we know that the exception we're
693 rethrowing satisfies the "filter" of the catch type. */
696 expand_eh_region_end_allowed (tree allowed
, tree failure
)
698 struct eh_region
*region
;
704 region
= expand_eh_region_end ();
705 region
->type
= ERT_ALLOWED_EXCEPTIONS
;
706 region
->u
.allowed
.type_list
= allowed
;
707 region
->label
= gen_label_rtx ();
709 for (; allowed
; allowed
= TREE_CHAIN (allowed
))
710 add_type_for_runtime (TREE_VALUE (allowed
));
712 /* We must emit the call to FAILURE here, so that if this function
713 throws a different exception, that it will be processed by the
716 around_label
= gen_label_rtx ();
717 emit_jump (around_label
);
719 emit_label (region
->label
);
720 expand_expr (failure
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
721 /* We must adjust the stack before we reach the AROUND_LABEL because
722 the call to FAILURE does not occur on all paths to the
724 do_pending_stack_adjust ();
726 emit_label (around_label
);
729 /* End an exception region for a must-not-throw filter. FAILURE is an
730 expression invoke if an uncaught exception propagates this far.
732 This is conceptually identical to expand_eh_region_end_allowed with
733 an empty allowed list (if you passed "std::terminate" instead of
734 "__cxa_call_unexpected"), but they are represented differently in
738 expand_eh_region_end_must_not_throw (tree failure
)
740 struct eh_region
*region
;
746 region
= expand_eh_region_end ();
747 region
->type
= ERT_MUST_NOT_THROW
;
748 region
->label
= gen_label_rtx ();
750 /* We must emit the call to FAILURE here, so that if this function
751 throws a different exception, that it will be processed by the
754 around_label
= gen_label_rtx ();
755 emit_jump (around_label
);
757 emit_label (region
->label
);
758 expand_expr (failure
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
760 emit_label (around_label
);
763 /* End an exception region for a throw. No handling goes on here,
764 but it's the easiest way for the front-end to indicate what type
768 expand_eh_region_end_throw (tree type
)
770 struct eh_region
*region
;
775 region
= expand_eh_region_end ();
776 region
->type
= ERT_THROW
;
777 region
->u
.throw.type
= type
;
780 /* End a fixup region. Within this region the cleanups for the immediately
781 enclosing region are _not_ run. This is used for goto cleanup to avoid
782 destroying an object twice.
784 This would be an extraordinarily simple prospect, were it not for the
785 fact that we don't actually know what the immediately enclosing region
786 is. This surprising fact is because expand_cleanups is currently
787 generating a sequence that it will insert somewhere else. We collect
788 the proper notion of "enclosing" in convert_from_eh_region_ranges. */
791 expand_eh_region_end_fixup (tree handler
)
793 struct eh_region
*fixup
;
798 fixup
= expand_eh_region_end ();
799 fixup
->type
= ERT_FIXUP
;
800 fixup
->u
.fixup
.cleanup_exp
= handler
;
803 /* Note that the current EH region (if any) may contain a throw, or a
804 call to a function which itself may contain a throw. */
807 note_eh_region_may_contain_throw (void)
809 struct eh_region
*region
;
811 region
= cfun
->eh
->cur_region
;
812 while (region
&& !region
->may_contain_throw
)
814 region
->may_contain_throw
= 1;
815 region
= region
->outer
;
819 /* Return an rtl expression for a pointer to the exception object
823 get_exception_pointer (struct function
*fun
)
825 rtx exc_ptr
= fun
->eh
->exc_ptr
;
826 if (fun
== cfun
&& ! exc_ptr
)
828 exc_ptr
= gen_reg_rtx (ptr_mode
);
829 fun
->eh
->exc_ptr
= exc_ptr
;
834 /* Return an rtl expression for the exception dispatch filter
838 get_exception_filter (struct function
*fun
)
840 rtx filter
= fun
->eh
->filter
;
841 if (fun
== cfun
&& ! filter
)
843 filter
= gen_reg_rtx (word_mode
);
844 fun
->eh
->filter
= filter
;
849 /* This section is for the exception handling specific optimization pass. */
851 /* Random access the exception region tree. It's just as simple to
852 collect the regions this way as in expand_eh_region_start, but
853 without having to realloc memory. */
856 collect_eh_region_array (void)
858 struct eh_region
**array
, *i
;
860 i
= cfun
->eh
->region_tree
;
864 array
= ggc_alloc_cleared ((cfun
->eh
->last_region_number
+ 1)
866 cfun
->eh
->region_array
= array
;
870 array
[i
->region_number
] = i
;
872 /* If there are sub-regions, process them. */
875 /* If there are peers, process them. */
876 else if (i
->next_peer
)
878 /* Otherwise, step back up the tree to the next peer. */
885 } while (i
->next_peer
== NULL
);
892 resolve_one_fixup_region (struct eh_region
*fixup
)
894 struct eh_region
*cleanup
, *real
;
897 n
= cfun
->eh
->last_region_number
;
900 for (j
= 1; j
<= n
; ++j
)
902 cleanup
= cfun
->eh
->region_array
[j
];
903 if (cleanup
&& cleanup
->type
== ERT_CLEANUP
904 && cleanup
->u
.cleanup
.exp
== fixup
->u
.fixup
.cleanup_exp
)
910 real
= cleanup
->outer
;
911 if (real
&& real
->type
== ERT_FIXUP
)
913 if (!real
->u
.fixup
.resolved
)
914 resolve_one_fixup_region (real
);
915 real
= real
->u
.fixup
.real_region
;
918 fixup
->u
.fixup
.real_region
= real
;
919 fixup
->u
.fixup
.resolved
= true;
923 resolve_fixup_regions (void)
925 int i
, n
= cfun
->eh
->last_region_number
;
927 for (i
= 1; i
<= n
; ++i
)
929 struct eh_region
*fixup
= cfun
->eh
->region_array
[i
];
931 if (!fixup
|| fixup
->type
!= ERT_FIXUP
|| fixup
->u
.fixup
.resolved
)
934 resolve_one_fixup_region (fixup
);
938 /* Now that we've discovered what region actually encloses a fixup,
939 we can shuffle pointers and remove them from the tree. */
942 remove_fixup_regions (void)
946 struct eh_region
*fixup
;
948 /* Walk the insn chain and adjust the REG_EH_REGION numbers
949 for instructions referencing fixup regions. This is only
950 strictly necessary for fixup regions with no parent, but
951 doesn't hurt to do it for all regions. */
952 for (insn
= get_insns(); insn
; insn
= NEXT_INSN (insn
))
954 && (note
= find_reg_note (insn
, REG_EH_REGION
, NULL
))
955 && INTVAL (XEXP (note
, 0)) > 0
956 && (fixup
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))])
957 && fixup
->type
== ERT_FIXUP
)
959 if (fixup
->u
.fixup
.real_region
)
960 XEXP (note
, 0) = GEN_INT (fixup
->u
.fixup
.real_region
->region_number
);
962 remove_note (insn
, note
);
965 /* Remove the fixup regions from the tree. */
966 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
968 fixup
= cfun
->eh
->region_array
[i
];
972 /* Allow GC to maybe free some memory. */
973 if (fixup
->type
== ERT_CLEANUP
)
974 fixup
->u
.cleanup
.exp
= NULL_TREE
;
976 if (fixup
->type
!= ERT_FIXUP
)
981 struct eh_region
*parent
, *p
, **pp
;
983 parent
= fixup
->u
.fixup
.real_region
;
985 /* Fix up the children's parent pointers; find the end of
987 for (p
= fixup
->inner
; ; p
= p
->next_peer
)
994 /* In the tree of cleanups, only outer-inner ordering matters.
995 So link the children back in anywhere at the correct level. */
999 pp
= &cfun
->eh
->region_tree
;
1002 fixup
->inner
= NULL
;
1005 remove_eh_handler (fixup
);
1009 /* Remove all regions whose labels are not reachable from insns. */
1012 remove_unreachable_regions (rtx insns
)
1014 int i
, *uid_region_num
;
1016 struct eh_region
*r
;
1019 uid_region_num
= xcalloc (get_max_uid (), sizeof(int));
1020 reachable
= xcalloc (cfun
->eh
->last_region_number
+ 1, sizeof(bool));
1022 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1024 r
= cfun
->eh
->region_array
[i
];
1025 if (!r
|| r
->region_number
!= i
)
1030 if (uid_region_num
[INSN_UID (r
->resume
)])
1032 uid_region_num
[INSN_UID (r
->resume
)] = i
;
1036 if (uid_region_num
[INSN_UID (r
->label
)])
1038 uid_region_num
[INSN_UID (r
->label
)] = i
;
1040 if (r
->type
== ERT_TRY
&& r
->u
.try.continue_label
)
1042 if (uid_region_num
[INSN_UID (r
->u
.try.continue_label
)])
1044 uid_region_num
[INSN_UID (r
->u
.try.continue_label
)] = i
;
1048 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
1049 reachable
[uid_region_num
[INSN_UID (insn
)]] = true;
1051 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1053 r
= cfun
->eh
->region_array
[i
];
1054 if (r
&& r
->region_number
== i
&& !reachable
[i
])
1056 /* Don't remove ERT_THROW regions if their outer region
1058 if (r
->type
== ERT_THROW
1060 && reachable
[r
->outer
->region_number
])
1063 remove_eh_handler (r
);
1068 free (uid_region_num
);
1071 /* Turn NOTE_INSN_EH_REGION notes into REG_EH_REGION notes for each
1072 can_throw instruction in the region. */
1075 convert_from_eh_region_ranges_1 (rtx
*pinsns
, int *orig_sp
, int cur
)
1080 for (insn
= *pinsns
; insn
; insn
= next
)
1082 next
= NEXT_INSN (insn
);
1083 if (GET_CODE (insn
) == NOTE
)
1085 int kind
= NOTE_LINE_NUMBER (insn
);
1086 if (kind
== NOTE_INSN_EH_REGION_BEG
1087 || kind
== NOTE_INSN_EH_REGION_END
)
1089 if (kind
== NOTE_INSN_EH_REGION_BEG
)
1091 struct eh_region
*r
;
1094 cur
= NOTE_EH_HANDLER (insn
);
1096 r
= cfun
->eh
->region_array
[cur
];
1097 if (r
->type
== ERT_FIXUP
)
1099 r
= r
->u
.fixup
.real_region
;
1100 cur
= r
? r
->region_number
: 0;
1102 else if (r
->type
== ERT_CATCH
)
1105 cur
= r
? r
->region_number
: 0;
1111 /* Removing the first insn of a CALL_PLACEHOLDER sequence
1112 requires extra care to adjust sequence start. */
1113 if (insn
== *pinsns
)
1119 else if (INSN_P (insn
))
1122 && ! find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
)
1123 /* Calls can always potentially throw exceptions, unless
1124 they have a REG_EH_REGION note with a value of 0 or less.
1125 Which should be the only possible kind so far. */
1126 && (GET_CODE (insn
) == CALL_INSN
1127 /* If we wanted exceptions for non-call insns, then
1128 any may_trap_p instruction could throw. */
1129 || (flag_non_call_exceptions
1130 && GET_CODE (PATTERN (insn
)) != CLOBBER
1131 && GET_CODE (PATTERN (insn
)) != USE
1132 && may_trap_p (PATTERN (insn
)))))
1134 REG_NOTES (insn
) = alloc_EXPR_LIST (REG_EH_REGION
, GEN_INT (cur
),
1138 if (GET_CODE (insn
) == CALL_INSN
1139 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
1141 convert_from_eh_region_ranges_1 (&XEXP (PATTERN (insn
), 0),
1143 convert_from_eh_region_ranges_1 (&XEXP (PATTERN (insn
), 1),
1145 convert_from_eh_region_ranges_1 (&XEXP (PATTERN (insn
), 2),
1156 convert_from_eh_region_ranges (void)
1161 collect_eh_region_array ();
1162 resolve_fixup_regions ();
1164 stack
= xmalloc (sizeof (int) * (cfun
->eh
->last_region_number
+ 1));
1165 insns
= get_insns ();
1166 convert_from_eh_region_ranges_1 (&insns
, stack
, 0);
1169 remove_fixup_regions ();
1170 remove_unreachable_regions (insns
);
1174 add_ehl_entry (rtx label
, struct eh_region
*region
)
1176 struct ehl_map_entry
**slot
, *entry
;
1178 LABEL_PRESERVE_P (label
) = 1;
1180 entry
= ggc_alloc (sizeof (*entry
));
1181 entry
->label
= label
;
1182 entry
->region
= region
;
1184 slot
= (struct ehl_map_entry
**)
1185 htab_find_slot (cfun
->eh
->exception_handler_label_map
, entry
, INSERT
);
1187 /* Before landing pad creation, each exception handler has its own
1188 label. After landing pad creation, the exception handlers may
1189 share landing pads. This is ok, since maybe_remove_eh_handler
1190 only requires the 1-1 mapping before landing pad creation. */
1191 if (*slot
&& !cfun
->eh
->built_landing_pads
)
1198 find_exception_handler_labels (void)
1202 if (cfun
->eh
->exception_handler_label_map
)
1203 htab_empty (cfun
->eh
->exception_handler_label_map
);
1206 /* ??? The expansion factor here (3/2) must be greater than the htab
1207 occupancy factor (4/3) to avoid unnecessary resizing. */
1208 cfun
->eh
->exception_handler_label_map
1209 = htab_create_ggc (cfun
->eh
->last_region_number
* 3 / 2,
1210 ehl_hash
, ehl_eq
, NULL
);
1213 if (cfun
->eh
->region_tree
== NULL
)
1216 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1218 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
1221 if (! region
|| region
->region_number
!= i
)
1223 if (cfun
->eh
->built_landing_pads
)
1224 lab
= region
->landing_pad
;
1226 lab
= region
->label
;
1229 add_ehl_entry (lab
, region
);
1232 /* For sjlj exceptions, need the return label to remain live until
1233 after landing pad generation. */
1234 if (USING_SJLJ_EXCEPTIONS
&& ! cfun
->eh
->built_landing_pads
)
1235 add_ehl_entry (return_label
, NULL
);
1239 current_function_has_exception_handlers (void)
1243 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1245 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
1247 if (! region
|| region
->region_number
!= i
)
1249 if (region
->type
!= ERT_THROW
)
1256 static struct eh_region
*
1257 duplicate_eh_region_1 (struct eh_region
*o
, struct inline_remap
*map
)
1259 struct eh_region
*n
= ggc_alloc_cleared (sizeof (struct eh_region
));
1261 n
->region_number
= o
->region_number
+ cfun
->eh
->last_region_number
;
1267 case ERT_MUST_NOT_THROW
:
1271 if (o
->u
.try.continue_label
)
1272 n
->u
.try.continue_label
1273 = get_label_from_map (map
,
1274 CODE_LABEL_NUMBER (o
->u
.try.continue_label
));
1278 n
->u
.catch.type_list
= o
->u
.catch.type_list
;
1281 case ERT_ALLOWED_EXCEPTIONS
:
1282 n
->u
.allowed
.type_list
= o
->u
.allowed
.type_list
;
1286 n
->u
.throw.type
= o
->u
.throw.type
;
1293 n
->label
= get_label_from_map (map
, CODE_LABEL_NUMBER (o
->label
));
1296 n
->resume
= map
->insn_map
[INSN_UID (o
->resume
)];
1297 if (n
->resume
== NULL
)
1305 duplicate_eh_region_2 (struct eh_region
*o
, struct eh_region
**n_array
)
1307 struct eh_region
*n
= n_array
[o
->region_number
];
1312 n
->u
.try.catch = n_array
[o
->u
.try.catch->region_number
];
1313 n
->u
.try.last_catch
= n_array
[o
->u
.try.last_catch
->region_number
];
1317 if (o
->u
.catch.next_catch
)
1318 n
->u
.catch.next_catch
= n_array
[o
->u
.catch.next_catch
->region_number
];
1319 if (o
->u
.catch.prev_catch
)
1320 n
->u
.catch.prev_catch
= n_array
[o
->u
.catch.prev_catch
->region_number
];
1328 n
->outer
= n_array
[o
->outer
->region_number
];
1330 n
->inner
= n_array
[o
->inner
->region_number
];
1332 n
->next_peer
= n_array
[o
->next_peer
->region_number
];
1336 duplicate_eh_regions (struct function
*ifun
, struct inline_remap
*map
)
1338 int ifun_last_region_number
= ifun
->eh
->last_region_number
;
1339 struct eh_region
**n_array
, *root
, *cur
;
1342 if (ifun_last_region_number
== 0)
1345 n_array
= xcalloc (ifun_last_region_number
+ 1, sizeof (*n_array
));
1347 for (i
= 1; i
<= ifun_last_region_number
; ++i
)
1349 cur
= ifun
->eh
->region_array
[i
];
1350 if (!cur
|| cur
->region_number
!= i
)
1352 n_array
[i
] = duplicate_eh_region_1 (cur
, map
);
1354 for (i
= 1; i
<= ifun_last_region_number
; ++i
)
1356 cur
= ifun
->eh
->region_array
[i
];
1357 if (!cur
|| cur
->region_number
!= i
)
1359 duplicate_eh_region_2 (cur
, n_array
);
1362 root
= n_array
[ifun
->eh
->region_tree
->region_number
];
1363 cur
= cfun
->eh
->cur_region
;
1366 struct eh_region
*p
= cur
->inner
;
1369 while (p
->next_peer
)
1371 p
->next_peer
= root
;
1376 for (i
= 1; i
<= ifun_last_region_number
; ++i
)
1377 if (n_array
[i
] && n_array
[i
]->outer
== NULL
)
1378 n_array
[i
]->outer
= cur
;
1382 struct eh_region
*p
= cfun
->eh
->region_tree
;
1385 while (p
->next_peer
)
1387 p
->next_peer
= root
;
1390 cfun
->eh
->region_tree
= root
;
1395 i
= cfun
->eh
->last_region_number
;
1396 cfun
->eh
->last_region_number
= i
+ ifun_last_region_number
;
1402 t2r_eq (const void *pentry
, const void *pdata
)
1404 tree entry
= (tree
) pentry
;
1405 tree data
= (tree
) pdata
;
1407 return TREE_PURPOSE (entry
) == data
;
1411 t2r_hash (const void *pentry
)
1413 tree entry
= (tree
) pentry
;
1414 return TYPE_HASH (TREE_PURPOSE (entry
));
1418 add_type_for_runtime (tree type
)
1422 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
1423 TYPE_HASH (type
), INSERT
);
1426 tree runtime
= (*lang_eh_runtime_type
) (type
);
1427 *slot
= tree_cons (type
, runtime
, NULL_TREE
);
1432 lookup_type_for_runtime (tree type
)
1436 slot
= (tree
*) htab_find_slot_with_hash (type_to_runtime_map
, type
,
1437 TYPE_HASH (type
), NO_INSERT
);
1439 /* We should have always inserted the data earlier. */
1440 return TREE_VALUE (*slot
);
1444 /* Represent an entry in @TTypes for either catch actions
1445 or exception filter actions. */
1446 struct ttypes_filter
GTY(())
1452 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
1453 (a tree) for a @TTypes type node we are thinking about adding. */
1456 ttypes_filter_eq (const void *pentry
, const void *pdata
)
1458 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1459 tree data
= (tree
) pdata
;
1461 return entry
->t
== data
;
1465 ttypes_filter_hash (const void *pentry
)
1467 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1468 return TYPE_HASH (entry
->t
);
1471 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
1472 exception specification list we are thinking about adding. */
1473 /* ??? Currently we use the type lists in the order given. Someone
1474 should put these in some canonical order. */
1477 ehspec_filter_eq (const void *pentry
, const void *pdata
)
1479 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1480 const struct ttypes_filter
*data
= (const struct ttypes_filter
*) pdata
;
1482 return type_list_equal (entry
->t
, data
->t
);
1485 /* Hash function for exception specification lists. */
1488 ehspec_filter_hash (const void *pentry
)
1490 const struct ttypes_filter
*entry
= (const struct ttypes_filter
*) pentry
;
1494 for (list
= entry
->t
; list
; list
= TREE_CHAIN (list
))
1495 h
= (h
<< 5) + (h
>> 27) + TYPE_HASH (TREE_VALUE (list
));
1499 /* Add TYPE to cfun->eh->ttype_data, using TYPES_HASH to speed
1500 up the search. Return the filter value to be used. */
1503 add_ttypes_entry (htab_t ttypes_hash
, tree type
)
1505 struct ttypes_filter
**slot
, *n
;
1507 slot
= (struct ttypes_filter
**)
1508 htab_find_slot_with_hash (ttypes_hash
, type
, TYPE_HASH (type
), INSERT
);
1510 if ((n
= *slot
) == NULL
)
1512 /* Filter value is a 1 based table index. */
1514 n
= xmalloc (sizeof (*n
));
1516 n
->filter
= VARRAY_ACTIVE_SIZE (cfun
->eh
->ttype_data
) + 1;
1519 VARRAY_PUSH_TREE (cfun
->eh
->ttype_data
, type
);
1525 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
1526 to speed up the search. Return the filter value to be used. */
1529 add_ehspec_entry (htab_t ehspec_hash
, htab_t ttypes_hash
, tree list
)
1531 struct ttypes_filter
**slot
, *n
;
1532 struct ttypes_filter dummy
;
1535 slot
= (struct ttypes_filter
**)
1536 htab_find_slot (ehspec_hash
, &dummy
, INSERT
);
1538 if ((n
= *slot
) == NULL
)
1540 /* Filter value is a -1 based byte index into a uleb128 buffer. */
1542 n
= xmalloc (sizeof (*n
));
1544 n
->filter
= -(VARRAY_ACTIVE_SIZE (cfun
->eh
->ehspec_data
) + 1);
1547 /* Look up each type in the list and encode its filter
1548 value as a uleb128. Terminate the list with 0. */
1549 for (; list
; list
= TREE_CHAIN (list
))
1550 push_uleb128 (&cfun
->eh
->ehspec_data
,
1551 add_ttypes_entry (ttypes_hash
, TREE_VALUE (list
)));
1552 VARRAY_PUSH_UCHAR (cfun
->eh
->ehspec_data
, 0);
1558 /* Generate the action filter values to be used for CATCH and
1559 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
1560 we use lots of landing pads, and so every type or list can share
1561 the same filter value, which saves table space. */
1564 assign_filter_values (void)
1567 htab_t ttypes
, ehspec
;
1569 VARRAY_TREE_INIT (cfun
->eh
->ttype_data
, 16, "ttype_data");
1570 VARRAY_UCHAR_INIT (cfun
->eh
->ehspec_data
, 64, "ehspec_data");
1572 ttypes
= htab_create (31, ttypes_filter_hash
, ttypes_filter_eq
, free
);
1573 ehspec
= htab_create (31, ehspec_filter_hash
, ehspec_filter_eq
, free
);
1575 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1577 struct eh_region
*r
= cfun
->eh
->region_array
[i
];
1579 /* Mind we don't process a region more than once. */
1580 if (!r
|| r
->region_number
!= i
)
1586 /* Whatever type_list is (NULL or true list), we build a list
1587 of filters for the region. */
1588 r
->u
.catch.filter_list
= NULL_TREE
;
1590 if (r
->u
.catch.type_list
!= NULL
)
1592 /* Get a filter value for each of the types caught and store
1593 them in the region's dedicated list. */
1594 tree tp_node
= r
->u
.catch.type_list
;
1596 for (;tp_node
; tp_node
= TREE_CHAIN (tp_node
))
1598 int flt
= add_ttypes_entry (ttypes
, TREE_VALUE (tp_node
));
1599 tree flt_node
= build_int_2 (flt
, 0);
1601 r
->u
.catch.filter_list
1602 = tree_cons (NULL_TREE
, flt_node
, r
->u
.catch.filter_list
);
1607 /* Get a filter value for the NULL list also since it will need
1608 an action record anyway. */
1609 int flt
= add_ttypes_entry (ttypes
, NULL
);
1610 tree flt_node
= build_int_2 (flt
, 0);
1612 r
->u
.catch.filter_list
1613 = tree_cons (NULL_TREE
, flt_node
, r
->u
.catch.filter_list
);
1618 case ERT_ALLOWED_EXCEPTIONS
:
1620 = add_ehspec_entry (ehspec
, ttypes
, r
->u
.allowed
.type_list
);
1628 htab_delete (ttypes
);
1629 htab_delete (ehspec
);
1632 /* Emit SEQ into basic block just before INSN (that is assumed to be
1633 first instruction of some existing BB and return the newly
1636 emit_to_new_bb_before (rtx seq
, rtx insn
)
1641 last
= emit_insn_before (seq
, insn
);
1642 if (GET_CODE (last
) == BARRIER
)
1643 last
= PREV_INSN (last
);
1644 bb
= create_basic_block (seq
, last
, BLOCK_FOR_INSN (insn
)->prev_bb
);
1645 update_bb_for_insn (bb
);
1646 bb
->flags
|= BB_SUPERBLOCK
;
1650 /* Generate the code to actually handle exceptions, which will follow the
1654 build_post_landing_pads (void)
1658 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1660 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
1663 /* Mind we don't process a region more than once. */
1664 if (!region
|| region
->region_number
!= i
)
1667 switch (region
->type
)
1670 /* ??? Collect the set of all non-overlapping catch handlers
1671 all the way up the chain until blocked by a cleanup. */
1672 /* ??? Outer try regions can share landing pads with inner
1673 try regions if the types are completely non-overlapping,
1674 and there are no intervening cleanups. */
1676 region
->post_landing_pad
= gen_label_rtx ();
1680 emit_label (region
->post_landing_pad
);
1682 /* ??? It is mighty inconvenient to call back into the
1683 switch statement generation code in expand_end_case.
1684 Rapid prototyping sez a sequence of ifs. */
1686 struct eh_region
*c
;
1687 for (c
= region
->u
.try.catch; c
; c
= c
->u
.catch.next_catch
)
1689 if (c
->u
.catch.type_list
== NULL
)
1690 emit_jump (c
->label
);
1693 /* Need for one cmp/jump per type caught. Each type
1694 list entry has a matching entry in the filter list
1695 (see assign_filter_values). */
1696 tree tp_node
= c
->u
.catch.type_list
;
1697 tree flt_node
= c
->u
.catch.filter_list
;
1701 emit_cmp_and_jump_insns
1703 GEN_INT (tree_low_cst (TREE_VALUE (flt_node
), 0)),
1704 EQ
, NULL_RTX
, word_mode
, 0, c
->label
);
1706 tp_node
= TREE_CHAIN (tp_node
);
1707 flt_node
= TREE_CHAIN (flt_node
);
1713 /* We delay the generation of the _Unwind_Resume until we generate
1714 landing pads. We emit a marker here so as to get good control
1715 flow data in the meantime. */
1717 = emit_jump_insn (gen_rtx_RESX (VOIDmode
, region
->region_number
));
1723 emit_to_new_bb_before (seq
, region
->u
.try.catch->label
);
1727 case ERT_ALLOWED_EXCEPTIONS
:
1728 region
->post_landing_pad
= gen_label_rtx ();
1732 emit_label (region
->post_landing_pad
);
1734 emit_cmp_and_jump_insns (cfun
->eh
->filter
,
1735 GEN_INT (region
->u
.allowed
.filter
),
1736 EQ
, NULL_RTX
, word_mode
, 0, region
->label
);
1738 /* We delay the generation of the _Unwind_Resume until we generate
1739 landing pads. We emit a marker here so as to get good control
1740 flow data in the meantime. */
1742 = emit_jump_insn (gen_rtx_RESX (VOIDmode
, region
->region_number
));
1748 emit_to_new_bb_before (seq
, region
->label
);
1752 case ERT_MUST_NOT_THROW
:
1753 region
->post_landing_pad
= region
->label
;
1758 /* Nothing to do. */
1767 /* Replace RESX patterns with jumps to the next handler if any, or calls to
1768 _Unwind_Resume otherwise. */
1771 connect_post_landing_pads (void)
1775 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1777 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
1778 struct eh_region
*outer
;
1782 /* Mind we don't process a region more than once. */
1783 if (!region
|| region
->region_number
!= i
)
1786 /* If there is no RESX, or it has been deleted by flow, there's
1787 nothing to fix up. */
1788 if (! region
->resume
|| INSN_DELETED_P (region
->resume
))
1791 /* Search for another landing pad in this function. */
1792 for (outer
= region
->outer
; outer
; outer
= outer
->outer
)
1793 if (outer
->post_landing_pad
)
1801 basic_block src
, dest
;
1803 emit_jump (outer
->post_landing_pad
);
1804 src
= BLOCK_FOR_INSN (region
->resume
);
1805 dest
= BLOCK_FOR_INSN (outer
->post_landing_pad
);
1807 remove_edge (src
->succ
);
1808 e
= make_edge (src
, dest
, 0);
1809 e
->probability
= REG_BR_PROB_BASE
;
1810 e
->count
= src
->count
;
1813 emit_library_call (unwind_resume_libfunc
, LCT_THROW
,
1814 VOIDmode
, 1, cfun
->eh
->exc_ptr
, ptr_mode
);
1818 barrier
= emit_insn_before (seq
, region
->resume
);
1819 /* Avoid duplicate barrier. */
1820 if (GET_CODE (barrier
) != BARRIER
)
1822 delete_insn (barrier
);
1823 delete_insn (region
->resume
);
1829 dw2_build_landing_pads (void)
1834 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1836 struct eh_region
*region
= cfun
->eh
->region_array
[i
];
1839 bool clobbers_hard_regs
= false;
1842 /* Mind we don't process a region more than once. */
1843 if (!region
|| region
->region_number
!= i
)
1846 if (region
->type
!= ERT_CLEANUP
1847 && region
->type
!= ERT_TRY
1848 && region
->type
!= ERT_ALLOWED_EXCEPTIONS
)
1853 region
->landing_pad
= gen_label_rtx ();
1854 emit_label (region
->landing_pad
);
1856 #ifdef HAVE_exception_receiver
1857 if (HAVE_exception_receiver
)
1858 emit_insn (gen_exception_receiver ());
1861 #ifdef HAVE_nonlocal_goto_receiver
1862 if (HAVE_nonlocal_goto_receiver
)
1863 emit_insn (gen_nonlocal_goto_receiver ());
1868 /* If the eh_return data registers are call-saved, then we
1869 won't have considered them clobbered from the call that
1870 threw. Kill them now. */
1873 unsigned r
= EH_RETURN_DATA_REGNO (j
);
1874 if (r
== INVALID_REGNUM
)
1876 if (! call_used_regs
[r
])
1878 emit_insn (gen_rtx_CLOBBER (VOIDmode
, gen_rtx_REG (Pmode
, r
)));
1879 clobbers_hard_regs
= true;
1883 if (clobbers_hard_regs
)
1885 /* @@@ This is a kludge. Not all machine descriptions define a
1886 blockage insn, but we must not allow the code we just generated
1887 to be reordered by scheduling. So emit an ASM_INPUT to act as
1889 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
, ""));
1892 emit_move_insn (cfun
->eh
->exc_ptr
,
1893 gen_rtx_REG (ptr_mode
, EH_RETURN_DATA_REGNO (0)));
1894 emit_move_insn (cfun
->eh
->filter
,
1895 gen_rtx_REG (word_mode
, EH_RETURN_DATA_REGNO (1)));
1900 bb
= emit_to_new_bb_before (seq
, region
->post_landing_pad
);
1901 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
1902 e
->count
= bb
->count
;
1903 e
->probability
= REG_BR_PROB_BASE
;
1910 int directly_reachable
;
1913 int call_site_index
;
1917 sjlj_find_directly_reachable_regions (struct sjlj_lp_info
*lp_info
)
1920 bool found_one
= false;
1922 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1924 struct eh_region
*region
;
1925 enum reachable_code rc
;
1929 if (! INSN_P (insn
))
1932 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
1933 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
1936 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
1938 type_thrown
= NULL_TREE
;
1939 if (region
->type
== ERT_THROW
)
1941 type_thrown
= region
->u
.throw.type
;
1942 region
= region
->outer
;
1945 /* Find the first containing region that might handle the exception.
1946 That's the landing pad to which we will transfer control. */
1947 rc
= RNL_NOT_CAUGHT
;
1948 for (; region
; region
= region
->outer
)
1950 rc
= reachable_next_level (region
, type_thrown
, 0);
1951 if (rc
!= RNL_NOT_CAUGHT
)
1954 if (rc
== RNL_MAYBE_CAUGHT
|| rc
== RNL_CAUGHT
)
1956 lp_info
[region
->region_number
].directly_reachable
= 1;
1965 sjlj_assign_call_site_values (rtx dispatch_label
, struct sjlj_lp_info
*lp_info
)
1970 /* First task: build the action table. */
1972 VARRAY_UCHAR_INIT (cfun
->eh
->action_record_data
, 64, "action_record_data");
1973 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
1975 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1976 if (lp_info
[i
].directly_reachable
)
1978 struct eh_region
*r
= cfun
->eh
->region_array
[i
];
1979 r
->landing_pad
= dispatch_label
;
1980 lp_info
[i
].action_index
= collect_one_action_chain (ar_hash
, r
);
1981 if (lp_info
[i
].action_index
!= -1)
1982 cfun
->uses_eh_lsda
= 1;
1985 htab_delete (ar_hash
);
1987 /* Next: assign dispatch values. In dwarf2 terms, this would be the
1988 landing pad label for the region. For sjlj though, there is one
1989 common landing pad from which we dispatch to the post-landing pads.
1991 A region receives a dispatch index if it is directly reachable
1992 and requires in-function processing. Regions that share post-landing
1993 pads may share dispatch indices. */
1994 /* ??? Post-landing pad sharing doesn't actually happen at the moment
1995 (see build_post_landing_pads) so we don't bother checking for it. */
1998 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
1999 if (lp_info
[i
].directly_reachable
)
2000 lp_info
[i
].dispatch_index
= index
++;
2002 /* Finally: assign call-site values. If dwarf2 terms, this would be
2003 the region number assigned by convert_to_eh_region_ranges, but
2004 handles no-action and must-not-throw differently. */
2007 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
2008 if (lp_info
[i
].directly_reachable
)
2010 int action
= lp_info
[i
].action_index
;
2012 /* Map must-not-throw to otherwise unused call-site index 0. */
2015 /* Map no-action to otherwise unused call-site index -1. */
2016 else if (action
== -1)
2018 /* Otherwise, look it up in the table. */
2020 index
= add_call_site (GEN_INT (lp_info
[i
].dispatch_index
), action
);
2022 lp_info
[i
].call_site_index
= index
;
2027 sjlj_mark_call_sites (struct sjlj_lp_info
*lp_info
)
2029 int last_call_site
= -2;
2032 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
2034 struct eh_region
*region
;
2036 rtx note
, before
, p
;
2038 /* Reset value tracking at extended basic block boundaries. */
2039 if (GET_CODE (insn
) == CODE_LABEL
)
2040 last_call_site
= -2;
2042 if (! INSN_P (insn
))
2045 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2048 /* Calls (and trapping insns) without notes are outside any
2049 exception handling region in this function. Mark them as
2051 if (GET_CODE (insn
) == CALL_INSN
2052 || (flag_non_call_exceptions
2053 && may_trap_p (PATTERN (insn
))))
2054 this_call_site
= -1;
2060 /* Calls that are known to not throw need not be marked. */
2061 if (INTVAL (XEXP (note
, 0)) <= 0)
2064 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
2065 this_call_site
= lp_info
[region
->region_number
].call_site_index
;
2068 if (this_call_site
== last_call_site
)
2071 /* Don't separate a call from it's argument loads. */
2073 if (GET_CODE (insn
) == CALL_INSN
)
2074 before
= find_first_parameter_load (insn
, NULL_RTX
);
2077 mem
= adjust_address (cfun
->eh
->sjlj_fc
, TYPE_MODE (integer_type_node
),
2078 sjlj_fc_call_site_ofs
);
2079 emit_move_insn (mem
, GEN_INT (this_call_site
));
2083 emit_insn_before (p
, before
);
2084 last_call_site
= this_call_site
;
2088 /* Construct the SjLj_Function_Context. */
2091 sjlj_emit_function_enter (rtx dispatch_label
)
2093 rtx fn_begin
, fc
, mem
, seq
;
2095 fc
= cfun
->eh
->sjlj_fc
;
2099 /* We're storing this libcall's address into memory instead of
2100 calling it directly. Thus, we must call assemble_external_libcall
2101 here, as we can not depend on emit_library_call to do it for us. */
2102 assemble_external_libcall (eh_personality_libfunc
);
2103 mem
= adjust_address (fc
, Pmode
, sjlj_fc_personality_ofs
);
2104 emit_move_insn (mem
, eh_personality_libfunc
);
2106 mem
= adjust_address (fc
, Pmode
, sjlj_fc_lsda_ofs
);
2107 if (cfun
->uses_eh_lsda
)
2112 ASM_GENERATE_INTERNAL_LABEL (buf
, "LLSDA", current_function_funcdef_no
);
2113 sym
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
2114 SYMBOL_REF_FLAGS (sym
) = SYMBOL_FLAG_LOCAL
;
2115 emit_move_insn (mem
, sym
);
2118 emit_move_insn (mem
, const0_rtx
);
2120 #ifdef DONT_USE_BUILTIN_SETJMP
2123 x
= emit_library_call_value (setjmp_libfunc
, NULL_RTX
, LCT_RETURNS_TWICE
,
2124 TYPE_MODE (integer_type_node
), 1,
2125 plus_constant (XEXP (fc
, 0),
2126 sjlj_fc_jbuf_ofs
), Pmode
);
2128 note
= emit_note (NOTE_INSN_EXPECTED_VALUE
);
2129 NOTE_EXPECTED_VALUE (note
) = gen_rtx_EQ (VOIDmode
, x
, const0_rtx
);
2131 emit_cmp_and_jump_insns (x
, const0_rtx
, NE
, 0,
2132 TYPE_MODE (integer_type_node
), 0, dispatch_label
);
2135 expand_builtin_setjmp_setup (plus_constant (XEXP (fc
, 0), sjlj_fc_jbuf_ofs
),
2139 emit_library_call (unwind_sjlj_register_libfunc
, LCT_NORMAL
, VOIDmode
,
2140 1, XEXP (fc
, 0), Pmode
);
2145 /* ??? Instead of doing this at the beginning of the function,
2146 do this in a block that is at loop level 0 and dominates all
2147 can_throw_internal instructions. */
2149 for (fn_begin
= get_insns (); ; fn_begin
= NEXT_INSN (fn_begin
))
2150 if (GET_CODE (fn_begin
) == NOTE
2151 && (NOTE_LINE_NUMBER (fn_begin
) == NOTE_INSN_FUNCTION_BEG
2152 || NOTE_LINE_NUMBER (fn_begin
) == NOTE_INSN_BASIC_BLOCK
))
2154 if (NOTE_LINE_NUMBER (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
2155 insert_insn_on_edge (seq
, ENTRY_BLOCK_PTR
->succ
);
2158 rtx last
= BB_END (ENTRY_BLOCK_PTR
->succ
->dest
);
2159 for (; ; fn_begin
= NEXT_INSN (fn_begin
))
2160 if ((GET_CODE (fn_begin
) == NOTE
2161 && NOTE_LINE_NUMBER (fn_begin
) == NOTE_INSN_FUNCTION_BEG
)
2162 || fn_begin
== last
)
2164 emit_insn_after (seq
, fn_begin
);
2168 /* Call back from expand_function_end to know where we should put
2169 the call to unwind_sjlj_unregister_libfunc if needed. */
2172 sjlj_emit_function_exit_after (rtx after
)
2174 cfun
->eh
->sjlj_exit_after
= after
;
2178 sjlj_emit_function_exit (void)
2185 emit_library_call (unwind_sjlj_unregister_libfunc
, LCT_NORMAL
, VOIDmode
,
2186 1, XEXP (cfun
->eh
->sjlj_fc
, 0), Pmode
);
2191 /* ??? Really this can be done in any block at loop level 0 that
2192 post-dominates all can_throw_internal instructions. This is
2193 the last possible moment. */
2195 for (e
= EXIT_BLOCK_PTR
->pred
; e
; e
= e
->pred_next
)
2196 if (e
->flags
& EDGE_FALLTHRU
)
2202 /* Figure out whether the place we are supposed to insert libcall
2203 is inside the last basic block or after it. In the other case
2204 we need to emit to edge. */
2205 if (e
->src
->next_bb
!= EXIT_BLOCK_PTR
)
2207 for (insn
= NEXT_INSN (BB_END (e
->src
)); insn
; insn
= NEXT_INSN (insn
))
2208 if (insn
== cfun
->eh
->sjlj_exit_after
)
2211 insert_insn_on_edge (seq
, e
);
2214 insn
= cfun
->eh
->sjlj_exit_after
;
2215 if (GET_CODE (insn
) == CODE_LABEL
)
2216 insn
= NEXT_INSN (insn
);
2217 emit_insn_after (seq
, insn
);
2223 sjlj_emit_dispatch_table (rtx dispatch_label
, struct sjlj_lp_info
*lp_info
)
2225 int i
, first_reachable
;
2226 rtx mem
, dispatch
, seq
, fc
;
2231 fc
= cfun
->eh
->sjlj_fc
;
2235 emit_label (dispatch_label
);
2237 #ifndef DONT_USE_BUILTIN_SETJMP
2238 expand_builtin_setjmp_receiver (dispatch_label
);
2241 /* Load up dispatch index, exc_ptr and filter values from the
2242 function context. */
2243 mem
= adjust_address (fc
, TYPE_MODE (integer_type_node
),
2244 sjlj_fc_call_site_ofs
);
2245 dispatch
= copy_to_reg (mem
);
2247 mem
= adjust_address (fc
, word_mode
, sjlj_fc_data_ofs
);
2248 if (word_mode
!= ptr_mode
)
2250 #ifdef POINTERS_EXTEND_UNSIGNED
2251 mem
= convert_memory_address (ptr_mode
, mem
);
2253 mem
= convert_to_mode (ptr_mode
, mem
, 0);
2256 emit_move_insn (cfun
->eh
->exc_ptr
, mem
);
2258 mem
= adjust_address (fc
, word_mode
, sjlj_fc_data_ofs
+ UNITS_PER_WORD
);
2259 emit_move_insn (cfun
->eh
->filter
, mem
);
2261 /* Jump to one of the directly reachable regions. */
2262 /* ??? This really ought to be using a switch statement. */
2264 first_reachable
= 0;
2265 for (i
= cfun
->eh
->last_region_number
; i
> 0; --i
)
2267 if (! lp_info
[i
].directly_reachable
)
2270 if (! first_reachable
)
2272 first_reachable
= i
;
2276 emit_cmp_and_jump_insns (dispatch
, GEN_INT (lp_info
[i
].dispatch_index
),
2277 EQ
, NULL_RTX
, TYPE_MODE (integer_type_node
), 0,
2278 cfun
->eh
->region_array
[i
]->post_landing_pad
);
2284 before
= cfun
->eh
->region_array
[first_reachable
]->post_landing_pad
;
2286 bb
= emit_to_new_bb_before (seq
, before
);
2287 e
= make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
2288 e
->count
= bb
->count
;
2289 e
->probability
= REG_BR_PROB_BASE
;
2293 sjlj_build_landing_pads (void)
2295 struct sjlj_lp_info
*lp_info
;
2297 lp_info
= xcalloc (cfun
->eh
->last_region_number
+ 1,
2298 sizeof (struct sjlj_lp_info
));
2300 if (sjlj_find_directly_reachable_regions (lp_info
))
2302 rtx dispatch_label
= gen_label_rtx ();
2305 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node
),
2306 int_size_in_bytes (sjlj_fc_type_node
),
2307 TYPE_ALIGN (sjlj_fc_type_node
));
2309 sjlj_assign_call_site_values (dispatch_label
, lp_info
);
2310 sjlj_mark_call_sites (lp_info
);
2312 sjlj_emit_function_enter (dispatch_label
);
2313 sjlj_emit_dispatch_table (dispatch_label
, lp_info
);
2314 sjlj_emit_function_exit ();
2321 finish_eh_generation (void)
2325 /* Nothing to do if no regions created. */
2326 if (cfun
->eh
->region_tree
== NULL
)
2329 /* The object here is to provide find_basic_blocks with detailed
2330 information (via reachable_handlers) on how exception control
2331 flows within the function. In this first pass, we can include
2332 type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS
2333 regions, and hope that it will be useful in deleting unreachable
2334 handlers. Subsequently, we will generate landing pads which will
2335 connect many of the handlers, and then type information will not
2336 be effective. Still, this is a win over previous implementations. */
2338 cleanup_cfg (CLEANUP_PRE_LOOP
| CLEANUP_NO_INSN_DEL
);
2340 /* These registers are used by the landing pads. Make sure they
2341 have been generated. */
2342 get_exception_pointer (cfun
);
2343 get_exception_filter (cfun
);
2345 /* Construct the landing pads. */
2347 assign_filter_values ();
2348 build_post_landing_pads ();
2349 connect_post_landing_pads ();
2350 if (USING_SJLJ_EXCEPTIONS
)
2351 sjlj_build_landing_pads ();
2353 dw2_build_landing_pads ();
2355 cfun
->eh
->built_landing_pads
= 1;
2357 /* We've totally changed the CFG. Start over. */
2358 find_exception_handler_labels ();
2359 break_superblocks ();
2360 if (USING_SJLJ_EXCEPTIONS
)
2361 commit_edge_insertions ();
2366 for (e
= bb
->succ
; e
; e
= next
)
2368 next
= e
->succ_next
;
2369 if (e
->flags
& EDGE_EH
)
2376 make_eh_edge (NULL
, bb
, BB_END (bb
));
2378 cleanup_cfg (CLEANUP_PRE_LOOP
| CLEANUP_NO_INSN_DEL
);
2382 ehl_hash (const void *pentry
)
2384 struct ehl_map_entry
*entry
= (struct ehl_map_entry
*) pentry
;
2386 /* 2^32 * ((sqrt(5) - 1) / 2) */
2387 const hashval_t scaled_golden_ratio
= 0x9e3779b9;
2388 return CODE_LABEL_NUMBER (entry
->label
) * scaled_golden_ratio
;
2392 ehl_eq (const void *pentry
, const void *pdata
)
2394 struct ehl_map_entry
*entry
= (struct ehl_map_entry
*) pentry
;
2395 struct ehl_map_entry
*data
= (struct ehl_map_entry
*) pdata
;
2397 return entry
->label
== data
->label
;
2400 /* This section handles removing dead code for flow. */
2402 /* Remove LABEL from exception_handler_label_map. */
2405 remove_exception_handler_label (rtx label
)
2407 struct ehl_map_entry
**slot
, tmp
;
2409 /* If exception_handler_label_map was not built yet,
2410 there is nothing to do. */
2411 if (cfun
->eh
->exception_handler_label_map
== NULL
)
2415 slot
= (struct ehl_map_entry
**)
2416 htab_find_slot (cfun
->eh
->exception_handler_label_map
, &tmp
, NO_INSERT
);
2420 htab_clear_slot (cfun
->eh
->exception_handler_label_map
, (void **) slot
);
2423 /* Splice REGION from the region tree etc. */
2426 remove_eh_handler (struct eh_region
*region
)
2428 struct eh_region
**pp
, **pp_start
, *p
, *outer
, *inner
;
2431 /* For the benefit of efficiently handling REG_EH_REGION notes,
2432 replace this region in the region array with its containing
2433 region. Note that previous region deletions may result in
2434 multiple copies of this region in the array, so we have a
2435 list of alternate numbers by which we are known. */
2437 outer
= region
->outer
;
2438 cfun
->eh
->region_array
[region
->region_number
] = outer
;
2442 EXECUTE_IF_SET_IN_BITMAP (region
->aka
, 0, i
,
2443 { cfun
->eh
->region_array
[i
] = outer
; });
2449 outer
->aka
= BITMAP_GGC_ALLOC ();
2451 bitmap_a_or_b (outer
->aka
, outer
->aka
, region
->aka
);
2452 bitmap_set_bit (outer
->aka
, region
->region_number
);
2455 if (cfun
->eh
->built_landing_pads
)
2456 lab
= region
->landing_pad
;
2458 lab
= region
->label
;
2460 remove_exception_handler_label (lab
);
2463 pp_start
= &outer
->inner
;
2465 pp_start
= &cfun
->eh
->region_tree
;
2466 for (pp
= pp_start
, p
= *pp
; p
!= region
; pp
= &p
->next_peer
, p
= *pp
)
2468 *pp
= region
->next_peer
;
2470 inner
= region
->inner
;
2473 for (p
= inner
; p
->next_peer
; p
= p
->next_peer
)
2477 p
->next_peer
= *pp_start
;
2481 if (region
->type
== ERT_CATCH
)
2483 struct eh_region
*try, *next
, *prev
;
2485 for (try = region
->next_peer
;
2486 try->type
== ERT_CATCH
;
2487 try = try->next_peer
)
2489 if (try->type
!= ERT_TRY
)
2492 next
= region
->u
.catch.next_catch
;
2493 prev
= region
->u
.catch.prev_catch
;
2496 next
->u
.catch.prev_catch
= prev
;
2498 try->u
.try.last_catch
= prev
;
2500 prev
->u
.catch.next_catch
= next
;
2503 try->u
.try.catch = next
;
2505 remove_eh_handler (try);
2510 /* LABEL heads a basic block that is about to be deleted. If this
2511 label corresponds to an exception region, we may be able to
2512 delete the region. */
2515 maybe_remove_eh_handler (rtx label
)
2517 struct ehl_map_entry
**slot
, tmp
;
2518 struct eh_region
*region
;
2520 /* ??? After generating landing pads, it's not so simple to determine
2521 if the region data is completely unused. One must examine the
2522 landing pad and the post landing pad, and whether an inner try block
2523 is referencing the catch handlers directly. */
2524 if (cfun
->eh
->built_landing_pads
)
2528 slot
= (struct ehl_map_entry
**)
2529 htab_find_slot (cfun
->eh
->exception_handler_label_map
, &tmp
, NO_INSERT
);
2532 region
= (*slot
)->region
;
2536 /* Flow will want to remove MUST_NOT_THROW regions as unreachable
2537 because there is no path to the fallback call to terminate.
2538 But the region continues to affect call-site data until there
2539 are no more contained calls, which we don't see here. */
2540 if (region
->type
== ERT_MUST_NOT_THROW
)
2542 htab_clear_slot (cfun
->eh
->exception_handler_label_map
, (void **) slot
);
2543 region
->label
= NULL_RTX
;
2546 remove_eh_handler (region
);
2549 /* Invokes CALLBACK for every exception handler label. Only used by old
2550 loop hackery; should not be used by new code. */
2553 for_each_eh_label (void (*callback
) (rtx
))
2555 htab_traverse (cfun
->eh
->exception_handler_label_map
, for_each_eh_label_1
,
2556 (void *) &callback
);
2560 for_each_eh_label_1 (void **pentry
, void *data
)
2562 struct ehl_map_entry
*entry
= *(struct ehl_map_entry
**)pentry
;
2563 void (*callback
) (rtx
) = *(void (**) (rtx
)) data
;
2565 (*callback
) (entry
->label
);
2569 /* This section describes CFG exception edges for flow. */
2571 /* For communicating between calls to reachable_next_level. */
2572 struct reachable_info
GTY(())
2579 /* A subroutine of reachable_next_level. Return true if TYPE, or a
2580 base class of TYPE, is in HANDLED. */
2583 check_handled (tree handled
, tree type
)
2587 /* We can check for exact matches without front-end help. */
2588 if (! lang_eh_type_covers
)
2590 for (t
= handled
; t
; t
= TREE_CHAIN (t
))
2591 if (TREE_VALUE (t
) == type
)
2596 for (t
= handled
; t
; t
= TREE_CHAIN (t
))
2597 if ((*lang_eh_type_covers
) (TREE_VALUE (t
), type
))
2604 /* A subroutine of reachable_next_level. If we are collecting a list
2605 of handlers, add one. After landing pad generation, reference
2606 it instead of the handlers themselves. Further, the handlers are
2607 all wired together, so by referencing one, we've got them all.
2608 Before landing pad generation we reference each handler individually.
2610 LP_REGION contains the landing pad; REGION is the handler. */
2613 add_reachable_handler (struct reachable_info
*info
, struct eh_region
*lp_region
, struct eh_region
*region
)
2618 if (cfun
->eh
->built_landing_pads
)
2620 if (! info
->handlers
)
2621 info
->handlers
= alloc_INSN_LIST (lp_region
->landing_pad
, NULL_RTX
);
2624 info
->handlers
= alloc_INSN_LIST (region
->label
, info
->handlers
);
2627 /* Process one level of exception regions for reachability.
2628 If TYPE_THROWN is non-null, then it is the *exact* type being
2629 propagated. If INFO is non-null, then collect handler labels
2630 and caught/allowed type information between invocations. */
2632 static enum reachable_code
2633 reachable_next_level (struct eh_region
*region
, tree type_thrown
,
2634 struct reachable_info
*info
)
2636 switch (region
->type
)
2639 /* Before landing-pad generation, we model control flow
2640 directly to the individual handlers. In this way we can
2641 see that catch handler types may shadow one another. */
2642 add_reachable_handler (info
, region
, region
);
2643 return RNL_MAYBE_CAUGHT
;
2647 struct eh_region
*c
;
2648 enum reachable_code ret
= RNL_NOT_CAUGHT
;
2650 for (c
= region
->u
.try.catch; c
; c
= c
->u
.catch.next_catch
)
2652 /* A catch-all handler ends the search. */
2653 if (c
->u
.catch.type_list
== NULL
)
2655 add_reachable_handler (info
, region
, c
);
2661 /* If we have at least one type match, end the search. */
2662 tree tp_node
= c
->u
.catch.type_list
;
2664 for (; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
2666 tree type
= TREE_VALUE (tp_node
);
2668 if (type
== type_thrown
2669 || (lang_eh_type_covers
2670 && (*lang_eh_type_covers
) (type
, type_thrown
)))
2672 add_reachable_handler (info
, region
, c
);
2677 /* If we have definitive information of a match failure,
2678 the catch won't trigger. */
2679 if (lang_eh_type_covers
)
2680 return RNL_NOT_CAUGHT
;
2683 /* At this point, we either don't know what type is thrown or
2684 don't have front-end assistance to help deciding if it is
2685 covered by one of the types in the list for this region.
2687 We'd then like to add this region to the list of reachable
2688 handlers since it is indeed potentially reachable based on the
2689 information we have.
2691 Actually, this handler is for sure not reachable if all the
2692 types it matches have already been caught. That is, it is only
2693 potentially reachable if at least one of the types it catches
2694 has not been previously caught. */
2697 ret
= RNL_MAYBE_CAUGHT
;
2700 tree tp_node
= c
->u
.catch.type_list
;
2701 bool maybe_reachable
= false;
2703 /* Compute the potential reachability of this handler and
2704 update the list of types caught at the same time. */
2705 for (; tp_node
; tp_node
= TREE_CHAIN (tp_node
))
2707 tree type
= TREE_VALUE (tp_node
);
2709 if (! check_handled (info
->types_caught
, type
))
2712 = tree_cons (NULL
, type
, info
->types_caught
);
2714 maybe_reachable
= true;
2718 if (maybe_reachable
)
2720 add_reachable_handler (info
, region
, c
);
2722 /* ??? If the catch type is a base class of every allowed
2723 type, then we know we can stop the search. */
2724 ret
= RNL_MAYBE_CAUGHT
;
2732 case ERT_ALLOWED_EXCEPTIONS
:
2733 /* An empty list of types definitely ends the search. */
2734 if (region
->u
.allowed
.type_list
== NULL_TREE
)
2736 add_reachable_handler (info
, region
, region
);
2740 /* Collect a list of lists of allowed types for use in detecting
2741 when a catch may be transformed into a catch-all. */
2743 info
->types_allowed
= tree_cons (NULL_TREE
,
2744 region
->u
.allowed
.type_list
,
2745 info
->types_allowed
);
2747 /* If we have definitive information about the type hierarchy,
2748 then we can tell if the thrown type will pass through the
2750 if (type_thrown
&& lang_eh_type_covers
)
2752 if (check_handled (region
->u
.allowed
.type_list
, type_thrown
))
2753 return RNL_NOT_CAUGHT
;
2756 add_reachable_handler (info
, region
, region
);
2761 add_reachable_handler (info
, region
, region
);
2762 return RNL_MAYBE_CAUGHT
;
2765 /* Catch regions are handled by their controlling try region. */
2766 return RNL_NOT_CAUGHT
;
2768 case ERT_MUST_NOT_THROW
:
2769 /* Here we end our search, since no exceptions may propagate.
2770 If we've touched down at some landing pad previous, then the
2771 explicit function call we generated may be used. Otherwise
2772 the call is made by the runtime. */
2773 if (info
&& info
->handlers
)
2775 add_reachable_handler (info
, region
, region
);
2784 /* Shouldn't see these here. */
2791 /* Retrieve a list of labels of exception handlers which can be
2792 reached by a given insn. */
2795 reachable_handlers (rtx insn
)
2797 struct reachable_info info
;
2798 struct eh_region
*region
;
2802 if (GET_CODE (insn
) == JUMP_INSN
2803 && GET_CODE (PATTERN (insn
)) == RESX
)
2804 region_number
= XINT (PATTERN (insn
), 0);
2807 rtx note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2808 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
2810 region_number
= INTVAL (XEXP (note
, 0));
2813 memset (&info
, 0, sizeof (info
));
2815 region
= cfun
->eh
->region_array
[region_number
];
2817 type_thrown
= NULL_TREE
;
2818 if (GET_CODE (insn
) == JUMP_INSN
2819 && GET_CODE (PATTERN (insn
)) == RESX
)
2821 /* A RESX leaves a region instead of entering it. Thus the
2822 region itself may have been deleted out from under us. */
2825 region
= region
->outer
;
2827 else if (region
->type
== ERT_THROW
)
2829 type_thrown
= region
->u
.throw.type
;
2830 region
= region
->outer
;
2835 if (reachable_next_level (region
, type_thrown
, &info
) >= RNL_CAUGHT
)
2837 /* If we have processed one cleanup, there is no point in
2838 processing any more of them. Each cleanup will have an edge
2839 to the next outer cleanup region, so the flow graph will be
2841 if (region
->type
== ERT_CLEANUP
)
2842 region
= region
->u
.cleanup
.prev_try
;
2844 region
= region
->outer
;
2847 return info
.handlers
;
2850 /* Determine if the given INSN can throw an exception that is caught
2851 within the function. */
2854 can_throw_internal (rtx insn
)
2856 struct eh_region
*region
;
2860 if (! INSN_P (insn
))
2863 if (GET_CODE (insn
) == INSN
2864 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2865 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2867 if (GET_CODE (insn
) == CALL_INSN
2868 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
2871 for (i
= 0; i
< 3; ++i
)
2873 rtx sub
= XEXP (PATTERN (insn
), i
);
2874 for (; sub
; sub
= NEXT_INSN (sub
))
2875 if (can_throw_internal (sub
))
2881 /* Every insn that might throw has an EH_REGION note. */
2882 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2883 if (!note
|| INTVAL (XEXP (note
, 0)) <= 0)
2886 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
2888 type_thrown
= NULL_TREE
;
2889 if (region
->type
== ERT_THROW
)
2891 type_thrown
= region
->u
.throw.type
;
2892 region
= region
->outer
;
2895 /* If this exception is ignored by each and every containing region,
2896 then control passes straight out. The runtime may handle some
2897 regions, which also do not require processing internally. */
2898 for (; region
; region
= region
->outer
)
2900 enum reachable_code how
= reachable_next_level (region
, type_thrown
, 0);
2901 if (how
== RNL_BLOCKED
)
2903 if (how
!= RNL_NOT_CAUGHT
)
2910 /* Determine if the given INSN can throw an exception that is
2911 visible outside the function. */
2914 can_throw_external (rtx insn
)
2916 struct eh_region
*region
;
2920 if (! INSN_P (insn
))
2923 if (GET_CODE (insn
) == INSN
2924 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
2925 insn
= XVECEXP (PATTERN (insn
), 0, 0);
2927 if (GET_CODE (insn
) == CALL_INSN
2928 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
2931 for (i
= 0; i
< 3; ++i
)
2933 rtx sub
= XEXP (PATTERN (insn
), i
);
2934 for (; sub
; sub
= NEXT_INSN (sub
))
2935 if (can_throw_external (sub
))
2941 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
2944 /* Calls (and trapping insns) without notes are outside any
2945 exception handling region in this function. We have to
2946 assume it might throw. Given that the front end and middle
2947 ends mark known NOTHROW functions, this isn't so wildly
2949 return (GET_CODE (insn
) == CALL_INSN
2950 || (flag_non_call_exceptions
2951 && may_trap_p (PATTERN (insn
))));
2953 if (INTVAL (XEXP (note
, 0)) <= 0)
2956 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
2958 type_thrown
= NULL_TREE
;
2959 if (region
->type
== ERT_THROW
)
2961 type_thrown
= region
->u
.throw.type
;
2962 region
= region
->outer
;
2965 /* If the exception is caught or blocked by any containing region,
2966 then it is not seen by any calling function. */
2967 for (; region
; region
= region
->outer
)
2968 if (reachable_next_level (region
, type_thrown
, NULL
) >= RNL_CAUGHT
)
2974 /* Set current_function_nothrow and cfun->all_throwers_are_sibcalls. */
2977 set_nothrow_function_flags (void)
2981 current_function_nothrow
= 1;
2983 /* Assume cfun->all_throwers_are_sibcalls until we encounter
2984 something that can throw an exception. We specifically exempt
2985 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
2986 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
2989 cfun
->all_throwers_are_sibcalls
= 1;
2991 if (! flag_exceptions
)
2994 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
2995 if (can_throw_external (insn
))
2997 current_function_nothrow
= 0;
2999 if (GET_CODE (insn
) != CALL_INSN
|| !SIBLING_CALL_P (insn
))
3001 cfun
->all_throwers_are_sibcalls
= 0;
3006 for (insn
= current_function_epilogue_delay_list
; insn
;
3007 insn
= XEXP (insn
, 1))
3008 if (can_throw_external (insn
))
3010 current_function_nothrow
= 0;
3012 if (GET_CODE (insn
) != CALL_INSN
|| !SIBLING_CALL_P (insn
))
3014 cfun
->all_throwers_are_sibcalls
= 0;
3021 /* Various hooks for unwind library. */
3023 /* Do any necessary initialization to access arbitrary stack frames.
3024 On the SPARC, this means flushing the register windows. */
3027 expand_builtin_unwind_init (void)
3029 /* Set this so all the registers get saved in our frame; we need to be
3030 able to copy the saved values for any registers from frames we unwind. */
3031 current_function_has_nonlocal_label
= 1;
3033 #ifdef SETUP_FRAME_ADDRESSES
3034 SETUP_FRAME_ADDRESSES ();
3039 expand_builtin_eh_return_data_regno (tree arglist
)
3041 tree which
= TREE_VALUE (arglist
);
3042 unsigned HOST_WIDE_INT iwhich
;
3044 if (TREE_CODE (which
) != INTEGER_CST
)
3046 error ("argument of `__builtin_eh_return_regno' must be constant");
3050 iwhich
= tree_low_cst (which
, 1);
3051 iwhich
= EH_RETURN_DATA_REGNO (iwhich
);
3052 if (iwhich
== INVALID_REGNUM
)
3055 #ifdef DWARF_FRAME_REGNUM
3056 iwhich
= DWARF_FRAME_REGNUM (iwhich
);
3058 iwhich
= DBX_REGISTER_NUMBER (iwhich
);
3061 return GEN_INT (iwhich
);
3064 /* Given a value extracted from the return address register or stack slot,
3065 return the actual address encoded in that value. */
3068 expand_builtin_extract_return_addr (tree addr_tree
)
3070 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, Pmode
, 0);
3072 if (GET_MODE (addr
) != Pmode
3073 && GET_MODE (addr
) != VOIDmode
)
3075 #ifdef POINTERS_EXTEND_UNSIGNED
3076 addr
= convert_memory_address (Pmode
, addr
);
3078 addr
= convert_to_mode (Pmode
, addr
, 0);
3082 /* First mask out any unwanted bits. */
3083 #ifdef MASK_RETURN_ADDR
3084 expand_and (Pmode
, addr
, MASK_RETURN_ADDR
, addr
);
3087 /* Then adjust to find the real return address. */
3088 #if defined (RETURN_ADDR_OFFSET)
3089 addr
= plus_constant (addr
, RETURN_ADDR_OFFSET
);
3095 /* Given an actual address in addr_tree, do any necessary encoding
3096 and return the value to be stored in the return address register or
3097 stack slot so the epilogue will return to that address. */
3100 expand_builtin_frob_return_addr (tree addr_tree
)
3102 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, 0);
3104 addr
= convert_memory_address (Pmode
, addr
);
3106 #ifdef RETURN_ADDR_OFFSET
3107 addr
= force_reg (Pmode
, addr
);
3108 addr
= plus_constant (addr
, -RETURN_ADDR_OFFSET
);
3114 /* Set up the epilogue with the magic bits we'll need to return to the
3115 exception handler. */
3118 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED
,
3123 #ifdef EH_RETURN_STACKADJ_RTX
3124 tmp
= expand_expr (stackadj_tree
, cfun
->eh
->ehr_stackadj
, VOIDmode
, 0);
3125 tmp
= convert_memory_address (Pmode
, tmp
);
3126 if (!cfun
->eh
->ehr_stackadj
)
3127 cfun
->eh
->ehr_stackadj
= copy_to_reg (tmp
);
3128 else if (tmp
!= cfun
->eh
->ehr_stackadj
)
3129 emit_move_insn (cfun
->eh
->ehr_stackadj
, tmp
);
3132 tmp
= expand_expr (handler_tree
, cfun
->eh
->ehr_handler
, VOIDmode
, 0);
3133 tmp
= convert_memory_address (Pmode
, tmp
);
3134 if (!cfun
->eh
->ehr_handler
)
3135 cfun
->eh
->ehr_handler
= copy_to_reg (tmp
);
3136 else if (tmp
!= cfun
->eh
->ehr_handler
)
3137 emit_move_insn (cfun
->eh
->ehr_handler
, tmp
);
3139 if (!cfun
->eh
->ehr_label
)
3140 cfun
->eh
->ehr_label
= gen_label_rtx ();
3141 emit_jump (cfun
->eh
->ehr_label
);
3145 expand_eh_return (void)
3149 if (! cfun
->eh
->ehr_label
)
3152 current_function_calls_eh_return
= 1;
3154 #ifdef EH_RETURN_STACKADJ_RTX
3155 emit_move_insn (EH_RETURN_STACKADJ_RTX
, const0_rtx
);
3158 around_label
= gen_label_rtx ();
3159 emit_jump (around_label
);
3161 emit_label (cfun
->eh
->ehr_label
);
3162 clobber_return_register ();
3164 #ifdef EH_RETURN_STACKADJ_RTX
3165 emit_move_insn (EH_RETURN_STACKADJ_RTX
, cfun
->eh
->ehr_stackadj
);
3168 #ifdef HAVE_eh_return
3170 emit_insn (gen_eh_return (cfun
->eh
->ehr_handler
));
3174 #ifdef EH_RETURN_HANDLER_RTX
3175 emit_move_insn (EH_RETURN_HANDLER_RTX
, cfun
->eh
->ehr_handler
);
3177 error ("__builtin_eh_return not supported on this target");
3181 emit_label (around_label
);
3184 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
3185 POINTERS_EXTEND_UNSIGNED and return it. */
3188 expand_builtin_extend_pointer (tree addr_tree
)
3190 rtx addr
= expand_expr (addr_tree
, NULL_RTX
, ptr_mode
, 0);
3193 #ifdef POINTERS_EXTEND_UNSIGNED
3194 extend
= POINTERS_EXTEND_UNSIGNED
;
3196 /* The previous EH code did an unsigned extend by default, so we do this also
3201 return convert_modes (word_mode
, ptr_mode
, addr
, extend
);
3204 /* In the following functions, we represent entries in the action table
3205 as 1-based indices. Special cases are:
3207 0: null action record, non-null landing pad; implies cleanups
3208 -1: null action record, null landing pad; implies no action
3209 -2: no call-site entry; implies must_not_throw
3210 -3: we have yet to process outer regions
3212 Further, no special cases apply to the "next" field of the record.
3213 For next, 0 means end of list. */
3215 struct action_record
3223 action_record_eq (const void *pentry
, const void *pdata
)
3225 const struct action_record
*entry
= (const struct action_record
*) pentry
;
3226 const struct action_record
*data
= (const struct action_record
*) pdata
;
3227 return entry
->filter
== data
->filter
&& entry
->next
== data
->next
;
3231 action_record_hash (const void *pentry
)
3233 const struct action_record
*entry
= (const struct action_record
*) pentry
;
3234 return entry
->next
* 1009 + entry
->filter
;
3238 add_action_record (htab_t ar_hash
, int filter
, int next
)
3240 struct action_record
**slot
, *new, tmp
;
3242 tmp
.filter
= filter
;
3244 slot
= (struct action_record
**) htab_find_slot (ar_hash
, &tmp
, INSERT
);
3246 if ((new = *slot
) == NULL
)
3248 new = xmalloc (sizeof (*new));
3249 new->offset
= VARRAY_ACTIVE_SIZE (cfun
->eh
->action_record_data
) + 1;
3250 new->filter
= filter
;
3254 /* The filter value goes in untouched. The link to the next
3255 record is a "self-relative" byte offset, or zero to indicate
3256 that there is no next record. So convert the absolute 1 based
3257 indices we've been carrying around into a displacement. */
3259 push_sleb128 (&cfun
->eh
->action_record_data
, filter
);
3261 next
-= VARRAY_ACTIVE_SIZE (cfun
->eh
->action_record_data
) + 1;
3262 push_sleb128 (&cfun
->eh
->action_record_data
, next
);
3269 collect_one_action_chain (htab_t ar_hash
, struct eh_region
*region
)
3271 struct eh_region
*c
;
3274 /* If we've reached the top of the region chain, then we have
3275 no actions, and require no landing pad. */
3279 switch (region
->type
)
3282 /* A cleanup adds a zero filter to the beginning of the chain, but
3283 there are special cases to look out for. If there are *only*
3284 cleanups along a path, then it compresses to a zero action.
3285 Further, if there are multiple cleanups along a path, we only
3286 need to represent one of them, as that is enough to trigger
3287 entry to the landing pad at runtime. */
3288 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3291 for (c
= region
->outer
; c
; c
= c
->outer
)
3292 if (c
->type
== ERT_CLEANUP
)
3294 return add_action_record (ar_hash
, 0, next
);
3297 /* Process the associated catch regions in reverse order.
3298 If there's a catch-all handler, then we don't need to
3299 search outer regions. Use a magic -3 value to record
3300 that we haven't done the outer search. */
3302 for (c
= region
->u
.try.last_catch
; c
; c
= c
->u
.catch.prev_catch
)
3304 if (c
->u
.catch.type_list
== NULL
)
3306 /* Retrieve the filter from the head of the filter list
3307 where we have stored it (see assign_filter_values). */
3309 = TREE_INT_CST_LOW (TREE_VALUE (c
->u
.catch.filter_list
));
3311 next
= add_action_record (ar_hash
, filter
, 0);
3315 /* Once the outer search is done, trigger an action record for
3316 each filter we have. */
3321 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3323 /* If there is no next action, terminate the chain. */
3326 /* If all outer actions are cleanups or must_not_throw,
3327 we'll have no action record for it, since we had wanted
3328 to encode these states in the call-site record directly.
3329 Add a cleanup action to the chain to catch these. */
3331 next
= add_action_record (ar_hash
, 0, 0);
3334 flt_node
= c
->u
.catch.filter_list
;
3335 for (; flt_node
; flt_node
= TREE_CHAIN (flt_node
))
3337 int filter
= TREE_INT_CST_LOW (TREE_VALUE (flt_node
));
3338 next
= add_action_record (ar_hash
, filter
, next
);
3344 case ERT_ALLOWED_EXCEPTIONS
:
3345 /* An exception specification adds its filter to the
3346 beginning of the chain. */
3347 next
= collect_one_action_chain (ar_hash
, region
->outer
);
3348 return add_action_record (ar_hash
, region
->u
.allowed
.filter
,
3349 next
< 0 ? 0 : next
);
3351 case ERT_MUST_NOT_THROW
:
3352 /* A must-not-throw region with no inner handlers or cleanups
3353 requires no call-site entry. Note that this differs from
3354 the no handler or cleanup case in that we do require an lsda
3355 to be generated. Return a magic -2 value to record this. */
3360 /* CATCH regions are handled in TRY above. THROW regions are
3361 for optimization information only and produce no output. */
3362 return collect_one_action_chain (ar_hash
, region
->outer
);
3370 add_call_site (rtx landing_pad
, int action
)
3372 struct call_site_record
*data
= cfun
->eh
->call_site_data
;
3373 int used
= cfun
->eh
->call_site_data_used
;
3374 int size
= cfun
->eh
->call_site_data_size
;
3378 size
= (size
? size
* 2 : 64);
3379 data
= ggc_realloc (data
, sizeof (*data
) * size
);
3380 cfun
->eh
->call_site_data
= data
;
3381 cfun
->eh
->call_site_data_size
= size
;
3384 data
[used
].landing_pad
= landing_pad
;
3385 data
[used
].action
= action
;
3387 cfun
->eh
->call_site_data_used
= used
+ 1;
3389 return used
+ call_site_base
;
3392 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
3393 The new note numbers will not refer to region numbers, but
3394 instead to call site entries. */
3397 convert_to_eh_region_ranges (void)
3399 rtx insn
, iter
, note
;
3401 int last_action
= -3;
3402 rtx last_action_insn
= NULL_RTX
;
3403 rtx last_landing_pad
= NULL_RTX
;
3404 rtx first_no_action_insn
= NULL_RTX
;
3407 if (USING_SJLJ_EXCEPTIONS
|| cfun
->eh
->region_tree
== NULL
)
3410 VARRAY_UCHAR_INIT (cfun
->eh
->action_record_data
, 64, "action_record_data");
3412 ar_hash
= htab_create (31, action_record_hash
, action_record_eq
, free
);
3414 for (iter
= get_insns (); iter
; iter
= NEXT_INSN (iter
))
3417 struct eh_region
*region
;
3419 rtx this_landing_pad
;
3422 if (GET_CODE (insn
) == INSN
3423 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
3424 insn
= XVECEXP (PATTERN (insn
), 0, 0);
3426 note
= find_reg_note (insn
, REG_EH_REGION
, NULL_RTX
);
3429 if (! (GET_CODE (insn
) == CALL_INSN
3430 || (flag_non_call_exceptions
3431 && may_trap_p (PATTERN (insn
)))))
3438 if (INTVAL (XEXP (note
, 0)) <= 0)
3440 region
= cfun
->eh
->region_array
[INTVAL (XEXP (note
, 0))];
3441 this_action
= collect_one_action_chain (ar_hash
, region
);
3444 /* Existence of catch handlers, or must-not-throw regions
3445 implies that an lsda is needed (even if empty). */
3446 if (this_action
!= -1)
3447 cfun
->uses_eh_lsda
= 1;
3449 /* Delay creation of region notes for no-action regions
3450 until we're sure that an lsda will be required. */
3451 else if (last_action
== -3)
3453 first_no_action_insn
= iter
;
3457 /* Cleanups and handlers may share action chains but not
3458 landing pads. Collect the landing pad for this region. */
3459 if (this_action
>= 0)
3461 struct eh_region
*o
;
3462 for (o
= region
; ! o
->landing_pad
; o
= o
->outer
)
3464 this_landing_pad
= o
->landing_pad
;
3467 this_landing_pad
= NULL_RTX
;
3469 /* Differing actions or landing pads implies a change in call-site
3470 info, which implies some EH_REGION note should be emitted. */
3471 if (last_action
!= this_action
3472 || last_landing_pad
!= this_landing_pad
)
3474 /* If we'd not seen a previous action (-3) or the previous
3475 action was must-not-throw (-2), then we do not need an
3477 if (last_action
>= -1)
3479 /* If we delayed the creation of the begin, do it now. */
3480 if (first_no_action_insn
)
3482 call_site
= add_call_site (NULL_RTX
, 0);
3483 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
,
3484 first_no_action_insn
);
3485 NOTE_EH_HANDLER (note
) = call_site
;
3486 first_no_action_insn
= NULL_RTX
;
3489 note
= emit_note_after (NOTE_INSN_EH_REGION_END
,
3491 NOTE_EH_HANDLER (note
) = call_site
;
3494 /* If the new action is must-not-throw, then no region notes
3496 if (this_action
>= -1)
3498 call_site
= add_call_site (this_landing_pad
,
3499 this_action
< 0 ? 0 : this_action
);
3500 note
= emit_note_before (NOTE_INSN_EH_REGION_BEG
, iter
);
3501 NOTE_EH_HANDLER (note
) = call_site
;
3504 last_action
= this_action
;
3505 last_landing_pad
= this_landing_pad
;
3507 last_action_insn
= iter
;
3510 if (last_action
>= -1 && ! first_no_action_insn
)
3512 note
= emit_note_after (NOTE_INSN_EH_REGION_END
, last_action_insn
);
3513 NOTE_EH_HANDLER (note
) = call_site
;
3516 htab_delete (ar_hash
);
3521 push_uleb128 (varray_type
*data_area
, unsigned int value
)
3525 unsigned char byte
= value
& 0x7f;
3529 VARRAY_PUSH_UCHAR (*data_area
, byte
);
3535 push_sleb128 (varray_type
*data_area
, int value
)
3542 byte
= value
& 0x7f;
3544 more
= ! ((value
== 0 && (byte
& 0x40) == 0)
3545 || (value
== -1 && (byte
& 0x40) != 0));
3548 VARRAY_PUSH_UCHAR (*data_area
, byte
);
3554 #ifndef HAVE_AS_LEB128
3556 dw2_size_of_call_site_table (void)
3558 int n
= cfun
->eh
->call_site_data_used
;
3559 int size
= n
* (4 + 4 + 4);
3562 for (i
= 0; i
< n
; ++i
)
3564 struct call_site_record
*cs
= &cfun
->eh
->call_site_data
[i
];
3565 size
+= size_of_uleb128 (cs
->action
);
3572 sjlj_size_of_call_site_table (void)
3574 int n
= cfun
->eh
->call_site_data_used
;
3578 for (i
= 0; i
< n
; ++i
)
3580 struct call_site_record
*cs
= &cfun
->eh
->call_site_data
[i
];
3581 size
+= size_of_uleb128 (INTVAL (cs
->landing_pad
));
3582 size
+= size_of_uleb128 (cs
->action
);
3590 dw2_output_call_site_table (void)
3592 const char *const function_start_lab
3593 = IDENTIFIER_POINTER (current_function_func_begin_label
);
3594 int n
= cfun
->eh
->call_site_data_used
;
3597 for (i
= 0; i
< n
; ++i
)
3599 struct call_site_record
*cs
= &cfun
->eh
->call_site_data
[i
];
3600 char reg_start_lab
[32];
3601 char reg_end_lab
[32];
3602 char landing_pad_lab
[32];
3604 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab
, "LEHB", call_site_base
+ i
);
3605 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab
, "LEHE", call_site_base
+ i
);
3607 if (cs
->landing_pad
)
3608 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab
, "L",
3609 CODE_LABEL_NUMBER (cs
->landing_pad
));
3611 /* ??? Perhaps use insn length scaling if the assembler supports
3612 generic arithmetic. */
3613 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
3614 data4 if the function is small enough. */
3615 #ifdef HAVE_AS_LEB128
3616 dw2_asm_output_delta_uleb128 (reg_start_lab
, function_start_lab
,
3617 "region %d start", i
);
3618 dw2_asm_output_delta_uleb128 (reg_end_lab
, reg_start_lab
,
3620 if (cs
->landing_pad
)
3621 dw2_asm_output_delta_uleb128 (landing_pad_lab
, function_start_lab
,
3624 dw2_asm_output_data_uleb128 (0, "landing pad");
3626 dw2_asm_output_delta (4, reg_start_lab
, function_start_lab
,
3627 "region %d start", i
);
3628 dw2_asm_output_delta (4, reg_end_lab
, reg_start_lab
, "length");
3629 if (cs
->landing_pad
)
3630 dw2_asm_output_delta (4, landing_pad_lab
, function_start_lab
,
3633 dw2_asm_output_data (4, 0, "landing pad");
3635 dw2_asm_output_data_uleb128 (cs
->action
, "action");
3638 call_site_base
+= n
;
3642 sjlj_output_call_site_table (void)
3644 int n
= cfun
->eh
->call_site_data_used
;
3647 for (i
= 0; i
< n
; ++i
)
3649 struct call_site_record
*cs
= &cfun
->eh
->call_site_data
[i
];
3651 dw2_asm_output_data_uleb128 (INTVAL (cs
->landing_pad
),
3652 "region %d landing pad", i
);
3653 dw2_asm_output_data_uleb128 (cs
->action
, "action");
3656 call_site_base
+= n
;
3659 /* Tell assembler to switch to the section for the exception handling
3663 default_exception_section (void)
3665 if (targetm
.have_named_sections
)
3668 #ifdef HAVE_LD_RO_RW_SECTION_MIXING
3669 int tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
3672 || ((tt_format
& 0x70) != DW_EH_PE_absptr
3673 && (tt_format
& 0x70) != DW_EH_PE_aligned
))
3674 ? 0 : SECTION_WRITE
;
3676 flags
= SECTION_WRITE
;
3678 named_section_flags (".gcc_except_table", flags
);
3683 readonly_data_section ();
3687 output_function_exception_table (void)
3689 int tt_format
, cs_format
, lp_format
, i
, n
;
3690 #ifdef HAVE_AS_LEB128
3691 char ttype_label
[32];
3692 char cs_after_size_label
[32];
3693 char cs_end_label
[32];
3698 int tt_format_size
= 0;
3700 /* Not all functions need anything. */
3701 if (! cfun
->uses_eh_lsda
)
3704 #ifdef IA64_UNWIND_INFO
3705 fputs ("\t.personality\t", asm_out_file
);
3706 output_addr_const (asm_out_file
, eh_personality_libfunc
);
3707 fputs ("\n\t.handlerdata\n", asm_out_file
);
3708 /* Note that varasm still thinks we're in the function's code section.
3709 The ".endp" directive that will immediately follow will take us back. */
3711 (*targetm
.asm_out
.exception_section
) ();
3714 have_tt_data
= (VARRAY_ACTIVE_SIZE (cfun
->eh
->ttype_data
) > 0
3715 || VARRAY_ACTIVE_SIZE (cfun
->eh
->ehspec_data
) > 0);
3717 /* Indicate the format of the @TType entries. */
3719 tt_format
= DW_EH_PE_omit
;
3722 tt_format
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
3723 #ifdef HAVE_AS_LEB128
3724 ASM_GENERATE_INTERNAL_LABEL (ttype_label
, "LLSDATT",
3725 current_function_funcdef_no
);
3727 tt_format_size
= size_of_encoded_value (tt_format
);
3729 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3732 (*targetm
.asm_out
.internal_label
) (asm_out_file
, "LLSDA",
3733 current_function_funcdef_no
);
3735 /* The LSDA header. */
3737 /* Indicate the format of the landing pad start pointer. An omitted
3738 field implies @LPStart == @Start. */
3739 /* Currently we always put @LPStart == @Start. This field would
3740 be most useful in moving the landing pads completely out of
3741 line to another section, but it could also be used to minimize
3742 the size of uleb128 landing pad offsets. */
3743 lp_format
= DW_EH_PE_omit
;
3744 dw2_asm_output_data (1, lp_format
, "@LPStart format (%s)",
3745 eh_data_format_name (lp_format
));
3747 /* @LPStart pointer would go here. */
3749 dw2_asm_output_data (1, tt_format
, "@TType format (%s)",
3750 eh_data_format_name (tt_format
));
3752 #ifndef HAVE_AS_LEB128
3753 if (USING_SJLJ_EXCEPTIONS
)
3754 call_site_len
= sjlj_size_of_call_site_table ();
3756 call_site_len
= dw2_size_of_call_site_table ();
3759 /* A pc-relative 4-byte displacement to the @TType data. */
3762 #ifdef HAVE_AS_LEB128
3763 char ttype_after_disp_label
[32];
3764 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label
, "LLSDATTD",
3765 current_function_funcdef_no
);
3766 dw2_asm_output_delta_uleb128 (ttype_label
, ttype_after_disp_label
,
3767 "@TType base offset");
3768 ASM_OUTPUT_LABEL (asm_out_file
, ttype_after_disp_label
);
3770 /* Ug. Alignment queers things. */
3771 unsigned int before_disp
, after_disp
, last_disp
, disp
;
3773 before_disp
= 1 + 1;
3774 after_disp
= (1 + size_of_uleb128 (call_site_len
)
3776 + VARRAY_ACTIVE_SIZE (cfun
->eh
->action_record_data
)
3777 + (VARRAY_ACTIVE_SIZE (cfun
->eh
->ttype_data
)
3783 unsigned int disp_size
, pad
;
3786 disp_size
= size_of_uleb128 (disp
);
3787 pad
= before_disp
+ disp_size
+ after_disp
;
3788 if (pad
% tt_format_size
)
3789 pad
= tt_format_size
- (pad
% tt_format_size
);
3792 disp
= after_disp
+ pad
;
3794 while (disp
!= last_disp
);
3796 dw2_asm_output_data_uleb128 (disp
, "@TType base offset");
3800 /* Indicate the format of the call-site offsets. */
3801 #ifdef HAVE_AS_LEB128
3802 cs_format
= DW_EH_PE_uleb128
;
3804 cs_format
= DW_EH_PE_udata4
;
3806 dw2_asm_output_data (1, cs_format
, "call-site format (%s)",
3807 eh_data_format_name (cs_format
));
3809 #ifdef HAVE_AS_LEB128
3810 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label
, "LLSDACSB",
3811 current_function_funcdef_no
);
3812 ASM_GENERATE_INTERNAL_LABEL (cs_end_label
, "LLSDACSE",
3813 current_function_funcdef_no
);
3814 dw2_asm_output_delta_uleb128 (cs_end_label
, cs_after_size_label
,
3815 "Call-site table length");
3816 ASM_OUTPUT_LABEL (asm_out_file
, cs_after_size_label
);
3817 if (USING_SJLJ_EXCEPTIONS
)
3818 sjlj_output_call_site_table ();
3820 dw2_output_call_site_table ();
3821 ASM_OUTPUT_LABEL (asm_out_file
, cs_end_label
);
3823 dw2_asm_output_data_uleb128 (call_site_len
,"Call-site table length");
3824 if (USING_SJLJ_EXCEPTIONS
)
3825 sjlj_output_call_site_table ();
3827 dw2_output_call_site_table ();
3830 /* ??? Decode and interpret the data for flag_debug_asm. */
3831 n
= VARRAY_ACTIVE_SIZE (cfun
->eh
->action_record_data
);
3832 for (i
= 0; i
< n
; ++i
)
3833 dw2_asm_output_data (1, VARRAY_UCHAR (cfun
->eh
->action_record_data
, i
),
3834 (i
? NULL
: "Action record table"));
3837 assemble_align (tt_format_size
* BITS_PER_UNIT
);
3839 i
= VARRAY_ACTIVE_SIZE (cfun
->eh
->ttype_data
);
3842 tree type
= VARRAY_TREE (cfun
->eh
->ttype_data
, i
);
3845 if (type
== NULL_TREE
)
3849 struct cgraph_varpool_node
*node
;
3851 type
= lookup_type_for_runtime (type
);
3852 value
= expand_expr (type
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
3854 /* Let cgraph know that the rtti decl is used. Not all of the
3855 paths below go through assemble_integer, which would take
3856 care of this for us. */
3857 if (TREE_CODE (type
) == ADDR_EXPR
)
3859 type
= TREE_OPERAND (type
, 0);
3860 node
= cgraph_varpool_node (type
);
3862 cgraph_varpool_mark_needed_node (node
);
3864 else if (TREE_CODE (type
) != INTEGER_CST
)
3868 if (tt_format
== DW_EH_PE_absptr
|| tt_format
== DW_EH_PE_aligned
)
3869 assemble_integer (value
, tt_format_size
,
3870 tt_format_size
* BITS_PER_UNIT
, 1);
3872 dw2_asm_output_encoded_addr_rtx (tt_format
, value
, NULL
);
3875 #ifdef HAVE_AS_LEB128
3877 ASM_OUTPUT_LABEL (asm_out_file
, ttype_label
);
3880 /* ??? Decode and interpret the data for flag_debug_asm. */
3881 n
= VARRAY_ACTIVE_SIZE (cfun
->eh
->ehspec_data
);
3882 for (i
= 0; i
< n
; ++i
)
3883 dw2_asm_output_data (1, VARRAY_UCHAR (cfun
->eh
->ehspec_data
, i
),
3884 (i
? NULL
: "Exception specification table"));
3886 function_section (current_function_decl
);
3889 #include "gt-except.h"