Daily bump.
[official-gcc.git] / gcc / except.c
blob915059c39717524fb7c455907d36811103988400
1 /* Implements exception handling.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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
11 version.
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
16 for more details.
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, 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA. */
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. ] */
50 #include "config.h"
51 #include "system.h"
52 #include "coretypes.h"
53 #include "tm.h"
54 #include "rtl.h"
55 #include "tree.h"
56 #include "flags.h"
57 #include "function.h"
58 #include "expr.h"
59 #include "libfuncs.h"
60 #include "insn-config.h"
61 #include "except.h"
62 #include "integrate.h"
63 #include "hard-reg-set.h"
64 #include "basic-block.h"
65 #include "output.h"
66 #include "dwarf2asm.h"
67 #include "dwarf2out.h"
68 #include "dwarf2.h"
69 #include "toplev.h"
70 #include "hashtab.h"
71 #include "intl.h"
72 #include "ggc.h"
73 #include "tm_p.h"
74 #include "target.h"
75 #include "langhooks.h"
76 #include "cgraph.h"
77 #include "diagnostic.h"
78 #include "tree-pass.h"
79 #include "timevar.h"
81 /* Provide defaults for stuff that may not be defined when using
82 sjlj exceptions. */
83 #ifndef EH_RETURN_DATA_REGNO
84 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
85 #endif
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(())
102 rtx label;
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. */
129 int region_number;
131 /* When a region is deleted, its parents inherit the REG_EH_REGION
132 numbers already assigned. */
133 bitmap aka;
135 /* Each region does exactly one thing. */
136 enum eh_region_type
138 ERT_UNKNOWN = 0,
139 ERT_CLEANUP,
140 ERT_TRY,
141 ERT_CATCH,
142 ERT_ALLOWED_EXCEPTIONS,
143 ERT_MUST_NOT_THROW,
144 ERT_THROW
145 } type;
147 /* Holds the action to perform based on the preceding type. */
148 union eh_region_u {
149 /* A list of catch blocks, a surrounding try block,
150 and the label for continuing after a catch. */
151 struct eh_region_u_try {
152 struct eh_region *catch;
153 struct eh_region *last_catch;
154 } GTY ((tag ("ERT_TRY"))) try;
156 /* The list through the catch handlers, the list of type objects
157 matched, and the list of associated filters. */
158 struct eh_region_u_catch {
159 struct eh_region *next_catch;
160 struct eh_region *prev_catch;
161 tree type_list;
162 tree filter_list;
163 } GTY ((tag ("ERT_CATCH"))) catch;
165 /* A tree_list of allowed types. */
166 struct eh_region_u_allowed {
167 tree type_list;
168 int filter;
169 } GTY ((tag ("ERT_ALLOWED_EXCEPTIONS"))) allowed;
171 /* The type given by a call to "throw foo();", or discovered
172 for a throw. */
173 struct eh_region_u_throw {
174 tree type;
175 } GTY ((tag ("ERT_THROW"))) throw;
177 /* Retain the cleanup expression even after expansion so that
178 we can match up fixup regions. */
179 struct eh_region_u_cleanup {
180 struct eh_region *prev_try;
181 } GTY ((tag ("ERT_CLEANUP"))) cleanup;
182 } GTY ((desc ("%0.type"))) u;
184 /* Entry point for this region's handler before landing pads are built. */
185 rtx label;
186 tree tree_label;
188 /* Entry point for this region's handler from the runtime eh library. */
189 rtx landing_pad;
191 /* Entry point for this region's handler from an inner region. */
192 rtx post_landing_pad;
194 /* The RESX insn for handing off control to the next outermost handler,
195 if appropriate. */
196 rtx resume;
198 /* True if something in this region may throw. */
199 unsigned may_contain_throw : 1;
202 typedef struct eh_region *eh_region;
204 struct call_site_record GTY(())
206 rtx landing_pad;
207 int action;
210 DEF_VEC_P(eh_region);
211 DEF_VEC_ALLOC_P(eh_region, gc);
213 /* Used to save exception status for each function. */
214 struct eh_status GTY(())
216 /* The tree of all regions for this function. */
217 struct eh_region *region_tree;
219 /* The same information as an indexable array. */
220 VEC(eh_region,gc) *region_array;
222 /* The most recently open region. */
223 struct eh_region *cur_region;
225 /* This is the region for which we are processing catch blocks. */
226 struct eh_region *try_region;
228 rtx filter;
229 rtx exc_ptr;
231 int built_landing_pads;
232 int last_region_number;
234 VEC(tree,gc) *ttype_data;
235 varray_type ehspec_data;
236 varray_type action_record_data;
238 htab_t GTY ((param_is (struct ehl_map_entry))) exception_handler_label_map;
240 struct call_site_record * GTY ((length ("%h.call_site_data_used")))
241 call_site_data;
242 int call_site_data_used;
243 int call_site_data_size;
245 rtx ehr_stackadj;
246 rtx ehr_handler;
247 rtx ehr_label;
249 rtx sjlj_fc;
250 rtx sjlj_exit_after;
252 htab_t GTY((param_is (struct throw_stmt_node))) throw_stmt_table;
255 static int t2r_eq (const void *, const void *);
256 static hashval_t t2r_hash (const void *);
257 static void add_type_for_runtime (tree);
258 static tree lookup_type_for_runtime (tree);
260 static void remove_unreachable_regions (rtx);
262 static int ttypes_filter_eq (const void *, const void *);
263 static hashval_t ttypes_filter_hash (const void *);
264 static int ehspec_filter_eq (const void *, const void *);
265 static hashval_t ehspec_filter_hash (const void *);
266 static int add_ttypes_entry (htab_t, tree);
267 static int add_ehspec_entry (htab_t, htab_t, tree);
268 static void assign_filter_values (void);
269 static void build_post_landing_pads (void);
270 static void connect_post_landing_pads (void);
271 static void dw2_build_landing_pads (void);
273 struct sjlj_lp_info;
274 static bool sjlj_find_directly_reachable_regions (struct sjlj_lp_info *);
275 static void sjlj_assign_call_site_values (rtx, struct sjlj_lp_info *);
276 static void sjlj_mark_call_sites (struct sjlj_lp_info *);
277 static void sjlj_emit_function_enter (rtx);
278 static void sjlj_emit_function_exit (void);
279 static void sjlj_emit_dispatch_table (rtx, struct sjlj_lp_info *);
280 static void sjlj_build_landing_pads (void);
282 static hashval_t ehl_hash (const void *);
283 static int ehl_eq (const void *, const void *);
284 static void add_ehl_entry (rtx, struct eh_region *);
285 static void remove_exception_handler_label (rtx);
286 static void remove_eh_handler (struct eh_region *);
287 static int for_each_eh_label_1 (void **, void *);
289 /* The return value of reachable_next_level. */
290 enum reachable_code
292 /* The given exception is not processed by the given region. */
293 RNL_NOT_CAUGHT,
294 /* The given exception may need processing by the given region. */
295 RNL_MAYBE_CAUGHT,
296 /* The given exception is completely processed by the given region. */
297 RNL_CAUGHT,
298 /* The given exception is completely processed by the runtime. */
299 RNL_BLOCKED
302 struct reachable_info;
303 static enum reachable_code reachable_next_level (struct eh_region *, tree,
304 struct reachable_info *);
306 static int action_record_eq (const void *, const void *);
307 static hashval_t action_record_hash (const void *);
308 static int add_action_record (htab_t, int, int);
309 static int collect_one_action_chain (htab_t, struct eh_region *);
310 static int add_call_site (rtx, int);
312 static void push_uleb128 (varray_type *, unsigned int);
313 static void push_sleb128 (varray_type *, int);
314 #ifndef HAVE_AS_LEB128
315 static int dw2_size_of_call_site_table (void);
316 static int sjlj_size_of_call_site_table (void);
317 #endif
318 static void dw2_output_call_site_table (void);
319 static void sjlj_output_call_site_table (void);
322 /* Routine to see if exception handling is turned on.
323 DO_WARN is nonzero if we want to inform the user that exception
324 handling is turned off.
326 This is used to ensure that -fexceptions has been specified if the
327 compiler tries to use any exception-specific functions. */
330 doing_eh (int do_warn)
332 if (! flag_exceptions)
334 static int warned = 0;
335 if (! warned && do_warn)
337 error ("exception handling disabled, use -fexceptions to enable");
338 warned = 1;
340 return 0;
342 return 1;
346 void
347 init_eh (void)
349 if (! flag_exceptions)
350 return;
352 type_to_runtime_map = htab_create_ggc (31, t2r_hash, t2r_eq, NULL);
354 /* Create the SjLj_Function_Context structure. This should match
355 the definition in unwind-sjlj.c. */
356 if (USING_SJLJ_EXCEPTIONS)
358 tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp;
360 sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE);
362 f_prev = build_decl (FIELD_DECL, get_identifier ("__prev"),
363 build_pointer_type (sjlj_fc_type_node));
364 DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node;
366 f_cs = build_decl (FIELD_DECL, get_identifier ("__call_site"),
367 integer_type_node);
368 DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;
370 tmp = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
371 tmp = build_array_type (lang_hooks.types.type_for_mode (word_mode, 1),
372 tmp);
373 f_data = build_decl (FIELD_DECL, get_identifier ("__data"), tmp);
374 DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node;
376 f_per = build_decl (FIELD_DECL, get_identifier ("__personality"),
377 ptr_type_node);
378 DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node;
380 f_lsda = build_decl (FIELD_DECL, get_identifier ("__lsda"),
381 ptr_type_node);
382 DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node;
384 #ifdef DONT_USE_BUILTIN_SETJMP
385 #ifdef JMP_BUF_SIZE
386 tmp = build_int_cst (NULL_TREE, JMP_BUF_SIZE - 1);
387 #else
388 /* Should be large enough for most systems, if it is not,
389 JMP_BUF_SIZE should be defined with the proper value. It will
390 also tend to be larger than necessary for most systems, a more
391 optimal port will define JMP_BUF_SIZE. */
392 tmp = build_int_cst (NULL_TREE, FIRST_PSEUDO_REGISTER + 2 - 1);
393 #endif
394 #else
395 /* builtin_setjmp takes a pointer to 5 words. */
396 tmp = build_int_cst (NULL_TREE, 5 * BITS_PER_WORD / POINTER_SIZE - 1);
397 #endif
398 tmp = build_index_type (tmp);
399 tmp = build_array_type (ptr_type_node, tmp);
400 f_jbuf = build_decl (FIELD_DECL, get_identifier ("__jbuf"), tmp);
401 #ifdef DONT_USE_BUILTIN_SETJMP
402 /* We don't know what the alignment requirements of the
403 runtime's jmp_buf has. Overestimate. */
404 DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT;
405 DECL_USER_ALIGN (f_jbuf) = 1;
406 #endif
407 DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node;
409 TYPE_FIELDS (sjlj_fc_type_node) = f_prev;
410 TREE_CHAIN (f_prev) = f_cs;
411 TREE_CHAIN (f_cs) = f_data;
412 TREE_CHAIN (f_data) = f_per;
413 TREE_CHAIN (f_per) = f_lsda;
414 TREE_CHAIN (f_lsda) = f_jbuf;
416 layout_type (sjlj_fc_type_node);
418 /* Cache the interesting field offsets so that we have
419 easy access from rtl. */
420 sjlj_fc_call_site_ofs
421 = (tree_low_cst (DECL_FIELD_OFFSET (f_cs), 1)
422 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_cs), 1) / BITS_PER_UNIT);
423 sjlj_fc_data_ofs
424 = (tree_low_cst (DECL_FIELD_OFFSET (f_data), 1)
425 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_data), 1) / BITS_PER_UNIT);
426 sjlj_fc_personality_ofs
427 = (tree_low_cst (DECL_FIELD_OFFSET (f_per), 1)
428 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_per), 1) / BITS_PER_UNIT);
429 sjlj_fc_lsda_ofs
430 = (tree_low_cst (DECL_FIELD_OFFSET (f_lsda), 1)
431 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_lsda), 1) / BITS_PER_UNIT);
432 sjlj_fc_jbuf_ofs
433 = (tree_low_cst (DECL_FIELD_OFFSET (f_jbuf), 1)
434 + tree_low_cst (DECL_FIELD_BIT_OFFSET (f_jbuf), 1) / BITS_PER_UNIT);
438 void
439 init_eh_for_function (void)
441 cfun->eh = ggc_alloc_cleared (sizeof (struct eh_status));
444 /* Routines to generate the exception tree somewhat directly.
445 These are used from tree-eh.c when processing exception related
446 nodes during tree optimization. */
448 static struct eh_region *
449 gen_eh_region (enum eh_region_type type, struct eh_region *outer)
451 struct eh_region *new;
453 #ifdef ENABLE_CHECKING
454 gcc_assert (doing_eh (0));
455 #endif
457 /* Insert a new blank region as a leaf in the tree. */
458 new = ggc_alloc_cleared (sizeof (*new));
459 new->type = type;
460 new->outer = outer;
461 if (outer)
463 new->next_peer = outer->inner;
464 outer->inner = new;
466 else
468 new->next_peer = cfun->eh->region_tree;
469 cfun->eh->region_tree = new;
472 new->region_number = ++cfun->eh->last_region_number;
474 return new;
477 struct eh_region *
478 gen_eh_region_cleanup (struct eh_region *outer, struct eh_region *prev_try)
480 struct eh_region *cleanup = gen_eh_region (ERT_CLEANUP, outer);
481 cleanup->u.cleanup.prev_try = prev_try;
482 return cleanup;
485 struct eh_region *
486 gen_eh_region_try (struct eh_region *outer)
488 return gen_eh_region (ERT_TRY, outer);
491 struct eh_region *
492 gen_eh_region_catch (struct eh_region *t, tree type_or_list)
494 struct eh_region *c, *l;
495 tree type_list, type_node;
497 /* Ensure to always end up with a type list to normalize further
498 processing, then register each type against the runtime types map. */
499 type_list = type_or_list;
500 if (type_or_list)
502 if (TREE_CODE (type_or_list) != TREE_LIST)
503 type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);
505 type_node = type_list;
506 for (; type_node; type_node = TREE_CHAIN (type_node))
507 add_type_for_runtime (TREE_VALUE (type_node));
510 c = gen_eh_region (ERT_CATCH, t->outer);
511 c->u.catch.type_list = type_list;
512 l = t->u.try.last_catch;
513 c->u.catch.prev_catch = l;
514 if (l)
515 l->u.catch.next_catch = c;
516 else
517 t->u.try.catch = c;
518 t->u.try.last_catch = c;
520 return c;
523 struct eh_region *
524 gen_eh_region_allowed (struct eh_region *outer, tree allowed)
526 struct eh_region *region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
527 region->u.allowed.type_list = allowed;
529 for (; allowed ; allowed = TREE_CHAIN (allowed))
530 add_type_for_runtime (TREE_VALUE (allowed));
532 return region;
535 struct eh_region *
536 gen_eh_region_must_not_throw (struct eh_region *outer)
538 return gen_eh_region (ERT_MUST_NOT_THROW, outer);
542 get_eh_region_number (struct eh_region *region)
544 return region->region_number;
547 bool
548 get_eh_region_may_contain_throw (struct eh_region *region)
550 return region->may_contain_throw;
553 tree
554 get_eh_region_tree_label (struct eh_region *region)
556 return region->tree_label;
559 void
560 set_eh_region_tree_label (struct eh_region *region, tree lab)
562 region->tree_label = lab;
565 void
566 expand_resx_expr (tree exp)
568 int region_nr = TREE_INT_CST_LOW (TREE_OPERAND (exp, 0));
569 struct eh_region *reg = VEC_index (eh_region,
570 cfun->eh->region_array, region_nr);
572 gcc_assert (!reg->resume);
573 reg->resume = emit_jump_insn (gen_rtx_RESX (VOIDmode, region_nr));
574 emit_barrier ();
577 /* Note that the current EH region (if any) may contain a throw, or a
578 call to a function which itself may contain a throw. */
580 void
581 note_eh_region_may_contain_throw (struct eh_region *region)
583 while (region && !region->may_contain_throw)
585 region->may_contain_throw = 1;
586 region = region->outer;
590 void
591 note_current_region_may_contain_throw (void)
593 note_eh_region_may_contain_throw (cfun->eh->cur_region);
597 /* Return an rtl expression for a pointer to the exception object
598 within a handler. */
601 get_exception_pointer (struct function *fun)
603 rtx exc_ptr = fun->eh->exc_ptr;
604 if (fun == cfun && ! exc_ptr)
606 exc_ptr = gen_reg_rtx (ptr_mode);
607 fun->eh->exc_ptr = exc_ptr;
609 return exc_ptr;
612 /* Return an rtl expression for the exception dispatch filter
613 within a handler. */
616 get_exception_filter (struct function *fun)
618 rtx filter = fun->eh->filter;
619 if (fun == cfun && ! filter)
621 filter = gen_reg_rtx (targetm.eh_return_filter_mode ());
622 fun->eh->filter = filter;
624 return filter;
627 /* This section is for the exception handling specific optimization pass. */
629 /* Random access the exception region tree. */
631 void
632 collect_eh_region_array (void)
634 struct eh_region *i;
636 i = cfun->eh->region_tree;
637 if (! i)
638 return;
640 VEC_safe_grow (eh_region, gc, cfun->eh->region_array,
641 cfun->eh->last_region_number + 1);
642 VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
644 while (1)
646 VEC_replace (eh_region, cfun->eh->region_array, i->region_number, i);
648 /* If there are sub-regions, process them. */
649 if (i->inner)
650 i = i->inner;
651 /* If there are peers, process them. */
652 else if (i->next_peer)
653 i = i->next_peer;
654 /* Otherwise, step back up the tree to the next peer. */
655 else
657 do {
658 i = i->outer;
659 if (i == NULL)
660 return;
661 } while (i->next_peer == NULL);
662 i = i->next_peer;
667 /* Remove all regions whose labels are not reachable from insns. */
669 static void
670 remove_unreachable_regions (rtx insns)
672 int i, *uid_region_num;
673 bool *reachable;
674 struct eh_region *r;
675 rtx insn;
677 uid_region_num = xcalloc (get_max_uid (), sizeof(int));
678 reachable = xcalloc (cfun->eh->last_region_number + 1, sizeof(bool));
680 for (i = cfun->eh->last_region_number; i > 0; --i)
682 r = VEC_index (eh_region, cfun->eh->region_array, i);
683 if (!r || r->region_number != i)
684 continue;
686 if (r->resume)
688 gcc_assert (!uid_region_num[INSN_UID (r->resume)]);
689 uid_region_num[INSN_UID (r->resume)] = i;
691 if (r->label)
693 gcc_assert (!uid_region_num[INSN_UID (r->label)]);
694 uid_region_num[INSN_UID (r->label)] = i;
698 for (insn = insns; insn; insn = NEXT_INSN (insn))
699 reachable[uid_region_num[INSN_UID (insn)]] = true;
701 for (i = cfun->eh->last_region_number; i > 0; --i)
703 r = VEC_index (eh_region, cfun->eh->region_array, i);
704 if (r && r->region_number == i && !reachable[i])
706 bool kill_it = true;
707 switch (r->type)
709 case ERT_THROW:
710 /* Don't remove ERT_THROW regions if their outer region
711 is reachable. */
712 if (r->outer && reachable[r->outer->region_number])
713 kill_it = false;
714 break;
716 case ERT_MUST_NOT_THROW:
717 /* MUST_NOT_THROW regions are implementable solely in the
718 runtime, but their existence continues to affect calls
719 within that region. Never delete them here. */
720 kill_it = false;
721 break;
723 case ERT_TRY:
725 /* TRY regions are reachable if any of its CATCH regions
726 are reachable. */
727 struct eh_region *c;
728 for (c = r->u.try.catch; c ; c = c->u.catch.next_catch)
729 if (reachable[c->region_number])
731 kill_it = false;
732 break;
734 break;
737 default:
738 break;
741 if (kill_it)
742 remove_eh_handler (r);
746 free (reachable);
747 free (uid_region_num);
750 /* Set up EH labels for RTL. */
752 void
753 convert_from_eh_region_ranges (void)
755 rtx insns = get_insns ();
756 int i, n = cfun->eh->last_region_number;
758 /* Most of the work is already done at the tree level. All we need to
759 do is collect the rtl labels that correspond to the tree labels that
760 collect the rtl labels that correspond to the tree labels
761 we allocated earlier. */
762 for (i = 1; i <= n; ++i)
764 struct eh_region *region;
766 region = VEC_index (eh_region, cfun->eh->region_array, i);
767 if (region && region->tree_label)
768 region->label = DECL_RTL_IF_SET (region->tree_label);
771 remove_unreachable_regions (insns);
774 static void
775 add_ehl_entry (rtx label, struct eh_region *region)
777 struct ehl_map_entry **slot, *entry;
779 LABEL_PRESERVE_P (label) = 1;
781 entry = ggc_alloc (sizeof (*entry));
782 entry->label = label;
783 entry->region = region;
785 slot = (struct ehl_map_entry **)
786 htab_find_slot (cfun->eh->exception_handler_label_map, entry, INSERT);
788 /* Before landing pad creation, each exception handler has its own
789 label. After landing pad creation, the exception handlers may
790 share landing pads. This is ok, since maybe_remove_eh_handler
791 only requires the 1-1 mapping before landing pad creation. */
792 gcc_assert (!*slot || cfun->eh->built_landing_pads);
794 *slot = entry;
797 void
798 find_exception_handler_labels (void)
800 int i;
802 if (cfun->eh->exception_handler_label_map)
803 htab_empty (cfun->eh->exception_handler_label_map);
804 else
806 /* ??? The expansion factor here (3/2) must be greater than the htab
807 occupancy factor (4/3) to avoid unnecessary resizing. */
808 cfun->eh->exception_handler_label_map
809 = htab_create_ggc (cfun->eh->last_region_number * 3 / 2,
810 ehl_hash, ehl_eq, NULL);
813 if (cfun->eh->region_tree == NULL)
814 return;
816 for (i = cfun->eh->last_region_number; i > 0; --i)
818 struct eh_region *region;
819 rtx lab;
821 region = VEC_index (eh_region, cfun->eh->region_array, i);
822 if (! region || region->region_number != i)
823 continue;
824 if (cfun->eh->built_landing_pads)
825 lab = region->landing_pad;
826 else
827 lab = region->label;
829 if (lab)
830 add_ehl_entry (lab, region);
833 /* For sjlj exceptions, need the return label to remain live until
834 after landing pad generation. */
835 if (USING_SJLJ_EXCEPTIONS && ! cfun->eh->built_landing_pads)
836 add_ehl_entry (return_label, NULL);
839 /* Returns true if the current function has exception handling regions. */
841 bool
842 current_function_has_exception_handlers (void)
844 int i;
846 for (i = cfun->eh->last_region_number; i > 0; --i)
848 struct eh_region *region;
850 region = VEC_index (eh_region, cfun->eh->region_array, i);
851 if (region
852 && region->region_number == i
853 && region->type != ERT_THROW)
854 return true;
857 return false;
860 /* A subroutine of duplicate_eh_regions. Search the region tree under O
861 for the minimum and maximum region numbers. Update *MIN and *MAX. */
863 static void
864 duplicate_eh_regions_0 (eh_region o, int *min, int *max)
866 if (o->region_number < *min)
867 *min = o->region_number;
868 if (o->region_number > *max)
869 *max = o->region_number;
871 if (o->inner)
873 o = o->inner;
874 duplicate_eh_regions_0 (o, min, max);
875 while (o->next_peer)
877 o = o->next_peer;
878 duplicate_eh_regions_0 (o, min, max);
883 /* A subroutine of duplicate_eh_regions. Copy the region tree under OLD.
884 Root it at OUTER, and apply EH_OFFSET to the region number. Don't worry
885 about the other internal pointers just yet, just the tree-like pointers. */
887 static eh_region
888 duplicate_eh_regions_1 (eh_region old, eh_region outer, int eh_offset)
890 eh_region ret, n;
892 ret = n = ggc_alloc (sizeof (struct eh_region));
894 *n = *old;
895 n->outer = outer;
896 n->next_peer = NULL;
897 gcc_assert (!old->aka);
899 n->region_number += eh_offset;
900 VEC_replace (eh_region, cfun->eh->region_array, n->region_number, n);
902 if (old->inner)
904 old = old->inner;
905 n = n->inner = duplicate_eh_regions_1 (old, ret, eh_offset);
906 while (old->next_peer)
908 old = old->next_peer;
909 n = n->next_peer = duplicate_eh_regions_1 (old, ret, eh_offset);
913 return ret;
916 /* Duplicate the EH regions of IFUN, rooted at COPY_REGION, into current
917 function and root the tree below OUTER_REGION. Remap labels using MAP
918 callback. The special case of COPY_REGION of 0 means all regions. */
921 duplicate_eh_regions (struct function *ifun, duplicate_eh_regions_map map,
922 void *data, int copy_region, int outer_region)
924 eh_region cur, prev_try, outer, *splice;
925 int i, min_region, max_region, eh_offset, cfun_last_region_number;
926 int num_regions;
928 if (!ifun->eh->region_tree)
929 return 0;
931 /* Find the range of region numbers to be copied. The interface we
932 provide here mandates a single offset to find new number from old,
933 which means we must look at the numbers present, instead of the
934 count or something else. */
935 if (copy_region > 0)
937 min_region = INT_MAX;
938 max_region = 0;
940 cur = VEC_index (eh_region, ifun->eh->region_array, copy_region);
941 duplicate_eh_regions_0 (cur, &min_region, &max_region);
943 else
944 min_region = 1, max_region = ifun->eh->last_region_number;
945 num_regions = max_region - min_region + 1;
946 cfun_last_region_number = cfun->eh->last_region_number;
947 eh_offset = cfun_last_region_number + 1 - min_region;
949 /* If we've not yet created a region array, do so now. */
950 VEC_safe_grow (eh_region, gc, cfun->eh->region_array,
951 cfun_last_region_number + 1 + num_regions);
952 cfun->eh->last_region_number = max_region + eh_offset;
954 /* We may have just allocated the array for the first time.
955 Make sure that element zero is null. */
956 VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
958 /* Zero all entries in the range allocated. */
959 memset (VEC_address (eh_region, cfun->eh->region_array)
960 + cfun_last_region_number + 1, 0, num_regions * sizeof (eh_region));
962 /* Locate the spot at which to insert the new tree. */
963 if (outer_region > 0)
965 outer = VEC_index (eh_region, cfun->eh->region_array, outer_region);
966 splice = &outer->inner;
968 else
970 outer = NULL;
971 splice = &cfun->eh->region_tree;
973 while (*splice)
974 splice = &(*splice)->next_peer;
976 /* Copy all the regions in the subtree. */
977 if (copy_region > 0)
979 cur = VEC_index (eh_region, ifun->eh->region_array, copy_region);
980 *splice = duplicate_eh_regions_1 (cur, outer, eh_offset);
982 else
984 eh_region n;
986 cur = ifun->eh->region_tree;
987 *splice = n = duplicate_eh_regions_1 (cur, outer, eh_offset);
988 while (cur->next_peer)
990 cur = cur->next_peer;
991 n = n->next_peer = duplicate_eh_regions_1 (cur, outer, eh_offset);
995 /* Remap all the labels in the new regions. */
996 for (i = cfun_last_region_number + 1;
997 VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i)
998 if (cur && cur->tree_label)
999 cur->tree_label = map (cur->tree_label, data);
1001 /* Search for the containing ERT_TRY region to fix up
1002 the prev_try short-cuts for ERT_CLEANUP regions. */
1003 prev_try = NULL;
1004 if (outer_region > 0)
1005 for (prev_try = VEC_index (eh_region, cfun->eh->region_array, outer_region);
1006 prev_try && prev_try->type != ERT_TRY;
1007 prev_try = prev_try->outer)
1010 /* Remap all of the internal catch and cleanup linkages. Since we
1011 duplicate entire subtrees, all of the referenced regions will have
1012 been copied too. And since we renumbered them as a block, a simple
1013 bit of arithmetic finds us the index for the replacement region. */
1014 for (i = cfun_last_region_number + 1;
1015 VEC_iterate (eh_region, cfun->eh->region_array, i, cur); ++i)
1017 if (cur == NULL)
1018 continue;
1020 #define REMAP(REG) \
1021 (REG) = VEC_index (eh_region, cfun->eh->region_array, \
1022 (REG)->region_number + eh_offset)
1024 switch (cur->type)
1026 case ERT_TRY:
1027 if (cur->u.try.catch)
1028 REMAP (cur->u.try.catch);
1029 if (cur->u.try.last_catch)
1030 REMAP (cur->u.try.last_catch);
1031 break;
1033 case ERT_CATCH:
1034 if (cur->u.catch.next_catch)
1035 REMAP (cur->u.catch.next_catch);
1036 if (cur->u.catch.prev_catch)
1037 REMAP (cur->u.catch.prev_catch);
1038 break;
1040 case ERT_CLEANUP:
1041 if (cur->u.cleanup.prev_try)
1042 REMAP (cur->u.cleanup.prev_try);
1043 else
1044 cur->u.cleanup.prev_try = prev_try;
1045 break;
1047 default:
1048 break;
1051 #undef REMAP
1054 return eh_offset;
1057 /* Return true if REGION_A is outer to REGION_B in IFUN. */
1059 bool
1060 eh_region_outer_p (struct function *ifun, int region_a, int region_b)
1062 struct eh_region *rp_a, *rp_b;
1064 gcc_assert (ifun->eh->last_region_number > 0);
1065 gcc_assert (ifun->eh->region_tree);
1067 rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a);
1068 rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b);
1069 gcc_assert (rp_a != NULL);
1070 gcc_assert (rp_b != NULL);
1074 if (rp_a == rp_b)
1075 return true;
1076 rp_b = rp_b->outer;
1078 while (rp_b);
1080 return false;
1083 /* Return region number of region that is outer to both if REGION_A and
1084 REGION_B in IFUN. */
1087 eh_region_outermost (struct function *ifun, int region_a, int region_b)
1089 struct eh_region *rp_a, *rp_b;
1090 sbitmap b_outer;
1092 gcc_assert (ifun->eh->last_region_number > 0);
1093 gcc_assert (ifun->eh->region_tree);
1095 rp_a = VEC_index (eh_region, ifun->eh->region_array, region_a);
1096 rp_b = VEC_index (eh_region, ifun->eh->region_array, region_b);
1097 gcc_assert (rp_a != NULL);
1098 gcc_assert (rp_b != NULL);
1100 b_outer = sbitmap_alloc (ifun->eh->last_region_number + 1);
1101 sbitmap_zero (b_outer);
1105 SET_BIT (b_outer, rp_b->region_number);
1106 rp_b = rp_b->outer;
1108 while (rp_b);
1112 if (TEST_BIT (b_outer, rp_a->region_number))
1114 sbitmap_free (b_outer);
1115 return rp_a->region_number;
1117 rp_a = rp_a->outer;
1119 while (rp_a);
1121 sbitmap_free (b_outer);
1122 return -1;
1125 static int
1126 t2r_eq (const void *pentry, const void *pdata)
1128 tree entry = (tree) pentry;
1129 tree data = (tree) pdata;
1131 return TREE_PURPOSE (entry) == data;
1134 static hashval_t
1135 t2r_hash (const void *pentry)
1137 tree entry = (tree) pentry;
1138 return TREE_HASH (TREE_PURPOSE (entry));
1141 static void
1142 add_type_for_runtime (tree type)
1144 tree *slot;
1146 slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
1147 TREE_HASH (type), INSERT);
1148 if (*slot == NULL)
1150 tree runtime = (*lang_eh_runtime_type) (type);
1151 *slot = tree_cons (type, runtime, NULL_TREE);
1155 static tree
1156 lookup_type_for_runtime (tree type)
1158 tree *slot;
1160 slot = (tree *) htab_find_slot_with_hash (type_to_runtime_map, type,
1161 TREE_HASH (type), NO_INSERT);
1163 /* We should have always inserted the data earlier. */
1164 return TREE_VALUE (*slot);
1168 /* Represent an entry in @TTypes for either catch actions
1169 or exception filter actions. */
1170 struct ttypes_filter GTY(())
1172 tree t;
1173 int filter;
1176 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
1177 (a tree) for a @TTypes type node we are thinking about adding. */
1179 static int
1180 ttypes_filter_eq (const void *pentry, const void *pdata)
1182 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
1183 tree data = (tree) pdata;
1185 return entry->t == data;
1188 static hashval_t
1189 ttypes_filter_hash (const void *pentry)
1191 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
1192 return TREE_HASH (entry->t);
1195 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
1196 exception specification list we are thinking about adding. */
1197 /* ??? Currently we use the type lists in the order given. Someone
1198 should put these in some canonical order. */
1200 static int
1201 ehspec_filter_eq (const void *pentry, const void *pdata)
1203 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
1204 const struct ttypes_filter *data = (const struct ttypes_filter *) pdata;
1206 return type_list_equal (entry->t, data->t);
1209 /* Hash function for exception specification lists. */
1211 static hashval_t
1212 ehspec_filter_hash (const void *pentry)
1214 const struct ttypes_filter *entry = (const struct ttypes_filter *) pentry;
1215 hashval_t h = 0;
1216 tree list;
1218 for (list = entry->t; list ; list = TREE_CHAIN (list))
1219 h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list));
1220 return h;
1223 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
1224 to speed up the search. Return the filter value to be used. */
1226 static int
1227 add_ttypes_entry (htab_t ttypes_hash, tree type)
1229 struct ttypes_filter **slot, *n;
1231 slot = (struct ttypes_filter **)
1232 htab_find_slot_with_hash (ttypes_hash, type, TREE_HASH (type), INSERT);
1234 if ((n = *slot) == NULL)
1236 /* Filter value is a 1 based table index. */
1238 n = XNEW (struct ttypes_filter);
1239 n->t = type;
1240 n->filter = VEC_length (tree, cfun->eh->ttype_data) + 1;
1241 *slot = n;
1243 VEC_safe_push (tree, gc, cfun->eh->ttype_data, type);
1246 return n->filter;
1249 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
1250 to speed up the search. Return the filter value to be used. */
1252 static int
1253 add_ehspec_entry (htab_t ehspec_hash, htab_t ttypes_hash, tree list)
1255 struct ttypes_filter **slot, *n;
1256 struct ttypes_filter dummy;
1258 dummy.t = list;
1259 slot = (struct ttypes_filter **)
1260 htab_find_slot (ehspec_hash, &dummy, INSERT);
1262 if ((n = *slot) == NULL)
1264 /* Filter value is a -1 based byte index into a uleb128 buffer. */
1266 n = XNEW (struct ttypes_filter);
1267 n->t = list;
1268 n->filter = -(VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) + 1);
1269 *slot = n;
1271 /* Generate a 0 terminated list of filter values. */
1272 for (; list ; list = TREE_CHAIN (list))
1274 if (targetm.arm_eabi_unwinder)
1275 VARRAY_PUSH_TREE (cfun->eh->ehspec_data, TREE_VALUE (list));
1276 else
1278 /* Look up each type in the list and encode its filter
1279 value as a uleb128. */
1280 push_uleb128 (&cfun->eh->ehspec_data,
1281 add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
1284 if (targetm.arm_eabi_unwinder)
1285 VARRAY_PUSH_TREE (cfun->eh->ehspec_data, NULL_TREE);
1286 else
1287 VARRAY_PUSH_UCHAR (cfun->eh->ehspec_data, 0);
1290 return n->filter;
1293 /* Generate the action filter values to be used for CATCH and
1294 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
1295 we use lots of landing pads, and so every type or list can share
1296 the same filter value, which saves table space. */
1298 static void
1299 assign_filter_values (void)
1301 int i;
1302 htab_t ttypes, ehspec;
1304 cfun->eh->ttype_data = VEC_alloc (tree, gc, 16);
1305 if (targetm.arm_eabi_unwinder)
1306 VARRAY_TREE_INIT (cfun->eh->ehspec_data, 64, "ehspec_data");
1307 else
1308 VARRAY_UCHAR_INIT (cfun->eh->ehspec_data, 64, "ehspec_data");
1310 ttypes = htab_create (31, ttypes_filter_hash, ttypes_filter_eq, free);
1311 ehspec = htab_create (31, ehspec_filter_hash, ehspec_filter_eq, free);
1313 for (i = cfun->eh->last_region_number; i > 0; --i)
1315 struct eh_region *r;
1317 r = VEC_index (eh_region, cfun->eh->region_array, i);
1319 /* Mind we don't process a region more than once. */
1320 if (!r || r->region_number != i)
1321 continue;
1323 switch (r->type)
1325 case ERT_CATCH:
1326 /* Whatever type_list is (NULL or true list), we build a list
1327 of filters for the region. */
1328 r->u.catch.filter_list = NULL_TREE;
1330 if (r->u.catch.type_list != NULL)
1332 /* Get a filter value for each of the types caught and store
1333 them in the region's dedicated list. */
1334 tree tp_node = r->u.catch.type_list;
1336 for (;tp_node; tp_node = TREE_CHAIN (tp_node))
1338 int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
1339 tree flt_node = build_int_cst (NULL_TREE, flt);
1341 r->u.catch.filter_list
1342 = tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
1345 else
1347 /* Get a filter value for the NULL list also since it will need
1348 an action record anyway. */
1349 int flt = add_ttypes_entry (ttypes, NULL);
1350 tree flt_node = build_int_cst (NULL_TREE, flt);
1352 r->u.catch.filter_list
1353 = tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list);
1356 break;
1358 case ERT_ALLOWED_EXCEPTIONS:
1359 r->u.allowed.filter
1360 = add_ehspec_entry (ehspec, ttypes, r->u.allowed.type_list);
1361 break;
1363 default:
1364 break;
1368 htab_delete (ttypes);
1369 htab_delete (ehspec);
1372 /* Emit SEQ into basic block just before INSN (that is assumed to be
1373 first instruction of some existing BB and return the newly
1374 produced block. */
1375 static basic_block
1376 emit_to_new_bb_before (rtx seq, rtx insn)
1378 rtx last;
1379 basic_block bb;
1380 edge e;
1381 edge_iterator ei;
1383 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
1384 call), we don't want it to go into newly created landing pad or other EH
1385 construct. */
1386 for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); )
1387 if (e->flags & EDGE_FALLTHRU)
1388 force_nonfallthru (e);
1389 else
1390 ei_next (&ei);
1391 last = emit_insn_before (seq, insn);
1392 if (BARRIER_P (last))
1393 last = PREV_INSN (last);
1394 bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);
1395 update_bb_for_insn (bb);
1396 bb->flags |= BB_SUPERBLOCK;
1397 return bb;
1400 /* Generate the code to actually handle exceptions, which will follow the
1401 landing pads. */
1403 static void
1404 build_post_landing_pads (void)
1406 int i;
1408 for (i = cfun->eh->last_region_number; i > 0; --i)
1410 struct eh_region *region;
1411 rtx seq;
1413 region = VEC_index (eh_region, cfun->eh->region_array, i);
1414 /* Mind we don't process a region more than once. */
1415 if (!region || region->region_number != i)
1416 continue;
1418 switch (region->type)
1420 case ERT_TRY:
1421 /* ??? Collect the set of all non-overlapping catch handlers
1422 all the way up the chain until blocked by a cleanup. */
1423 /* ??? Outer try regions can share landing pads with inner
1424 try regions if the types are completely non-overlapping,
1425 and there are no intervening cleanups. */
1427 region->post_landing_pad = gen_label_rtx ();
1429 start_sequence ();
1431 emit_label (region->post_landing_pad);
1433 /* ??? It is mighty inconvenient to call back into the
1434 switch statement generation code in expand_end_case.
1435 Rapid prototyping sez a sequence of ifs. */
1437 struct eh_region *c;
1438 for (c = region->u.try.catch; c ; c = c->u.catch.next_catch)
1440 if (c->u.catch.type_list == NULL)
1441 emit_jump (c->label);
1442 else
1444 /* Need for one cmp/jump per type caught. Each type
1445 list entry has a matching entry in the filter list
1446 (see assign_filter_values). */
1447 tree tp_node = c->u.catch.type_list;
1448 tree flt_node = c->u.catch.filter_list;
1450 for (; tp_node; )
1452 emit_cmp_and_jump_insns
1453 (cfun->eh->filter,
1454 GEN_INT (tree_low_cst (TREE_VALUE (flt_node), 0)),
1455 EQ, NULL_RTX,
1456 targetm.eh_return_filter_mode (), 0, c->label);
1458 tp_node = TREE_CHAIN (tp_node);
1459 flt_node = TREE_CHAIN (flt_node);
1465 /* We delay the generation of the _Unwind_Resume until we generate
1466 landing pads. We emit a marker here so as to get good control
1467 flow data in the meantime. */
1468 region->resume
1469 = emit_jump_insn (gen_rtx_RESX (VOIDmode, region->region_number));
1470 emit_barrier ();
1472 seq = get_insns ();
1473 end_sequence ();
1475 emit_to_new_bb_before (seq, region->u.try.catch->label);
1477 break;
1479 case ERT_ALLOWED_EXCEPTIONS:
1480 region->post_landing_pad = gen_label_rtx ();
1482 start_sequence ();
1484 emit_label (region->post_landing_pad);
1486 emit_cmp_and_jump_insns (cfun->eh->filter,
1487 GEN_INT (region->u.allowed.filter),
1488 EQ, NULL_RTX,
1489 targetm.eh_return_filter_mode (), 0, region->label);
1491 /* We delay the generation of the _Unwind_Resume until we generate
1492 landing pads. We emit a marker here so as to get good control
1493 flow data in the meantime. */
1494 region->resume
1495 = emit_jump_insn (gen_rtx_RESX (VOIDmode, region->region_number));
1496 emit_barrier ();
1498 seq = get_insns ();
1499 end_sequence ();
1501 emit_to_new_bb_before (seq, region->label);
1502 break;
1504 case ERT_CLEANUP:
1505 case ERT_MUST_NOT_THROW:
1506 region->post_landing_pad = region->label;
1507 break;
1509 case ERT_CATCH:
1510 case ERT_THROW:
1511 /* Nothing to do. */
1512 break;
1514 default:
1515 gcc_unreachable ();
1520 /* Replace RESX patterns with jumps to the next handler if any, or calls to
1521 _Unwind_Resume otherwise. */
1523 static void
1524 connect_post_landing_pads (void)
1526 int i;
1528 for (i = cfun->eh->last_region_number; i > 0; --i)
1530 struct eh_region *region;
1531 struct eh_region *outer;
1532 rtx seq;
1533 rtx barrier;
1535 region = VEC_index (eh_region, cfun->eh->region_array, i);
1536 /* Mind we don't process a region more than once. */
1537 if (!region || region->region_number != i)
1538 continue;
1540 /* If there is no RESX, or it has been deleted by flow, there's
1541 nothing to fix up. */
1542 if (! region->resume || INSN_DELETED_P (region->resume))
1543 continue;
1545 /* Search for another landing pad in this function. */
1546 for (outer = region->outer; outer ; outer = outer->outer)
1547 if (outer->post_landing_pad)
1548 break;
1550 start_sequence ();
1552 if (outer)
1554 edge e;
1555 basic_block src, dest;
1557 emit_jump (outer->post_landing_pad);
1558 src = BLOCK_FOR_INSN (region->resume);
1559 dest = BLOCK_FOR_INSN (outer->post_landing_pad);
1560 while (EDGE_COUNT (src->succs) > 0)
1561 remove_edge (EDGE_SUCC (src, 0));
1562 e = make_edge (src, dest, 0);
1563 e->probability = REG_BR_PROB_BASE;
1564 e->count = src->count;
1566 else
1568 emit_library_call (unwind_resume_libfunc, LCT_THROW,
1569 VOIDmode, 1, cfun->eh->exc_ptr, ptr_mode);
1571 /* What we just emitted was a throwing libcall, so it got a
1572 barrier automatically added after it. If the last insn in
1573 the libcall sequence isn't the barrier, it's because the
1574 target emits multiple insns for a call, and there are insns
1575 after the actual call insn (which are redundant and would be
1576 optimized away). The barrier is inserted exactly after the
1577 call insn, so let's go get that and delete the insns after
1578 it, because below we need the barrier to be the last insn in
1579 the sequence. */
1580 delete_insns_since (NEXT_INSN (last_call_insn ()));
1583 seq = get_insns ();
1584 end_sequence ();
1585 barrier = emit_insn_before (seq, region->resume);
1586 /* Avoid duplicate barrier. */
1587 gcc_assert (BARRIER_P (barrier));
1588 delete_insn (barrier);
1589 delete_insn (region->resume);
1591 /* ??? From tree-ssa we can wind up with catch regions whose
1592 label is not instantiated, but whose resx is present. Now
1593 that we've dealt with the resx, kill the region. */
1594 if (region->label == NULL && region->type == ERT_CLEANUP)
1595 remove_eh_handler (region);
1600 static void
1601 dw2_build_landing_pads (void)
1603 int i;
1605 for (i = cfun->eh->last_region_number; i > 0; --i)
1607 struct eh_region *region;
1608 rtx seq;
1609 basic_block bb;
1610 edge e;
1612 region = VEC_index (eh_region, cfun->eh->region_array, i);
1613 /* Mind we don't process a region more than once. */
1614 if (!region || region->region_number != i)
1615 continue;
1617 if (region->type != ERT_CLEANUP
1618 && region->type != ERT_TRY
1619 && region->type != ERT_ALLOWED_EXCEPTIONS)
1620 continue;
1622 start_sequence ();
1624 region->landing_pad = gen_label_rtx ();
1625 emit_label (region->landing_pad);
1627 #ifdef HAVE_exception_receiver
1628 if (HAVE_exception_receiver)
1629 emit_insn (gen_exception_receiver ());
1630 else
1631 #endif
1632 #ifdef HAVE_nonlocal_goto_receiver
1633 if (HAVE_nonlocal_goto_receiver)
1634 emit_insn (gen_nonlocal_goto_receiver ());
1635 else
1636 #endif
1637 { /* Nothing */ }
1639 emit_move_insn (cfun->eh->exc_ptr,
1640 gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
1641 emit_move_insn (cfun->eh->filter,
1642 gen_rtx_REG (targetm.eh_return_filter_mode (),
1643 EH_RETURN_DATA_REGNO (1)));
1645 seq = get_insns ();
1646 end_sequence ();
1648 bb = emit_to_new_bb_before (seq, region->post_landing_pad);
1649 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
1650 e->count = bb->count;
1651 e->probability = REG_BR_PROB_BASE;
1656 struct sjlj_lp_info
1658 int directly_reachable;
1659 int action_index;
1660 int dispatch_index;
1661 int call_site_index;
1664 static bool
1665 sjlj_find_directly_reachable_regions (struct sjlj_lp_info *lp_info)
1667 rtx insn;
1668 bool found_one = false;
1670 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
1672 struct eh_region *region;
1673 enum reachable_code rc;
1674 tree type_thrown;
1675 rtx note;
1677 if (! INSN_P (insn))
1678 continue;
1680 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1681 if (!note || INTVAL (XEXP (note, 0)) <= 0)
1682 continue;
1684 region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
1686 type_thrown = NULL_TREE;
1687 if (region->type == ERT_THROW)
1689 type_thrown = region->u.throw.type;
1690 region = region->outer;
1693 /* Find the first containing region that might handle the exception.
1694 That's the landing pad to which we will transfer control. */
1695 rc = RNL_NOT_CAUGHT;
1696 for (; region; region = region->outer)
1698 rc = reachable_next_level (region, type_thrown, NULL);
1699 if (rc != RNL_NOT_CAUGHT)
1700 break;
1702 if (rc == RNL_MAYBE_CAUGHT || rc == RNL_CAUGHT)
1704 lp_info[region->region_number].directly_reachable = 1;
1705 found_one = true;
1709 return found_one;
1712 static void
1713 sjlj_assign_call_site_values (rtx dispatch_label, struct sjlj_lp_info *lp_info)
1715 htab_t ar_hash;
1716 int i, index;
1718 /* First task: build the action table. */
1720 VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data");
1721 ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
1723 for (i = cfun->eh->last_region_number; i > 0; --i)
1724 if (lp_info[i].directly_reachable)
1726 struct eh_region *r = VEC_index (eh_region, cfun->eh->region_array, i);
1728 r->landing_pad = dispatch_label;
1729 lp_info[i].action_index = collect_one_action_chain (ar_hash, r);
1730 if (lp_info[i].action_index != -1)
1731 cfun->uses_eh_lsda = 1;
1734 htab_delete (ar_hash);
1736 /* Next: assign dispatch values. In dwarf2 terms, this would be the
1737 landing pad label for the region. For sjlj though, there is one
1738 common landing pad from which we dispatch to the post-landing pads.
1740 A region receives a dispatch index if it is directly reachable
1741 and requires in-function processing. Regions that share post-landing
1742 pads may share dispatch indices. */
1743 /* ??? Post-landing pad sharing doesn't actually happen at the moment
1744 (see build_post_landing_pads) so we don't bother checking for it. */
1746 index = 0;
1747 for (i = cfun->eh->last_region_number; i > 0; --i)
1748 if (lp_info[i].directly_reachable)
1749 lp_info[i].dispatch_index = index++;
1751 /* Finally: assign call-site values. If dwarf2 terms, this would be
1752 the region number assigned by convert_to_eh_region_ranges, but
1753 handles no-action and must-not-throw differently. */
1755 call_site_base = 1;
1756 for (i = cfun->eh->last_region_number; i > 0; --i)
1757 if (lp_info[i].directly_reachable)
1759 int action = lp_info[i].action_index;
1761 /* Map must-not-throw to otherwise unused call-site index 0. */
1762 if (action == -2)
1763 index = 0;
1764 /* Map no-action to otherwise unused call-site index -1. */
1765 else if (action == -1)
1766 index = -1;
1767 /* Otherwise, look it up in the table. */
1768 else
1769 index = add_call_site (GEN_INT (lp_info[i].dispatch_index), action);
1771 lp_info[i].call_site_index = index;
1775 static void
1776 sjlj_mark_call_sites (struct sjlj_lp_info *lp_info)
1778 int last_call_site = -2;
1779 rtx insn, mem;
1781 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
1783 struct eh_region *region;
1784 int this_call_site;
1785 rtx note, before, p;
1787 /* Reset value tracking at extended basic block boundaries. */
1788 if (LABEL_P (insn))
1789 last_call_site = -2;
1791 if (! INSN_P (insn))
1792 continue;
1794 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1795 if (!note)
1797 /* Calls (and trapping insns) without notes are outside any
1798 exception handling region in this function. Mark them as
1799 no action. */
1800 if (CALL_P (insn)
1801 || (flag_non_call_exceptions
1802 && may_trap_p (PATTERN (insn))))
1803 this_call_site = -1;
1804 else
1805 continue;
1807 else
1809 /* Calls that are known to not throw need not be marked. */
1810 if (INTVAL (XEXP (note, 0)) <= 0)
1811 continue;
1813 region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
1814 this_call_site = lp_info[region->region_number].call_site_index;
1817 if (this_call_site == last_call_site)
1818 continue;
1820 /* Don't separate a call from it's argument loads. */
1821 before = insn;
1822 if (CALL_P (insn))
1823 before = find_first_parameter_load (insn, NULL_RTX);
1825 start_sequence ();
1826 mem = adjust_address (cfun->eh->sjlj_fc, TYPE_MODE (integer_type_node),
1827 sjlj_fc_call_site_ofs);
1828 emit_move_insn (mem, GEN_INT (this_call_site));
1829 p = get_insns ();
1830 end_sequence ();
1832 emit_insn_before (p, before);
1833 last_call_site = this_call_site;
1837 /* Construct the SjLj_Function_Context. */
1839 static void
1840 sjlj_emit_function_enter (rtx dispatch_label)
1842 rtx fn_begin, fc, mem, seq;
1843 bool fn_begin_outside_block;
1845 fc = cfun->eh->sjlj_fc;
1847 start_sequence ();
1849 /* We're storing this libcall's address into memory instead of
1850 calling it directly. Thus, we must call assemble_external_libcall
1851 here, as we can not depend on emit_library_call to do it for us. */
1852 assemble_external_libcall (eh_personality_libfunc);
1853 mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
1854 emit_move_insn (mem, eh_personality_libfunc);
1856 mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
1857 if (cfun->uses_eh_lsda)
1859 char buf[20];
1860 rtx sym;
1862 ASM_GENERATE_INTERNAL_LABEL (buf, "LLSDA", current_function_funcdef_no);
1863 sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
1864 SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_LOCAL;
1865 emit_move_insn (mem, sym);
1867 else
1868 emit_move_insn (mem, const0_rtx);
1870 #ifdef DONT_USE_BUILTIN_SETJMP
1872 rtx x;
1873 x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE,
1874 TYPE_MODE (integer_type_node), 1,
1875 plus_constant (XEXP (fc, 0),
1876 sjlj_fc_jbuf_ofs), Pmode);
1878 emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
1879 TYPE_MODE (integer_type_node), 0, dispatch_label);
1880 add_reg_br_prob_note (get_insns (), REG_BR_PROB_BASE/100);
1882 #else
1883 expand_builtin_setjmp_setup (plus_constant (XEXP (fc, 0), sjlj_fc_jbuf_ofs),
1884 dispatch_label);
1885 #endif
1887 emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
1888 1, XEXP (fc, 0), Pmode);
1890 seq = get_insns ();
1891 end_sequence ();
1893 /* ??? Instead of doing this at the beginning of the function,
1894 do this in a block that is at loop level 0 and dominates all
1895 can_throw_internal instructions. */
1897 fn_begin_outside_block = true;
1898 for (fn_begin = get_insns (); ; fn_begin = NEXT_INSN (fn_begin))
1899 if (NOTE_P (fn_begin))
1901 if (NOTE_LINE_NUMBER (fn_begin) == NOTE_INSN_FUNCTION_BEG)
1902 break;
1903 else if (NOTE_LINE_NUMBER (fn_begin) == NOTE_INSN_BASIC_BLOCK)
1904 fn_begin_outside_block = false;
1907 if (fn_begin_outside_block)
1908 insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR));
1909 else
1910 emit_insn_after (seq, fn_begin);
1913 /* Call back from expand_function_end to know where we should put
1914 the call to unwind_sjlj_unregister_libfunc if needed. */
1916 void
1917 sjlj_emit_function_exit_after (rtx after)
1919 cfun->eh->sjlj_exit_after = after;
1922 static void
1923 sjlj_emit_function_exit (void)
1925 rtx seq;
1926 edge e;
1927 edge_iterator ei;
1929 start_sequence ();
1931 emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
1932 1, XEXP (cfun->eh->sjlj_fc, 0), Pmode);
1934 seq = get_insns ();
1935 end_sequence ();
1937 /* ??? Really this can be done in any block at loop level 0 that
1938 post-dominates all can_throw_internal instructions. This is
1939 the last possible moment. */
1941 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
1942 if (e->flags & EDGE_FALLTHRU)
1943 break;
1944 if (e)
1946 rtx insn;
1948 /* Figure out whether the place we are supposed to insert libcall
1949 is inside the last basic block or after it. In the other case
1950 we need to emit to edge. */
1951 gcc_assert (e->src->next_bb == EXIT_BLOCK_PTR);
1952 for (insn = BB_HEAD (e->src); ; insn = NEXT_INSN (insn))
1954 if (insn == cfun->eh->sjlj_exit_after)
1956 if (LABEL_P (insn))
1957 insn = NEXT_INSN (insn);
1958 emit_insn_after (seq, insn);
1959 return;
1961 if (insn == BB_END (e->src))
1962 break;
1964 insert_insn_on_edge (seq, e);
1968 static void
1969 sjlj_emit_dispatch_table (rtx dispatch_label, struct sjlj_lp_info *lp_info)
1971 int i, first_reachable;
1972 rtx mem, dispatch, seq, fc;
1973 rtx before;
1974 basic_block bb;
1975 edge e;
1977 fc = cfun->eh->sjlj_fc;
1979 start_sequence ();
1981 emit_label (dispatch_label);
1983 #ifndef DONT_USE_BUILTIN_SETJMP
1984 expand_builtin_setjmp_receiver (dispatch_label);
1985 #endif
1987 /* Load up dispatch index, exc_ptr and filter values from the
1988 function context. */
1989 mem = adjust_address (fc, TYPE_MODE (integer_type_node),
1990 sjlj_fc_call_site_ofs);
1991 dispatch = copy_to_reg (mem);
1993 mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs);
1994 if (word_mode != ptr_mode)
1996 #ifdef POINTERS_EXTEND_UNSIGNED
1997 mem = convert_memory_address (ptr_mode, mem);
1998 #else
1999 mem = convert_to_mode (ptr_mode, mem, 0);
2000 #endif
2002 emit_move_insn (cfun->eh->exc_ptr, mem);
2004 mem = adjust_address (fc, word_mode, sjlj_fc_data_ofs + UNITS_PER_WORD);
2005 emit_move_insn (cfun->eh->filter, mem);
2007 /* Jump to one of the directly reachable regions. */
2008 /* ??? This really ought to be using a switch statement. */
2010 first_reachable = 0;
2011 for (i = cfun->eh->last_region_number; i > 0; --i)
2013 if (! lp_info[i].directly_reachable)
2014 continue;
2016 if (! first_reachable)
2018 first_reachable = i;
2019 continue;
2022 emit_cmp_and_jump_insns (dispatch, GEN_INT (lp_info[i].dispatch_index),
2023 EQ, NULL_RTX, TYPE_MODE (integer_type_node), 0,
2024 ((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, i))
2025 ->post_landing_pad);
2028 seq = get_insns ();
2029 end_sequence ();
2031 before = (((struct eh_region *)VEC_index (eh_region, cfun->eh->region_array, first_reachable))
2032 ->post_landing_pad);
2034 bb = emit_to_new_bb_before (seq, before);
2035 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
2036 e->count = bb->count;
2037 e->probability = REG_BR_PROB_BASE;
2040 static void
2041 sjlj_build_landing_pads (void)
2043 struct sjlj_lp_info *lp_info;
2045 lp_info = XCNEWVEC (struct sjlj_lp_info, cfun->eh->last_region_number + 1);
2047 if (sjlj_find_directly_reachable_regions (lp_info))
2049 rtx dispatch_label = gen_label_rtx ();
2051 cfun->eh->sjlj_fc
2052 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
2053 int_size_in_bytes (sjlj_fc_type_node),
2054 TYPE_ALIGN (sjlj_fc_type_node));
2056 sjlj_assign_call_site_values (dispatch_label, lp_info);
2057 sjlj_mark_call_sites (lp_info);
2059 sjlj_emit_function_enter (dispatch_label);
2060 sjlj_emit_dispatch_table (dispatch_label, lp_info);
2061 sjlj_emit_function_exit ();
2064 free (lp_info);
2067 void
2068 finish_eh_generation (void)
2070 basic_block bb;
2072 /* Nothing to do if no regions created. */
2073 if (cfun->eh->region_tree == NULL)
2074 return;
2076 /* The object here is to provide find_basic_blocks with detailed
2077 information (via reachable_handlers) on how exception control
2078 flows within the function. In this first pass, we can include
2079 type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS
2080 regions, and hope that it will be useful in deleting unreachable
2081 handlers. Subsequently, we will generate landing pads which will
2082 connect many of the handlers, and then type information will not
2083 be effective. Still, this is a win over previous implementations. */
2085 /* These registers are used by the landing pads. Make sure they
2086 have been generated. */
2087 get_exception_pointer (cfun);
2088 get_exception_filter (cfun);
2090 /* Construct the landing pads. */
2092 assign_filter_values ();
2093 build_post_landing_pads ();
2094 connect_post_landing_pads ();
2095 if (USING_SJLJ_EXCEPTIONS)
2096 sjlj_build_landing_pads ();
2097 else
2098 dw2_build_landing_pads ();
2100 cfun->eh->built_landing_pads = 1;
2102 /* We've totally changed the CFG. Start over. */
2103 find_exception_handler_labels ();
2104 break_superblocks ();
2105 if (USING_SJLJ_EXCEPTIONS)
2106 commit_edge_insertions ();
2107 FOR_EACH_BB (bb)
2109 edge e;
2110 edge_iterator ei;
2111 bool eh = false;
2112 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
2114 if (e->flags & EDGE_EH)
2116 remove_edge (e);
2117 eh = true;
2119 else
2120 ei_next (&ei);
2122 if (eh)
2123 rtl_make_eh_edge (NULL, bb, BB_END (bb));
2127 static hashval_t
2128 ehl_hash (const void *pentry)
2130 struct ehl_map_entry *entry = (struct ehl_map_entry *) pentry;
2132 /* 2^32 * ((sqrt(5) - 1) / 2) */
2133 const hashval_t scaled_golden_ratio = 0x9e3779b9;
2134 return CODE_LABEL_NUMBER (entry->label) * scaled_golden_ratio;
2137 static int
2138 ehl_eq (const void *pentry, const void *pdata)
2140 struct ehl_map_entry *entry = (struct ehl_map_entry *) pentry;
2141 struct ehl_map_entry *data = (struct ehl_map_entry *) pdata;
2143 return entry->label == data->label;
2146 /* This section handles removing dead code for flow. */
2148 /* Remove LABEL from exception_handler_label_map. */
2150 static void
2151 remove_exception_handler_label (rtx label)
2153 struct ehl_map_entry **slot, tmp;
2155 /* If exception_handler_label_map was not built yet,
2156 there is nothing to do. */
2157 if (cfun->eh->exception_handler_label_map == NULL)
2158 return;
2160 tmp.label = label;
2161 slot = (struct ehl_map_entry **)
2162 htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
2163 gcc_assert (slot);
2165 htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
2168 /* Splice REGION from the region tree etc. */
2170 static void
2171 remove_eh_handler (struct eh_region *region)
2173 struct eh_region **pp, **pp_start, *p, *outer, *inner;
2174 rtx lab;
2176 /* For the benefit of efficiently handling REG_EH_REGION notes,
2177 replace this region in the region array with its containing
2178 region. Note that previous region deletions may result in
2179 multiple copies of this region in the array, so we have a
2180 list of alternate numbers by which we are known. */
2182 outer = region->outer;
2183 VEC_replace (eh_region, cfun->eh->region_array, region->region_number, outer);
2184 if (region->aka)
2186 unsigned i;
2187 bitmap_iterator bi;
2189 EXECUTE_IF_SET_IN_BITMAP (region->aka, 0, i, bi)
2191 VEC_replace (eh_region, cfun->eh->region_array, i, outer);
2195 if (outer)
2197 if (!outer->aka)
2198 outer->aka = BITMAP_GGC_ALLOC ();
2199 if (region->aka)
2200 bitmap_ior_into (outer->aka, region->aka);
2201 bitmap_set_bit (outer->aka, region->region_number);
2204 if (cfun->eh->built_landing_pads)
2205 lab = region->landing_pad;
2206 else
2207 lab = region->label;
2208 if (lab)
2209 remove_exception_handler_label (lab);
2211 if (outer)
2212 pp_start = &outer->inner;
2213 else
2214 pp_start = &cfun->eh->region_tree;
2215 for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp)
2216 continue;
2217 *pp = region->next_peer;
2219 inner = region->inner;
2220 if (inner)
2222 for (p = inner; p->next_peer ; p = p->next_peer)
2223 p->outer = outer;
2224 p->outer = outer;
2226 p->next_peer = *pp_start;
2227 *pp_start = inner;
2230 if (region->type == ERT_CATCH)
2232 struct eh_region *try, *next, *prev;
2234 for (try = region->next_peer;
2235 try->type == ERT_CATCH;
2236 try = try->next_peer)
2237 continue;
2238 gcc_assert (try->type == ERT_TRY);
2240 next = region->u.catch.next_catch;
2241 prev = region->u.catch.prev_catch;
2243 if (next)
2244 next->u.catch.prev_catch = prev;
2245 else
2246 try->u.try.last_catch = prev;
2247 if (prev)
2248 prev->u.catch.next_catch = next;
2249 else
2251 try->u.try.catch = next;
2252 if (! next)
2253 remove_eh_handler (try);
2258 /* LABEL heads a basic block that is about to be deleted. If this
2259 label corresponds to an exception region, we may be able to
2260 delete the region. */
2262 void
2263 maybe_remove_eh_handler (rtx label)
2265 struct ehl_map_entry **slot, tmp;
2266 struct eh_region *region;
2268 /* ??? After generating landing pads, it's not so simple to determine
2269 if the region data is completely unused. One must examine the
2270 landing pad and the post landing pad, and whether an inner try block
2271 is referencing the catch handlers directly. */
2272 if (cfun->eh->built_landing_pads)
2273 return;
2275 tmp.label = label;
2276 slot = (struct ehl_map_entry **)
2277 htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
2278 if (! slot)
2279 return;
2280 region = (*slot)->region;
2281 if (! region)
2282 return;
2284 /* Flow will want to remove MUST_NOT_THROW regions as unreachable
2285 because there is no path to the fallback call to terminate.
2286 But the region continues to affect call-site data until there
2287 are no more contained calls, which we don't see here. */
2288 if (region->type == ERT_MUST_NOT_THROW)
2290 htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
2291 region->label = NULL_RTX;
2293 else
2294 remove_eh_handler (region);
2297 /* Invokes CALLBACK for every exception handler label. Only used by old
2298 loop hackery; should not be used by new code. */
2300 void
2301 for_each_eh_label (void (*callback) (rtx))
2303 htab_traverse (cfun->eh->exception_handler_label_map, for_each_eh_label_1,
2304 (void *) &callback);
2307 static int
2308 for_each_eh_label_1 (void **pentry, void *data)
2310 struct ehl_map_entry *entry = *(struct ehl_map_entry **)pentry;
2311 void (*callback) (rtx) = *(void (**) (rtx)) data;
2313 (*callback) (entry->label);
2314 return 1;
2317 /* Invoke CALLBACK for every exception region in the current function. */
2319 void
2320 for_each_eh_region (void (*callback) (struct eh_region *))
2322 int i, n = cfun->eh->last_region_number;
2323 for (i = 1; i <= n; ++i)
2325 struct eh_region *region;
2327 region = VEC_index (eh_region, cfun->eh->region_array, i);
2328 if (region)
2329 (*callback) (region);
2333 /* This section describes CFG exception edges for flow. */
2335 /* For communicating between calls to reachable_next_level. */
2336 struct reachable_info
2338 tree types_caught;
2339 tree types_allowed;
2340 void (*callback) (struct eh_region *, void *);
2341 void *callback_data;
2342 bool saw_any_handlers;
2345 /* A subroutine of reachable_next_level. Return true if TYPE, or a
2346 base class of TYPE, is in HANDLED. */
2348 static int
2349 check_handled (tree handled, tree type)
2351 tree t;
2353 /* We can check for exact matches without front-end help. */
2354 if (! lang_eh_type_covers)
2356 for (t = handled; t ; t = TREE_CHAIN (t))
2357 if (TREE_VALUE (t) == type)
2358 return 1;
2360 else
2362 for (t = handled; t ; t = TREE_CHAIN (t))
2363 if ((*lang_eh_type_covers) (TREE_VALUE (t), type))
2364 return 1;
2367 return 0;
2370 /* A subroutine of reachable_next_level. If we are collecting a list
2371 of handlers, add one. After landing pad generation, reference
2372 it instead of the handlers themselves. Further, the handlers are
2373 all wired together, so by referencing one, we've got them all.
2374 Before landing pad generation we reference each handler individually.
2376 LP_REGION contains the landing pad; REGION is the handler. */
2378 static void
2379 add_reachable_handler (struct reachable_info *info,
2380 struct eh_region *lp_region, struct eh_region *region)
2382 if (! info)
2383 return;
2385 info->saw_any_handlers = true;
2387 if (cfun->eh->built_landing_pads)
2388 info->callback (lp_region, info->callback_data);
2389 else
2390 info->callback (region, info->callback_data);
2393 /* Process one level of exception regions for reachability.
2394 If TYPE_THROWN is non-null, then it is the *exact* type being
2395 propagated. If INFO is non-null, then collect handler labels
2396 and caught/allowed type information between invocations. */
2398 static enum reachable_code
2399 reachable_next_level (struct eh_region *region, tree type_thrown,
2400 struct reachable_info *info)
2402 switch (region->type)
2404 case ERT_CLEANUP:
2405 /* Before landing-pad generation, we model control flow
2406 directly to the individual handlers. In this way we can
2407 see that catch handler types may shadow one another. */
2408 add_reachable_handler (info, region, region);
2409 return RNL_MAYBE_CAUGHT;
2411 case ERT_TRY:
2413 struct eh_region *c;
2414 enum reachable_code ret = RNL_NOT_CAUGHT;
2416 for (c = region->u.try.catch; c ; c = c->u.catch.next_catch)
2418 /* A catch-all handler ends the search. */
2419 if (c->u.catch.type_list == NULL)
2421 add_reachable_handler (info, region, c);
2422 return RNL_CAUGHT;
2425 if (type_thrown)
2427 /* If we have at least one type match, end the search. */
2428 tree tp_node = c->u.catch.type_list;
2430 for (; tp_node; tp_node = TREE_CHAIN (tp_node))
2432 tree type = TREE_VALUE (tp_node);
2434 if (type == type_thrown
2435 || (lang_eh_type_covers
2436 && (*lang_eh_type_covers) (type, type_thrown)))
2438 add_reachable_handler (info, region, c);
2439 return RNL_CAUGHT;
2443 /* If we have definitive information of a match failure,
2444 the catch won't trigger. */
2445 if (lang_eh_type_covers)
2446 return RNL_NOT_CAUGHT;
2449 /* At this point, we either don't know what type is thrown or
2450 don't have front-end assistance to help deciding if it is
2451 covered by one of the types in the list for this region.
2453 We'd then like to add this region to the list of reachable
2454 handlers since it is indeed potentially reachable based on the
2455 information we have.
2457 Actually, this handler is for sure not reachable if all the
2458 types it matches have already been caught. That is, it is only
2459 potentially reachable if at least one of the types it catches
2460 has not been previously caught. */
2462 if (! info)
2463 ret = RNL_MAYBE_CAUGHT;
2464 else
2466 tree tp_node = c->u.catch.type_list;
2467 bool maybe_reachable = false;
2469 /* Compute the potential reachability of this handler and
2470 update the list of types caught at the same time. */
2471 for (; tp_node; tp_node = TREE_CHAIN (tp_node))
2473 tree type = TREE_VALUE (tp_node);
2475 if (! check_handled (info->types_caught, type))
2477 info->types_caught
2478 = tree_cons (NULL, type, info->types_caught);
2480 maybe_reachable = true;
2484 if (maybe_reachable)
2486 add_reachable_handler (info, region, c);
2488 /* ??? If the catch type is a base class of every allowed
2489 type, then we know we can stop the search. */
2490 ret = RNL_MAYBE_CAUGHT;
2495 return ret;
2498 case ERT_ALLOWED_EXCEPTIONS:
2499 /* An empty list of types definitely ends the search. */
2500 if (region->u.allowed.type_list == NULL_TREE)
2502 add_reachable_handler (info, region, region);
2503 return RNL_CAUGHT;
2506 /* Collect a list of lists of allowed types for use in detecting
2507 when a catch may be transformed into a catch-all. */
2508 if (info)
2509 info->types_allowed = tree_cons (NULL_TREE,
2510 region->u.allowed.type_list,
2511 info->types_allowed);
2513 /* If we have definitive information about the type hierarchy,
2514 then we can tell if the thrown type will pass through the
2515 filter. */
2516 if (type_thrown && lang_eh_type_covers)
2518 if (check_handled (region->u.allowed.type_list, type_thrown))
2519 return RNL_NOT_CAUGHT;
2520 else
2522 add_reachable_handler (info, region, region);
2523 return RNL_CAUGHT;
2527 add_reachable_handler (info, region, region);
2528 return RNL_MAYBE_CAUGHT;
2530 case ERT_CATCH:
2531 /* Catch regions are handled by their controlling try region. */
2532 return RNL_NOT_CAUGHT;
2534 case ERT_MUST_NOT_THROW:
2535 /* Here we end our search, since no exceptions may propagate.
2536 If we've touched down at some landing pad previous, then the
2537 explicit function call we generated may be used. Otherwise
2538 the call is made by the runtime.
2540 Before inlining, do not perform this optimization. We may
2541 inline a subroutine that contains handlers, and that will
2542 change the value of saw_any_handlers. */
2544 if ((info && info->saw_any_handlers) || !cfun->after_inlining)
2546 add_reachable_handler (info, region, region);
2547 return RNL_CAUGHT;
2549 else
2550 return RNL_BLOCKED;
2552 case ERT_THROW:
2553 case ERT_UNKNOWN:
2554 /* Shouldn't see these here. */
2555 gcc_unreachable ();
2556 break;
2557 default:
2558 gcc_unreachable ();
2562 /* Invoke CALLBACK on each region reachable from REGION_NUMBER. */
2564 void
2565 foreach_reachable_handler (int region_number, bool is_resx,
2566 void (*callback) (struct eh_region *, void *),
2567 void *callback_data)
2569 struct reachable_info info;
2570 struct eh_region *region;
2571 tree type_thrown;
2573 memset (&info, 0, sizeof (info));
2574 info.callback = callback;
2575 info.callback_data = callback_data;
2577 region = VEC_index (eh_region, cfun->eh->region_array, region_number);
2579 type_thrown = NULL_TREE;
2580 if (is_resx)
2582 /* A RESX leaves a region instead of entering it. Thus the
2583 region itself may have been deleted out from under us. */
2584 if (region == NULL)
2585 return;
2586 region = region->outer;
2588 else if (region->type == ERT_THROW)
2590 type_thrown = region->u.throw.type;
2591 region = region->outer;
2594 while (region)
2596 if (reachable_next_level (region, type_thrown, &info) >= RNL_CAUGHT)
2597 break;
2598 /* If we have processed one cleanup, there is no point in
2599 processing any more of them. Each cleanup will have an edge
2600 to the next outer cleanup region, so the flow graph will be
2601 accurate. */
2602 if (region->type == ERT_CLEANUP)
2603 region = region->u.cleanup.prev_try;
2604 else
2605 region = region->outer;
2609 /* Retrieve a list of labels of exception handlers which can be
2610 reached by a given insn. */
2612 static void
2613 arh_to_landing_pad (struct eh_region *region, void *data)
2615 rtx *p_handlers = data;
2616 if (! *p_handlers)
2617 *p_handlers = alloc_INSN_LIST (region->landing_pad, NULL_RTX);
2620 static void
2621 arh_to_label (struct eh_region *region, void *data)
2623 rtx *p_handlers = data;
2624 *p_handlers = alloc_INSN_LIST (region->label, *p_handlers);
2628 reachable_handlers (rtx insn)
2630 bool is_resx = false;
2631 rtx handlers = NULL;
2632 int region_number;
2634 if (JUMP_P (insn)
2635 && GET_CODE (PATTERN (insn)) == RESX)
2637 region_number = XINT (PATTERN (insn), 0);
2638 is_resx = true;
2640 else
2642 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
2643 if (!note || INTVAL (XEXP (note, 0)) <= 0)
2644 return NULL;
2645 region_number = INTVAL (XEXP (note, 0));
2648 foreach_reachable_handler (region_number, is_resx,
2649 (cfun->eh->built_landing_pads
2650 ? arh_to_landing_pad
2651 : arh_to_label),
2652 &handlers);
2654 return handlers;
2657 /* Determine if the given INSN can throw an exception that is caught
2658 within the function. */
2660 bool
2661 can_throw_internal_1 (int region_number, bool is_resx)
2663 struct eh_region *region;
2664 tree type_thrown;
2666 region = VEC_index (eh_region, cfun->eh->region_array, region_number);
2668 type_thrown = NULL_TREE;
2669 if (is_resx)
2670 region = region->outer;
2671 else if (region->type == ERT_THROW)
2673 type_thrown = region->u.throw.type;
2674 region = region->outer;
2677 /* If this exception is ignored by each and every containing region,
2678 then control passes straight out. The runtime may handle some
2679 regions, which also do not require processing internally. */
2680 for (; region; region = region->outer)
2682 enum reachable_code how = reachable_next_level (region, type_thrown, 0);
2683 if (how == RNL_BLOCKED)
2684 return false;
2685 if (how != RNL_NOT_CAUGHT)
2686 return true;
2689 return false;
2692 bool
2693 can_throw_internal (rtx insn)
2695 rtx note;
2697 if (! INSN_P (insn))
2698 return false;
2700 if (JUMP_P (insn)
2701 && GET_CODE (PATTERN (insn)) == RESX
2702 && XINT (PATTERN (insn), 0) > 0)
2703 return can_throw_internal_1 (XINT (PATTERN (insn), 0), true);
2705 if (NONJUMP_INSN_P (insn)
2706 && GET_CODE (PATTERN (insn)) == SEQUENCE)
2707 insn = XVECEXP (PATTERN (insn), 0, 0);
2709 /* Every insn that might throw has an EH_REGION note. */
2710 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
2711 if (!note || INTVAL (XEXP (note, 0)) <= 0)
2712 return false;
2714 return can_throw_internal_1 (INTVAL (XEXP (note, 0)), false);
2717 /* Determine if the given INSN can throw an exception that is
2718 visible outside the function. */
2720 bool
2721 can_throw_external_1 (int region_number, bool is_resx)
2723 struct eh_region *region;
2724 tree type_thrown;
2726 region = VEC_index (eh_region, cfun->eh->region_array, region_number);
2728 type_thrown = NULL_TREE;
2729 if (is_resx)
2730 region = region->outer;
2731 else if (region->type == ERT_THROW)
2733 type_thrown = region->u.throw.type;
2734 region = region->outer;
2737 /* If the exception is caught or blocked by any containing region,
2738 then it is not seen by any calling function. */
2739 for (; region ; region = region->outer)
2740 if (reachable_next_level (region, type_thrown, NULL) >= RNL_CAUGHT)
2741 return false;
2743 return true;
2746 bool
2747 can_throw_external (rtx insn)
2749 rtx note;
2751 if (! INSN_P (insn))
2752 return false;
2754 if (JUMP_P (insn)
2755 && GET_CODE (PATTERN (insn)) == RESX
2756 && XINT (PATTERN (insn), 0) > 0)
2757 return can_throw_external_1 (XINT (PATTERN (insn), 0), true);
2759 if (NONJUMP_INSN_P (insn)
2760 && GET_CODE (PATTERN (insn)) == SEQUENCE)
2761 insn = XVECEXP (PATTERN (insn), 0, 0);
2763 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
2764 if (!note)
2766 /* Calls (and trapping insns) without notes are outside any
2767 exception handling region in this function. We have to
2768 assume it might throw. Given that the front end and middle
2769 ends mark known NOTHROW functions, this isn't so wildly
2770 inaccurate. */
2771 return (CALL_P (insn)
2772 || (flag_non_call_exceptions
2773 && may_trap_p (PATTERN (insn))));
2775 if (INTVAL (XEXP (note, 0)) <= 0)
2776 return false;
2778 return can_throw_external_1 (INTVAL (XEXP (note, 0)), false);
2781 /* Set TREE_NOTHROW and cfun->all_throwers_are_sibcalls. */
2783 unsigned int
2784 set_nothrow_function_flags (void)
2786 rtx insn;
2788 /* If we don't know that this implementation of the function will
2789 actually be used, then we must not set TREE_NOTHROW, since
2790 callers must not assume that this function does not throw. */
2791 if (DECL_REPLACEABLE_P (current_function_decl))
2792 return 0;
2794 TREE_NOTHROW (current_function_decl) = 1;
2796 /* Assume cfun->all_throwers_are_sibcalls until we encounter
2797 something that can throw an exception. We specifically exempt
2798 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
2799 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
2800 is optimistic. */
2802 cfun->all_throwers_are_sibcalls = 1;
2804 if (! flag_exceptions)
2805 return 0;
2807 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2808 if (can_throw_external (insn))
2810 TREE_NOTHROW (current_function_decl) = 0;
2812 if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
2814 cfun->all_throwers_are_sibcalls = 0;
2815 return 0;
2819 for (insn = current_function_epilogue_delay_list; insn;
2820 insn = XEXP (insn, 1))
2821 if (can_throw_external (insn))
2823 TREE_NOTHROW (current_function_decl) = 0;
2825 if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
2827 cfun->all_throwers_are_sibcalls = 0;
2828 return 0;
2831 return 0;
2834 struct tree_opt_pass pass_set_nothrow_function_flags =
2836 NULL, /* name */
2837 NULL, /* gate */
2838 set_nothrow_function_flags, /* execute */
2839 NULL, /* sub */
2840 NULL, /* next */
2841 0, /* static_pass_number */
2842 0, /* tv_id */
2843 0, /* properties_required */
2844 0, /* properties_provided */
2845 0, /* properties_destroyed */
2846 0, /* todo_flags_start */
2847 0, /* todo_flags_finish */
2848 0 /* letter */
2852 /* Various hooks for unwind library. */
2854 /* Do any necessary initialization to access arbitrary stack frames.
2855 On the SPARC, this means flushing the register windows. */
2857 void
2858 expand_builtin_unwind_init (void)
2860 /* Set this so all the registers get saved in our frame; we need to be
2861 able to copy the saved values for any registers from frames we unwind. */
2862 current_function_has_nonlocal_label = 1;
2864 #ifdef SETUP_FRAME_ADDRESSES
2865 SETUP_FRAME_ADDRESSES ();
2866 #endif
2870 expand_builtin_eh_return_data_regno (tree exp)
2872 tree which = CALL_EXPR_ARG (exp, 0);
2873 unsigned HOST_WIDE_INT iwhich;
2875 if (TREE_CODE (which) != INTEGER_CST)
2877 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2878 return constm1_rtx;
2881 iwhich = tree_low_cst (which, 1);
2882 iwhich = EH_RETURN_DATA_REGNO (iwhich);
2883 if (iwhich == INVALID_REGNUM)
2884 return constm1_rtx;
2886 #ifdef DWARF_FRAME_REGNUM
2887 iwhich = DWARF_FRAME_REGNUM (iwhich);
2888 #else
2889 iwhich = DBX_REGISTER_NUMBER (iwhich);
2890 #endif
2892 return GEN_INT (iwhich);
2895 /* Given a value extracted from the return address register or stack slot,
2896 return the actual address encoded in that value. */
2899 expand_builtin_extract_return_addr (tree addr_tree)
2901 rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, 0);
2903 if (GET_MODE (addr) != Pmode
2904 && GET_MODE (addr) != VOIDmode)
2906 #ifdef POINTERS_EXTEND_UNSIGNED
2907 addr = convert_memory_address (Pmode, addr);
2908 #else
2909 addr = convert_to_mode (Pmode, addr, 0);
2910 #endif
2913 /* First mask out any unwanted bits. */
2914 #ifdef MASK_RETURN_ADDR
2915 expand_and (Pmode, addr, MASK_RETURN_ADDR, addr);
2916 #endif
2918 /* Then adjust to find the real return address. */
2919 #if defined (RETURN_ADDR_OFFSET)
2920 addr = plus_constant (addr, RETURN_ADDR_OFFSET);
2921 #endif
2923 return addr;
2926 /* Given an actual address in addr_tree, do any necessary encoding
2927 and return the value to be stored in the return address register or
2928 stack slot so the epilogue will return to that address. */
2931 expand_builtin_frob_return_addr (tree addr_tree)
2933 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, 0);
2935 addr = convert_memory_address (Pmode, addr);
2937 #ifdef RETURN_ADDR_OFFSET
2938 addr = force_reg (Pmode, addr);
2939 addr = plus_constant (addr, -RETURN_ADDR_OFFSET);
2940 #endif
2942 return addr;
2945 /* Set up the epilogue with the magic bits we'll need to return to the
2946 exception handler. */
2948 void
2949 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED,
2950 tree handler_tree)
2952 rtx tmp;
2954 #ifdef EH_RETURN_STACKADJ_RTX
2955 tmp = expand_expr (stackadj_tree, cfun->eh->ehr_stackadj, VOIDmode, 0);
2956 tmp = convert_memory_address (Pmode, tmp);
2957 if (!cfun->eh->ehr_stackadj)
2958 cfun->eh->ehr_stackadj = copy_to_reg (tmp);
2959 else if (tmp != cfun->eh->ehr_stackadj)
2960 emit_move_insn (cfun->eh->ehr_stackadj, tmp);
2961 #endif
2963 tmp = expand_expr (handler_tree, cfun->eh->ehr_handler, VOIDmode, 0);
2964 tmp = convert_memory_address (Pmode, tmp);
2965 if (!cfun->eh->ehr_handler)
2966 cfun->eh->ehr_handler = copy_to_reg (tmp);
2967 else if (tmp != cfun->eh->ehr_handler)
2968 emit_move_insn (cfun->eh->ehr_handler, tmp);
2970 if (!cfun->eh->ehr_label)
2971 cfun->eh->ehr_label = gen_label_rtx ();
2972 emit_jump (cfun->eh->ehr_label);
2975 void
2976 expand_eh_return (void)
2978 rtx around_label;
2980 if (! cfun->eh->ehr_label)
2981 return;
2983 current_function_calls_eh_return = 1;
2985 #ifdef EH_RETURN_STACKADJ_RTX
2986 emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx);
2987 #endif
2989 around_label = gen_label_rtx ();
2990 emit_jump (around_label);
2992 emit_label (cfun->eh->ehr_label);
2993 clobber_return_register ();
2995 #ifdef EH_RETURN_STACKADJ_RTX
2996 emit_move_insn (EH_RETURN_STACKADJ_RTX, cfun->eh->ehr_stackadj);
2997 #endif
2999 #ifdef HAVE_eh_return
3000 if (HAVE_eh_return)
3001 emit_insn (gen_eh_return (cfun->eh->ehr_handler));
3002 else
3003 #endif
3005 #ifdef EH_RETURN_HANDLER_RTX
3006 emit_move_insn (EH_RETURN_HANDLER_RTX, cfun->eh->ehr_handler);
3007 #else
3008 error ("__builtin_eh_return not supported on this target");
3009 #endif
3012 emit_label (around_label);
3015 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
3016 POINTERS_EXTEND_UNSIGNED and return it. */
3019 expand_builtin_extend_pointer (tree addr_tree)
3021 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, 0);
3022 int extend;
3024 #ifdef POINTERS_EXTEND_UNSIGNED
3025 extend = POINTERS_EXTEND_UNSIGNED;
3026 #else
3027 /* The previous EH code did an unsigned extend by default, so we do this also
3028 for consistency. */
3029 extend = 1;
3030 #endif
3032 return convert_modes (word_mode, ptr_mode, addr, extend);
3035 /* In the following functions, we represent entries in the action table
3036 as 1-based indices. Special cases are:
3038 0: null action record, non-null landing pad; implies cleanups
3039 -1: null action record, null landing pad; implies no action
3040 -2: no call-site entry; implies must_not_throw
3041 -3: we have yet to process outer regions
3043 Further, no special cases apply to the "next" field of the record.
3044 For next, 0 means end of list. */
3046 struct action_record
3048 int offset;
3049 int filter;
3050 int next;
3053 static int
3054 action_record_eq (const void *pentry, const void *pdata)
3056 const struct action_record *entry = (const struct action_record *) pentry;
3057 const struct action_record *data = (const struct action_record *) pdata;
3058 return entry->filter == data->filter && entry->next == data->next;
3061 static hashval_t
3062 action_record_hash (const void *pentry)
3064 const struct action_record *entry = (const struct action_record *) pentry;
3065 return entry->next * 1009 + entry->filter;
3068 static int
3069 add_action_record (htab_t ar_hash, int filter, int next)
3071 struct action_record **slot, *new, tmp;
3073 tmp.filter = filter;
3074 tmp.next = next;
3075 slot = (struct action_record **) htab_find_slot (ar_hash, &tmp, INSERT);
3077 if ((new = *slot) == NULL)
3079 new = xmalloc (sizeof (*new));
3080 new->offset = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
3081 new->filter = filter;
3082 new->next = next;
3083 *slot = new;
3085 /* The filter value goes in untouched. The link to the next
3086 record is a "self-relative" byte offset, or zero to indicate
3087 that there is no next record. So convert the absolute 1 based
3088 indices we've been carrying around into a displacement. */
3090 push_sleb128 (&cfun->eh->action_record_data, filter);
3091 if (next)
3092 next -= VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data) + 1;
3093 push_sleb128 (&cfun->eh->action_record_data, next);
3096 return new->offset;
3099 static int
3100 collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
3102 struct eh_region *c;
3103 int next;
3105 /* If we've reached the top of the region chain, then we have
3106 no actions, and require no landing pad. */
3107 if (region == NULL)
3108 return -1;
3110 switch (region->type)
3112 case ERT_CLEANUP:
3113 /* A cleanup adds a zero filter to the beginning of the chain, but
3114 there are special cases to look out for. If there are *only*
3115 cleanups along a path, then it compresses to a zero action.
3116 Further, if there are multiple cleanups along a path, we only
3117 need to represent one of them, as that is enough to trigger
3118 entry to the landing pad at runtime. */
3119 next = collect_one_action_chain (ar_hash, region->outer);
3120 if (next <= 0)
3121 return 0;
3122 for (c = region->outer; c ; c = c->outer)
3123 if (c->type == ERT_CLEANUP)
3124 return next;
3125 return add_action_record (ar_hash, 0, next);
3127 case ERT_TRY:
3128 /* Process the associated catch regions in reverse order.
3129 If there's a catch-all handler, then we don't need to
3130 search outer regions. Use a magic -3 value to record
3131 that we haven't done the outer search. */
3132 next = -3;
3133 for (c = region->u.try.last_catch; c ; c = c->u.catch.prev_catch)
3135 if (c->u.catch.type_list == NULL)
3137 /* Retrieve the filter from the head of the filter list
3138 where we have stored it (see assign_filter_values). */
3139 int filter
3140 = TREE_INT_CST_LOW (TREE_VALUE (c->u.catch.filter_list));
3142 next = add_action_record (ar_hash, filter, 0);
3144 else
3146 /* Once the outer search is done, trigger an action record for
3147 each filter we have. */
3148 tree flt_node;
3150 if (next == -3)
3152 next = collect_one_action_chain (ar_hash, region->outer);
3154 /* If there is no next action, terminate the chain. */
3155 if (next == -1)
3156 next = 0;
3157 /* If all outer actions are cleanups or must_not_throw,
3158 we'll have no action record for it, since we had wanted
3159 to encode these states in the call-site record directly.
3160 Add a cleanup action to the chain to catch these. */
3161 else if (next <= 0)
3162 next = add_action_record (ar_hash, 0, 0);
3165 flt_node = c->u.catch.filter_list;
3166 for (; flt_node; flt_node = TREE_CHAIN (flt_node))
3168 int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node));
3169 next = add_action_record (ar_hash, filter, next);
3173 return next;
3175 case ERT_ALLOWED_EXCEPTIONS:
3176 /* An exception specification adds its filter to the
3177 beginning of the chain. */
3178 next = collect_one_action_chain (ar_hash, region->outer);
3180 /* If there is no next action, terminate the chain. */
3181 if (next == -1)
3182 next = 0;
3183 /* If all outer actions are cleanups or must_not_throw,
3184 we'll have no action record for it, since we had wanted
3185 to encode these states in the call-site record directly.
3186 Add a cleanup action to the chain to catch these. */
3187 else if (next <= 0)
3188 next = add_action_record (ar_hash, 0, 0);
3190 return add_action_record (ar_hash, region->u.allowed.filter, next);
3192 case ERT_MUST_NOT_THROW:
3193 /* A must-not-throw region with no inner handlers or cleanups
3194 requires no call-site entry. Note that this differs from
3195 the no handler or cleanup case in that we do require an lsda
3196 to be generated. Return a magic -2 value to record this. */
3197 return -2;
3199 case ERT_CATCH:
3200 case ERT_THROW:
3201 /* CATCH regions are handled in TRY above. THROW regions are
3202 for optimization information only and produce no output. */
3203 return collect_one_action_chain (ar_hash, region->outer);
3205 default:
3206 gcc_unreachable ();
3210 static int
3211 add_call_site (rtx landing_pad, int action)
3213 struct call_site_record *data = cfun->eh->call_site_data;
3214 int used = cfun->eh->call_site_data_used;
3215 int size = cfun->eh->call_site_data_size;
3217 if (used >= size)
3219 size = (size ? size * 2 : 64);
3220 data = ggc_realloc (data, sizeof (*data) * size);
3221 cfun->eh->call_site_data = data;
3222 cfun->eh->call_site_data_size = size;
3225 data[used].landing_pad = landing_pad;
3226 data[used].action = action;
3228 cfun->eh->call_site_data_used = used + 1;
3230 return used + call_site_base;
3233 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
3234 The new note numbers will not refer to region numbers, but
3235 instead to call site entries. */
3237 unsigned int
3238 convert_to_eh_region_ranges (void)
3240 rtx insn, iter, note;
3241 htab_t ar_hash;
3242 int last_action = -3;
3243 rtx last_action_insn = NULL_RTX;
3244 rtx last_landing_pad = NULL_RTX;
3245 rtx first_no_action_insn = NULL_RTX;
3246 int call_site = 0;
3248 if (USING_SJLJ_EXCEPTIONS || cfun->eh->region_tree == NULL)
3249 return 0;
3251 VARRAY_UCHAR_INIT (cfun->eh->action_record_data, 64, "action_record_data");
3253 ar_hash = htab_create (31, action_record_hash, action_record_eq, free);
3255 for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
3256 if (INSN_P (iter))
3258 struct eh_region *region;
3259 int this_action;
3260 rtx this_landing_pad;
3262 insn = iter;
3263 if (NONJUMP_INSN_P (insn)
3264 && GET_CODE (PATTERN (insn)) == SEQUENCE)
3265 insn = XVECEXP (PATTERN (insn), 0, 0);
3267 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
3268 if (!note)
3270 if (! (CALL_P (insn)
3271 || (flag_non_call_exceptions
3272 && may_trap_p (PATTERN (insn)))))
3273 continue;
3274 this_action = -1;
3275 region = NULL;
3277 else
3279 if (INTVAL (XEXP (note, 0)) <= 0)
3280 continue;
3281 region = VEC_index (eh_region, cfun->eh->region_array, INTVAL (XEXP (note, 0)));
3282 this_action = collect_one_action_chain (ar_hash, region);
3285 /* Existence of catch handlers, or must-not-throw regions
3286 implies that an lsda is needed (even if empty). */
3287 if (this_action != -1)
3288 cfun->uses_eh_lsda = 1;
3290 /* Delay creation of region notes for no-action regions
3291 until we're sure that an lsda will be required. */
3292 else if (last_action == -3)
3294 first_no_action_insn = iter;
3295 last_action = -1;
3298 /* Cleanups and handlers may share action chains but not
3299 landing pads. Collect the landing pad for this region. */
3300 if (this_action >= 0)
3302 struct eh_region *o;
3303 for (o = region; ! o->landing_pad ; o = o->outer)
3304 continue;
3305 this_landing_pad = o->landing_pad;
3307 else
3308 this_landing_pad = NULL_RTX;
3310 /* Differing actions or landing pads implies a change in call-site
3311 info, which implies some EH_REGION note should be emitted. */
3312 if (last_action != this_action
3313 || last_landing_pad != this_landing_pad)
3315 /* If we'd not seen a previous action (-3) or the previous
3316 action was must-not-throw (-2), then we do not need an
3317 end note. */
3318 if (last_action >= -1)
3320 /* If we delayed the creation of the begin, do it now. */
3321 if (first_no_action_insn)
3323 call_site = add_call_site (NULL_RTX, 0);
3324 note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
3325 first_no_action_insn);
3326 NOTE_EH_HANDLER (note) = call_site;
3327 first_no_action_insn = NULL_RTX;
3330 note = emit_note_after (NOTE_INSN_EH_REGION_END,
3331 last_action_insn);
3332 NOTE_EH_HANDLER (note) = call_site;
3335 /* If the new action is must-not-throw, then no region notes
3336 are created. */
3337 if (this_action >= -1)
3339 call_site = add_call_site (this_landing_pad,
3340 this_action < 0 ? 0 : this_action);
3341 note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter);
3342 NOTE_EH_HANDLER (note) = call_site;
3345 last_action = this_action;
3346 last_landing_pad = this_landing_pad;
3348 last_action_insn = iter;
3351 if (last_action >= -1 && ! first_no_action_insn)
3353 note = emit_note_after (NOTE_INSN_EH_REGION_END, last_action_insn);
3354 NOTE_EH_HANDLER (note) = call_site;
3357 htab_delete (ar_hash);
3358 return 0;
3361 struct tree_opt_pass pass_convert_to_eh_region_ranges =
3363 "eh-ranges", /* name */
3364 NULL, /* gate */
3365 convert_to_eh_region_ranges, /* execute */
3366 NULL, /* sub */
3367 NULL, /* next */
3368 0, /* static_pass_number */
3369 0, /* tv_id */
3370 0, /* properties_required */
3371 0, /* properties_provided */
3372 0, /* properties_destroyed */
3373 0, /* todo_flags_start */
3374 TODO_dump_func, /* todo_flags_finish */
3375 0 /* letter */
3379 static void
3380 push_uleb128 (varray_type *data_area, unsigned int value)
3384 unsigned char byte = value & 0x7f;
3385 value >>= 7;
3386 if (value)
3387 byte |= 0x80;
3388 VARRAY_PUSH_UCHAR (*data_area, byte);
3390 while (value);
3393 static void
3394 push_sleb128 (varray_type *data_area, int value)
3396 unsigned char byte;
3397 int more;
3401 byte = value & 0x7f;
3402 value >>= 7;
3403 more = ! ((value == 0 && (byte & 0x40) == 0)
3404 || (value == -1 && (byte & 0x40) != 0));
3405 if (more)
3406 byte |= 0x80;
3407 VARRAY_PUSH_UCHAR (*data_area, byte);
3409 while (more);
3413 #ifndef HAVE_AS_LEB128
3414 static int
3415 dw2_size_of_call_site_table (void)
3417 int n = cfun->eh->call_site_data_used;
3418 int size = n * (4 + 4 + 4);
3419 int i;
3421 for (i = 0; i < n; ++i)
3423 struct call_site_record *cs = &cfun->eh->call_site_data[i];
3424 size += size_of_uleb128 (cs->action);
3427 return size;
3430 static int
3431 sjlj_size_of_call_site_table (void)
3433 int n = cfun->eh->call_site_data_used;
3434 int size = 0;
3435 int i;
3437 for (i = 0; i < n; ++i)
3439 struct call_site_record *cs = &cfun->eh->call_site_data[i];
3440 size += size_of_uleb128 (INTVAL (cs->landing_pad));
3441 size += size_of_uleb128 (cs->action);
3444 return size;
3446 #endif
3448 static void
3449 dw2_output_call_site_table (void)
3451 int n = cfun->eh->call_site_data_used;
3452 int i;
3454 for (i = 0; i < n; ++i)
3456 struct call_site_record *cs = &cfun->eh->call_site_data[i];
3457 char reg_start_lab[32];
3458 char reg_end_lab[32];
3459 char landing_pad_lab[32];
3461 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab, "LEHB", call_site_base + i);
3462 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab, "LEHE", call_site_base + i);
3464 if (cs->landing_pad)
3465 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab, "L",
3466 CODE_LABEL_NUMBER (cs->landing_pad));
3468 /* ??? Perhaps use insn length scaling if the assembler supports
3469 generic arithmetic. */
3470 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
3471 data4 if the function is small enough. */
3472 #ifdef HAVE_AS_LEB128
3473 dw2_asm_output_delta_uleb128 (reg_start_lab,
3474 current_function_func_begin_label,
3475 "region %d start", i);
3476 dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab,
3477 "length");
3478 if (cs->landing_pad)
3479 dw2_asm_output_delta_uleb128 (landing_pad_lab,
3480 current_function_func_begin_label,
3481 "landing pad");
3482 else
3483 dw2_asm_output_data_uleb128 (0, "landing pad");
3484 #else
3485 dw2_asm_output_delta (4, reg_start_lab,
3486 current_function_func_begin_label,
3487 "region %d start", i);
3488 dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length");
3489 if (cs->landing_pad)
3490 dw2_asm_output_delta (4, landing_pad_lab,
3491 current_function_func_begin_label,
3492 "landing pad");
3493 else
3494 dw2_asm_output_data (4, 0, "landing pad");
3495 #endif
3496 dw2_asm_output_data_uleb128 (cs->action, "action");
3499 call_site_base += n;
3502 static void
3503 sjlj_output_call_site_table (void)
3505 int n = cfun->eh->call_site_data_used;
3506 int i;
3508 for (i = 0; i < n; ++i)
3510 struct call_site_record *cs = &cfun->eh->call_site_data[i];
3512 dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
3513 "region %d landing pad", i);
3514 dw2_asm_output_data_uleb128 (cs->action, "action");
3517 call_site_base += n;
3520 #ifndef TARGET_UNWIND_INFO
3521 /* Switch to the section that should be used for exception tables. */
3523 static void
3524 switch_to_exception_section (const char * ARG_UNUSED (fnname))
3526 section *s;
3528 if (exception_section)
3529 s = exception_section;
3530 else
3532 /* Compute the section and cache it into exception_section,
3533 unless it depends on the function name. */
3534 if (targetm.have_named_sections)
3536 int flags;
3538 if (EH_TABLES_CAN_BE_READ_ONLY)
3540 int tt_format =
3541 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
3542 flags = ((! flag_pic
3543 || ((tt_format & 0x70) != DW_EH_PE_absptr
3544 && (tt_format & 0x70) != DW_EH_PE_aligned))
3545 ? 0 : SECTION_WRITE);
3547 else
3548 flags = SECTION_WRITE;
3550 #ifdef HAVE_LD_EH_GC_SECTIONS
3551 if (flag_function_sections)
3553 char *section_name = xmalloc (strlen (fnname) + 32);
3554 sprintf (section_name, ".gcc_except_table.%s", fnname);
3555 s = get_section (section_name, flags, NULL);
3556 free (section_name);
3558 else
3559 #endif
3560 exception_section
3561 = s = get_section (".gcc_except_table", flags, NULL);
3563 else
3564 exception_section
3565 = s = flag_pic ? data_section : readonly_data_section;
3568 switch_to_section (s);
3570 #endif
3573 /* Output a reference from an exception table to the type_info object TYPE.
3574 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
3575 the value. */
3577 static void
3578 output_ttype (tree type, int tt_format, int tt_format_size)
3580 rtx value;
3581 bool public = true;
3583 if (type == NULL_TREE)
3584 value = const0_rtx;
3585 else
3587 struct varpool_node *node;
3589 type = lookup_type_for_runtime (type);
3590 value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
3592 /* Let cgraph know that the rtti decl is used. Not all of the
3593 paths below go through assemble_integer, which would take
3594 care of this for us. */
3595 STRIP_NOPS (type);
3596 if (TREE_CODE (type) == ADDR_EXPR)
3598 type = TREE_OPERAND (type, 0);
3599 if (TREE_CODE (type) == VAR_DECL)
3601 node = varpool_node (type);
3602 if (node)
3603 varpool_mark_needed_node (node);
3604 public = TREE_PUBLIC (type);
3607 else
3608 gcc_assert (TREE_CODE (type) == INTEGER_CST);
3611 /* Allow the target to override the type table entry format. */
3612 if (targetm.asm_out.ttype (value))
3613 return;
3615 if (tt_format == DW_EH_PE_absptr || tt_format == DW_EH_PE_aligned)
3616 assemble_integer (value, tt_format_size,
3617 tt_format_size * BITS_PER_UNIT, 1);
3618 else
3619 dw2_asm_output_encoded_addr_rtx (tt_format, value, public, NULL);
3622 void
3623 output_function_exception_table (const char * ARG_UNUSED (fnname))
3625 int tt_format, cs_format, lp_format, i, n;
3626 #ifdef HAVE_AS_LEB128
3627 char ttype_label[32];
3628 char cs_after_size_label[32];
3629 char cs_end_label[32];
3630 #else
3631 int call_site_len;
3632 #endif
3633 int have_tt_data;
3634 int tt_format_size = 0;
3636 if (eh_personality_libfunc)
3637 assemble_external_libcall (eh_personality_libfunc);
3639 /* Not all functions need anything. */
3640 if (! cfun->uses_eh_lsda)
3641 return;
3643 #ifdef TARGET_UNWIND_INFO
3644 /* TODO: Move this into target file. */
3645 fputs ("\t.personality\t", asm_out_file);
3646 output_addr_const (asm_out_file, eh_personality_libfunc);
3647 fputs ("\n\t.handlerdata\n", asm_out_file);
3648 /* Note that varasm still thinks we're in the function's code section.
3649 The ".endp" directive that will immediately follow will take us back. */
3650 #else
3651 switch_to_exception_section (fnname);
3652 #endif
3654 /* If the target wants a label to begin the table, emit it here. */
3655 targetm.asm_out.except_table_label (asm_out_file);
3657 have_tt_data = (VEC_length (tree, cfun->eh->ttype_data) > 0
3658 || VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data) > 0);
3660 /* Indicate the format of the @TType entries. */
3661 if (! have_tt_data)
3662 tt_format = DW_EH_PE_omit;
3663 else
3665 tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
3666 #ifdef HAVE_AS_LEB128
3667 ASM_GENERATE_INTERNAL_LABEL (ttype_label, "LLSDATT",
3668 current_function_funcdef_no);
3669 #endif
3670 tt_format_size = size_of_encoded_value (tt_format);
3672 assemble_align (tt_format_size * BITS_PER_UNIT);
3675 targetm.asm_out.internal_label (asm_out_file, "LLSDA",
3676 current_function_funcdef_no);
3678 /* The LSDA header. */
3680 /* Indicate the format of the landing pad start pointer. An omitted
3681 field implies @LPStart == @Start. */
3682 /* Currently we always put @LPStart == @Start. This field would
3683 be most useful in moving the landing pads completely out of
3684 line to another section, but it could also be used to minimize
3685 the size of uleb128 landing pad offsets. */
3686 lp_format = DW_EH_PE_omit;
3687 dw2_asm_output_data (1, lp_format, "@LPStart format (%s)",
3688 eh_data_format_name (lp_format));
3690 /* @LPStart pointer would go here. */
3692 dw2_asm_output_data (1, tt_format, "@TType format (%s)",
3693 eh_data_format_name (tt_format));
3695 #ifndef HAVE_AS_LEB128
3696 if (USING_SJLJ_EXCEPTIONS)
3697 call_site_len = sjlj_size_of_call_site_table ();
3698 else
3699 call_site_len = dw2_size_of_call_site_table ();
3700 #endif
3702 /* A pc-relative 4-byte displacement to the @TType data. */
3703 if (have_tt_data)
3705 #ifdef HAVE_AS_LEB128
3706 char ttype_after_disp_label[32];
3707 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label, "LLSDATTD",
3708 current_function_funcdef_no);
3709 dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
3710 "@TType base offset");
3711 ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label);
3712 #else
3713 /* Ug. Alignment queers things. */
3714 unsigned int before_disp, after_disp, last_disp, disp;
3716 before_disp = 1 + 1;
3717 after_disp = (1 + size_of_uleb128 (call_site_len)
3718 + call_site_len
3719 + VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data)
3720 + (VEC_length (tree, cfun->eh->ttype_data)
3721 * tt_format_size));
3723 disp = after_disp;
3726 unsigned int disp_size, pad;
3728 last_disp = disp;
3729 disp_size = size_of_uleb128 (disp);
3730 pad = before_disp + disp_size + after_disp;
3731 if (pad % tt_format_size)
3732 pad = tt_format_size - (pad % tt_format_size);
3733 else
3734 pad = 0;
3735 disp = after_disp + pad;
3737 while (disp != last_disp);
3739 dw2_asm_output_data_uleb128 (disp, "@TType base offset");
3740 #endif
3743 /* Indicate the format of the call-site offsets. */
3744 #ifdef HAVE_AS_LEB128
3745 cs_format = DW_EH_PE_uleb128;
3746 #else
3747 cs_format = DW_EH_PE_udata4;
3748 #endif
3749 dw2_asm_output_data (1, cs_format, "call-site format (%s)",
3750 eh_data_format_name (cs_format));
3752 #ifdef HAVE_AS_LEB128
3753 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label, "LLSDACSB",
3754 current_function_funcdef_no);
3755 ASM_GENERATE_INTERNAL_LABEL (cs_end_label, "LLSDACSE",
3756 current_function_funcdef_no);
3757 dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label,
3758 "Call-site table length");
3759 ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label);
3760 if (USING_SJLJ_EXCEPTIONS)
3761 sjlj_output_call_site_table ();
3762 else
3763 dw2_output_call_site_table ();
3764 ASM_OUTPUT_LABEL (asm_out_file, cs_end_label);
3765 #else
3766 dw2_asm_output_data_uleb128 (call_site_len,"Call-site table length");
3767 if (USING_SJLJ_EXCEPTIONS)
3768 sjlj_output_call_site_table ();
3769 else
3770 dw2_output_call_site_table ();
3771 #endif
3773 /* ??? Decode and interpret the data for flag_debug_asm. */
3774 n = VARRAY_ACTIVE_SIZE (cfun->eh->action_record_data);
3775 for (i = 0; i < n; ++i)
3776 dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->action_record_data, i),
3777 (i ? NULL : "Action record table"));
3779 if (have_tt_data)
3780 assemble_align (tt_format_size * BITS_PER_UNIT);
3782 i = VEC_length (tree, cfun->eh->ttype_data);
3783 while (i-- > 0)
3785 tree type = VEC_index (tree, cfun->eh->ttype_data, i);
3786 output_ttype (type, tt_format, tt_format_size);
3789 #ifdef HAVE_AS_LEB128
3790 if (have_tt_data)
3791 ASM_OUTPUT_LABEL (asm_out_file, ttype_label);
3792 #endif
3794 /* ??? Decode and interpret the data for flag_debug_asm. */
3795 n = VARRAY_ACTIVE_SIZE (cfun->eh->ehspec_data);
3796 for (i = 0; i < n; ++i)
3798 if (targetm.arm_eabi_unwinder)
3800 tree type = VARRAY_TREE (cfun->eh->ehspec_data, i);
3801 output_ttype (type, tt_format, tt_format_size);
3803 else
3804 dw2_asm_output_data (1, VARRAY_UCHAR (cfun->eh->ehspec_data, i),
3805 (i ? NULL : "Exception specification table"));
3808 switch_to_section (current_function_section ());
3811 void
3812 set_eh_throw_stmt_table (struct function *fun, struct htab *table)
3814 fun->eh->throw_stmt_table = table;
3817 htab_t
3818 get_eh_throw_stmt_table (struct function *fun)
3820 return fun->eh->throw_stmt_table;
3823 /* Dump EH information to OUT. */
3824 void
3825 dump_eh_tree (FILE *out, struct function *fun)
3827 struct eh_region *i;
3828 int depth = 0;
3829 static const char * const type_name[] = {"unknown", "cleanup", "try", "catch",
3830 "allowed_exceptions", "must_not_throw",
3831 "throw"};
3833 i = fun->eh->region_tree;
3834 if (! i)
3835 return;
3837 fprintf (out, "Eh tree:\n");
3838 while (1)
3840 fprintf (out, " %*s %i %s", depth * 2, "",
3841 i->region_number, type_name [(int)i->type]);
3842 if (i->tree_label)
3844 fprintf (out, " tree_label:");
3845 print_generic_expr (out, i->tree_label, 0);
3847 fprintf (out, "\n");
3848 /* If there are sub-regions, process them. */
3849 if (i->inner)
3850 i = i->inner, depth++;
3851 /* If there are peers, process them. */
3852 else if (i->next_peer)
3853 i = i->next_peer;
3854 /* Otherwise, step back up the tree to the next peer. */
3855 else
3857 do {
3858 i = i->outer;
3859 depth--;
3860 if (i == NULL)
3861 return;
3862 } while (i->next_peer == NULL);
3863 i = i->next_peer;
3868 /* Verify some basic invariants on EH datastructures. Could be extended to
3869 catch more. */
3870 void
3871 verify_eh_tree (struct function *fun)
3873 struct eh_region *i, *outer = NULL;
3874 bool err = false;
3875 int nvisited = 0;
3876 int count = 0;
3877 int j;
3878 int depth = 0;
3880 i = fun->eh->region_tree;
3881 if (! i)
3882 return;
3883 for (j = fun->eh->last_region_number; j > 0; --j)
3884 if ((i = VEC_index (eh_region, cfun->eh->region_array, j)))
3886 count++;
3887 if (i->region_number != j)
3889 error ("region_array is corrupted for region %i", i->region_number);
3890 err = true;
3894 while (1)
3896 if (VEC_index (eh_region, cfun->eh->region_array, i->region_number) != i)
3898 error ("region_array is corrupted for region %i", i->region_number);
3899 err = true;
3901 if (i->outer != outer)
3903 error ("outer block of region %i is wrong", i->region_number);
3904 err = true;
3906 if (i->may_contain_throw && outer && !outer->may_contain_throw)
3908 error ("region %i may contain throw and is contained in region that may not",
3909 i->region_number);
3910 err = true;
3912 if (depth < 0)
3914 error ("negative nesting depth of region %i", i->region_number);
3915 err = true;
3917 nvisited ++;
3918 /* If there are sub-regions, process them. */
3919 if (i->inner)
3920 outer = i, i = i->inner, depth++;
3921 /* If there are peers, process them. */
3922 else if (i->next_peer)
3923 i = i->next_peer;
3924 /* Otherwise, step back up the tree to the next peer. */
3925 else
3927 do {
3928 i = i->outer;
3929 depth--;
3930 if (i == NULL)
3932 if (depth != -1)
3934 error ("tree list ends on depth %i", depth + 1);
3935 err = true;
3937 if (count != nvisited)
3939 error ("array does not match the region tree");
3940 err = true;
3942 if (err)
3944 dump_eh_tree (stderr, fun);
3945 internal_error ("verify_eh_tree failed");
3947 return;
3949 outer = i->outer;
3950 } while (i->next_peer == NULL);
3951 i = i->next_peer;
3956 /* Initialize unwind_resume_libfunc. */
3958 void
3959 default_init_unwind_resume_libfunc (void)
3961 /* The default c++ routines aren't actually c++ specific, so use those. */
3962 unwind_resume_libfunc =
3963 init_one_libfunc ( USING_SJLJ_EXCEPTIONS ? "_Unwind_SjLj_Resume"
3964 : "_Unwind_Resume");
3968 static bool
3969 gate_handle_eh (void)
3971 return doing_eh (0);
3974 /* Complete generation of exception handling code. */
3975 static unsigned int
3976 rest_of_handle_eh (void)
3978 cleanup_cfg (CLEANUP_NO_INSN_DEL);
3979 finish_eh_generation ();
3980 cleanup_cfg (CLEANUP_NO_INSN_DEL);
3981 return 0;
3984 struct tree_opt_pass pass_rtl_eh =
3986 "eh", /* name */
3987 gate_handle_eh, /* gate */
3988 rest_of_handle_eh, /* execute */
3989 NULL, /* sub */
3990 NULL, /* next */
3991 0, /* static_pass_number */
3992 TV_JUMP, /* tv_id */
3993 0, /* properties_required */
3994 0, /* properties_provided */
3995 0, /* properties_destroyed */
3996 0, /* todo_flags_start */
3997 TODO_dump_func, /* todo_flags_finish */
3998 'h' /* letter */
4001 #include "gt-except.h"