Daily bump.
[official-gcc.git] / gcc / except.c
blob78518ea808be6847131ecf40c14b6cce362f74f7
1 /* Implements exception handling.
2 Copyright (C) 1989-2014 Free Software Foundation, Inc.
3 Contributed by Mike Stump <mrs@cygnus.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* An exception is an event that can be "thrown" from within a
23 function. This event can then be "caught" by the callers of
24 the function.
26 The representation of exceptions changes several times during
27 the compilation process:
29 In the beginning, in the front end, we have the GENERIC trees
30 TRY_CATCH_EXPR, TRY_FINALLY_EXPR, WITH_CLEANUP_EXPR,
31 CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR.
33 During initial gimplification (gimplify.c) these are lowered
34 to the GIMPLE_TRY, GIMPLE_CATCH, and GIMPLE_EH_FILTER nodes.
35 The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted
36 into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1
37 conversion.
39 During pass_lower_eh (tree-eh.c) we record the nested structure
40 of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE.
41 We expand the eh_protect_cleanup_actions langhook into MUST_NOT_THROW
42 regions at this time. We can then flatten the statements within
43 the TRY nodes to straight-line code. Statements that had been within
44 TRY nodes that can throw are recorded within CFUN->EH->THROW_STMT_TABLE,
45 so that we may remember what action is supposed to be taken if
46 a given statement does throw. During this lowering process,
47 we create an EH_LANDING_PAD node for each EH_REGION that has
48 some code within the function that needs to be executed if a
49 throw does happen. We also create RESX statements that are
50 used to transfer control from an inner EH_REGION to an outer
51 EH_REGION. We also create EH_DISPATCH statements as placeholders
52 for a runtime type comparison that should be made in order to
53 select the action to perform among different CATCH and EH_FILTER
54 regions.
56 During pass_lower_eh_dispatch (tree-eh.c), which is run after
57 all inlining is complete, we are able to run assign_filter_values,
58 which allows us to map the set of types manipulated by all of the
59 CATCH and EH_FILTER regions to a set of integers. This set of integers
60 will be how the exception runtime communicates with the code generated
61 within the function. We then expand the GIMPLE_EH_DISPATCH statements
62 to a switch or conditional branches that use the argument provided by
63 the runtime (__builtin_eh_filter) and the set of integers we computed
64 in assign_filter_values.
66 During pass_lower_resx (tree-eh.c), which is run near the end
67 of optimization, we expand RESX statements. If the eh region
68 that is outer to the RESX statement is a MUST_NOT_THROW, then
69 the RESX expands to some form of abort statement. If the eh
70 region that is outer to the RESX statement is within the current
71 function, then the RESX expands to a bookkeeping call
72 (__builtin_eh_copy_values) and a goto. Otherwise, the next
73 handler for the exception must be within a function somewhere
74 up the call chain, so we call back into the exception runtime
75 (__builtin_unwind_resume).
77 During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes
78 that create an rtl to eh_region mapping that corresponds to the
79 gimple to eh_region mapping that had been recorded in the
80 THROW_STMT_TABLE.
82 Then, via finish_eh_generation, we generate the real landing pads
83 to which the runtime will actually transfer control. These new
84 landing pads perform whatever bookkeeping is needed by the target
85 backend in order to resume execution within the current function.
86 Each of these new landing pads falls through into the post_landing_pad
87 label which had been used within the CFG up to this point. All
88 exception edges within the CFG are redirected to the new landing pads.
89 If the target uses setjmp to implement exceptions, the various extra
90 calls into the runtime to register and unregister the current stack
91 frame are emitted at this time.
93 During pass_convert_to_eh_region_ranges (except.c), we transform
94 the REG_EH_REGION notes attached to individual insns into
95 non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG
96 and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the
97 same associated action within the exception region tree, meaning
98 that (1) the exception is caught by the same landing pad within the
99 current function, (2) the exception is blocked by the runtime with
100 a MUST_NOT_THROW region, or (3) the exception is not handled at all
101 within the current function.
103 Finally, during assembly generation, we call
104 output_function_exception_table (except.c) to emit the tables with
105 which the exception runtime can determine if a given stack frame
106 handles a given exception, and if so what filter value to provide
107 to the function when the non-local control transfer is effected.
108 If the target uses dwarf2 unwinding to implement exceptions, then
109 output_call_frame_info (dwarf2out.c) emits the required unwind data. */
112 #include "config.h"
113 #include "system.h"
114 #include "coretypes.h"
115 #include "tm.h"
116 #include "rtl.h"
117 #include "tree.h"
118 #include "stringpool.h"
119 #include "stor-layout.h"
120 #include "flags.h"
121 #include "function.h"
122 #include "expr.h"
123 #include "libfuncs.h"
124 #include "insn-config.h"
125 #include "except.h"
126 #include "hard-reg-set.h"
127 #include "output.h"
128 #include "dwarf2asm.h"
129 #include "dwarf2out.h"
130 #include "dwarf2.h"
131 #include "toplev.h"
132 #include "hash-table.h"
133 #include "intl.h"
134 #include "tm_p.h"
135 #include "target.h"
136 #include "common/common-target.h"
137 #include "langhooks.h"
138 #include "cgraph.h"
139 #include "diagnostic.h"
140 #include "tree-pretty-print.h"
141 #include "tree-pass.h"
142 #include "cfgloop.h"
143 #include "builtins.h"
145 /* Provide defaults for stuff that may not be defined when using
146 sjlj exceptions. */
147 #ifndef EH_RETURN_DATA_REGNO
148 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
149 #endif
151 static GTY(()) int call_site_base;
153 struct tree_hash_traits : default_hashmap_traits
155 static hashval_t hash (tree t) { return TREE_HASH (t); }
158 static GTY (()) hash_map<tree, tree, tree_hash_traits> *type_to_runtime_map;
160 /* Describe the SjLj_Function_Context structure. */
161 static GTY(()) tree sjlj_fc_type_node;
162 static int sjlj_fc_call_site_ofs;
163 static int sjlj_fc_data_ofs;
164 static int sjlj_fc_personality_ofs;
165 static int sjlj_fc_lsda_ofs;
166 static int sjlj_fc_jbuf_ofs;
169 struct GTY(()) call_site_record_d
171 rtx landing_pad;
172 int action;
175 /* In the following structure and associated functions,
176 we represent entries in the action table as 1-based indices.
177 Special cases are:
179 0: null action record, non-null landing pad; implies cleanups
180 -1: null action record, null landing pad; implies no action
181 -2: no call-site entry; implies must_not_throw
182 -3: we have yet to process outer regions
184 Further, no special cases apply to the "next" field of the record.
185 For next, 0 means end of list. */
187 struct action_record
189 int offset;
190 int filter;
191 int next;
194 /* Hashtable helpers. */
196 struct action_record_hasher : typed_free_remove <action_record>
198 typedef action_record value_type;
199 typedef action_record compare_type;
200 static inline hashval_t hash (const value_type *);
201 static inline bool equal (const value_type *, const compare_type *);
204 inline hashval_t
205 action_record_hasher::hash (const value_type *entry)
207 return entry->next * 1009 + entry->filter;
210 inline bool
211 action_record_hasher::equal (const value_type *entry, const compare_type *data)
213 return entry->filter == data->filter && entry->next == data->next;
216 typedef hash_table<action_record_hasher> action_hash_type;
218 static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *,
219 eh_landing_pad *);
221 static void dw2_build_landing_pads (void);
223 static int collect_one_action_chain (action_hash_type *, eh_region);
224 static int add_call_site (rtx, int, int);
226 static void push_uleb128 (vec<uchar, va_gc> **, unsigned int);
227 static void push_sleb128 (vec<uchar, va_gc> **, int);
228 #ifndef HAVE_AS_LEB128
229 static int dw2_size_of_call_site_table (int);
230 static int sjlj_size_of_call_site_table (void);
231 #endif
232 static void dw2_output_call_site_table (int, int);
233 static void sjlj_output_call_site_table (void);
236 void
237 init_eh (void)
239 if (! flag_exceptions)
240 return;
242 type_to_runtime_map
243 = hash_map<tree, tree, tree_hash_traits>::create_ggc (31);
245 /* Create the SjLj_Function_Context structure. This should match
246 the definition in unwind-sjlj.c. */
247 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
249 tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp;
251 sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE);
253 f_prev = build_decl (BUILTINS_LOCATION,
254 FIELD_DECL, get_identifier ("__prev"),
255 build_pointer_type (sjlj_fc_type_node));
256 DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node;
258 f_cs = build_decl (BUILTINS_LOCATION,
259 FIELD_DECL, get_identifier ("__call_site"),
260 integer_type_node);
261 DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;
263 tmp = build_index_type (size_int (4 - 1));
264 tmp = build_array_type (lang_hooks.types.type_for_mode
265 (targetm.unwind_word_mode (), 1),
266 tmp);
267 f_data = build_decl (BUILTINS_LOCATION,
268 FIELD_DECL, get_identifier ("__data"), tmp);
269 DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node;
271 f_per = build_decl (BUILTINS_LOCATION,
272 FIELD_DECL, get_identifier ("__personality"),
273 ptr_type_node);
274 DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node;
276 f_lsda = build_decl (BUILTINS_LOCATION,
277 FIELD_DECL, get_identifier ("__lsda"),
278 ptr_type_node);
279 DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node;
281 #ifdef DONT_USE_BUILTIN_SETJMP
282 #ifdef JMP_BUF_SIZE
283 tmp = size_int (JMP_BUF_SIZE - 1);
284 #else
285 /* Should be large enough for most systems, if it is not,
286 JMP_BUF_SIZE should be defined with the proper value. It will
287 also tend to be larger than necessary for most systems, a more
288 optimal port will define JMP_BUF_SIZE. */
289 tmp = size_int (FIRST_PSEUDO_REGISTER + 2 - 1);
290 #endif
291 #else
292 /* Compute a minimally sized jump buffer. We need room to store at
293 least 3 pointers - stack pointer, frame pointer and return address.
294 Plus for some targets we need room for an extra pointer - in the
295 case of MIPS this is the global pointer. This makes a total of four
296 pointers, but to be safe we actually allocate room for 5.
298 If pointers are smaller than words then we allocate enough room for
299 5 words, just in case the backend needs this much room. For more
300 discussion on this issue see:
301 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
302 if (POINTER_SIZE > BITS_PER_WORD)
303 tmp = size_int (5 - 1);
304 else
305 tmp = size_int ((5 * BITS_PER_WORD / POINTER_SIZE) - 1);
306 #endif
308 tmp = build_index_type (tmp);
309 tmp = build_array_type (ptr_type_node, tmp);
310 f_jbuf = build_decl (BUILTINS_LOCATION,
311 FIELD_DECL, get_identifier ("__jbuf"), tmp);
312 #ifdef DONT_USE_BUILTIN_SETJMP
313 /* We don't know what the alignment requirements of the
314 runtime's jmp_buf has. Overestimate. */
315 DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT;
316 DECL_USER_ALIGN (f_jbuf) = 1;
317 #endif
318 DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node;
320 TYPE_FIELDS (sjlj_fc_type_node) = f_prev;
321 TREE_CHAIN (f_prev) = f_cs;
322 TREE_CHAIN (f_cs) = f_data;
323 TREE_CHAIN (f_data) = f_per;
324 TREE_CHAIN (f_per) = f_lsda;
325 TREE_CHAIN (f_lsda) = f_jbuf;
327 layout_type (sjlj_fc_type_node);
329 /* Cache the interesting field offsets so that we have
330 easy access from rtl. */
331 sjlj_fc_call_site_ofs
332 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs))
333 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs)) / BITS_PER_UNIT);
334 sjlj_fc_data_ofs
335 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data))
336 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data)) / BITS_PER_UNIT);
337 sjlj_fc_personality_ofs
338 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per))
339 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per)) / BITS_PER_UNIT);
340 sjlj_fc_lsda_ofs
341 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda))
342 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda)) / BITS_PER_UNIT);
343 sjlj_fc_jbuf_ofs
344 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf))
345 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf)) / BITS_PER_UNIT);
349 void
350 init_eh_for_function (void)
352 cfun->eh = ggc_cleared_alloc<eh_status> ();
354 /* Make sure zero'th entries are used. */
355 vec_safe_push (cfun->eh->region_array, (eh_region)0);
356 vec_safe_push (cfun->eh->lp_array, (eh_landing_pad)0);
359 /* Routines to generate the exception tree somewhat directly.
360 These are used from tree-eh.c when processing exception related
361 nodes during tree optimization. */
363 static eh_region
364 gen_eh_region (enum eh_region_type type, eh_region outer)
366 eh_region new_eh;
368 /* Insert a new blank region as a leaf in the tree. */
369 new_eh = ggc_cleared_alloc<eh_region_d> ();
370 new_eh->type = type;
371 new_eh->outer = outer;
372 if (outer)
374 new_eh->next_peer = outer->inner;
375 outer->inner = new_eh;
377 else
379 new_eh->next_peer = cfun->eh->region_tree;
380 cfun->eh->region_tree = new_eh;
383 new_eh->index = vec_safe_length (cfun->eh->region_array);
384 vec_safe_push (cfun->eh->region_array, new_eh);
386 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
387 if (targetm.arm_eabi_unwinder && lang_hooks.eh_use_cxa_end_cleanup)
388 new_eh->use_cxa_end_cleanup = true;
390 return new_eh;
393 eh_region
394 gen_eh_region_cleanup (eh_region outer)
396 return gen_eh_region (ERT_CLEANUP, outer);
399 eh_region
400 gen_eh_region_try (eh_region outer)
402 return gen_eh_region (ERT_TRY, outer);
405 eh_catch
406 gen_eh_region_catch (eh_region t, tree type_or_list)
408 eh_catch c, l;
409 tree type_list, type_node;
411 gcc_assert (t->type == ERT_TRY);
413 /* Ensure to always end up with a type list to normalize further
414 processing, then register each type against the runtime types map. */
415 type_list = type_or_list;
416 if (type_or_list)
418 if (TREE_CODE (type_or_list) != TREE_LIST)
419 type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);
421 type_node = type_list;
422 for (; type_node; type_node = TREE_CHAIN (type_node))
423 add_type_for_runtime (TREE_VALUE (type_node));
426 c = ggc_cleared_alloc<eh_catch_d> ();
427 c->type_list = type_list;
428 l = t->u.eh_try.last_catch;
429 c->prev_catch = l;
430 if (l)
431 l->next_catch = c;
432 else
433 t->u.eh_try.first_catch = c;
434 t->u.eh_try.last_catch = c;
436 return c;
439 eh_region
440 gen_eh_region_allowed (eh_region outer, tree allowed)
442 eh_region region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
443 region->u.allowed.type_list = allowed;
445 for (; allowed ; allowed = TREE_CHAIN (allowed))
446 add_type_for_runtime (TREE_VALUE (allowed));
448 return region;
451 eh_region
452 gen_eh_region_must_not_throw (eh_region outer)
454 return gen_eh_region (ERT_MUST_NOT_THROW, outer);
457 eh_landing_pad
458 gen_eh_landing_pad (eh_region region)
460 eh_landing_pad lp = ggc_cleared_alloc<eh_landing_pad_d> ();
462 lp->next_lp = region->landing_pads;
463 lp->region = region;
464 lp->index = vec_safe_length (cfun->eh->lp_array);
465 region->landing_pads = lp;
467 vec_safe_push (cfun->eh->lp_array, lp);
469 return lp;
472 eh_region
473 get_eh_region_from_number_fn (struct function *ifun, int i)
475 return (*ifun->eh->region_array)[i];
478 eh_region
479 get_eh_region_from_number (int i)
481 return get_eh_region_from_number_fn (cfun, i);
484 eh_landing_pad
485 get_eh_landing_pad_from_number_fn (struct function *ifun, int i)
487 return (*ifun->eh->lp_array)[i];
490 eh_landing_pad
491 get_eh_landing_pad_from_number (int i)
493 return get_eh_landing_pad_from_number_fn (cfun, i);
496 eh_region
497 get_eh_region_from_lp_number_fn (struct function *ifun, int i)
499 if (i < 0)
500 return (*ifun->eh->region_array)[-i];
501 else if (i == 0)
502 return NULL;
503 else
505 eh_landing_pad lp;
506 lp = (*ifun->eh->lp_array)[i];
507 return lp->region;
511 eh_region
512 get_eh_region_from_lp_number (int i)
514 return get_eh_region_from_lp_number_fn (cfun, i);
517 /* Returns true if the current function has exception handling regions. */
519 bool
520 current_function_has_exception_handlers (void)
522 return cfun->eh->region_tree != NULL;
525 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
526 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
528 struct duplicate_eh_regions_data
530 duplicate_eh_regions_map label_map;
531 void *label_map_data;
532 hash_map<void *, void *> *eh_map;
535 static void
536 duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,
537 eh_region old_r, eh_region outer)
539 eh_landing_pad old_lp, new_lp;
540 eh_region new_r;
542 new_r = gen_eh_region (old_r->type, outer);
543 gcc_assert (!data->eh_map->put (old_r, new_r));
545 switch (old_r->type)
547 case ERT_CLEANUP:
548 break;
550 case ERT_TRY:
552 eh_catch oc, nc;
553 for (oc = old_r->u.eh_try.first_catch; oc ; oc = oc->next_catch)
555 /* We should be doing all our region duplication before and
556 during inlining, which is before filter lists are created. */
557 gcc_assert (oc->filter_list == NULL);
558 nc = gen_eh_region_catch (new_r, oc->type_list);
559 nc->label = data->label_map (oc->label, data->label_map_data);
562 break;
564 case ERT_ALLOWED_EXCEPTIONS:
565 new_r->u.allowed.type_list = old_r->u.allowed.type_list;
566 if (old_r->u.allowed.label)
567 new_r->u.allowed.label
568 = data->label_map (old_r->u.allowed.label, data->label_map_data);
569 else
570 new_r->u.allowed.label = NULL_TREE;
571 break;
573 case ERT_MUST_NOT_THROW:
574 new_r->u.must_not_throw.failure_loc =
575 LOCATION_LOCUS (old_r->u.must_not_throw.failure_loc);
576 new_r->u.must_not_throw.failure_decl =
577 old_r->u.must_not_throw.failure_decl;
578 break;
581 for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp)
583 /* Don't bother copying unused landing pads. */
584 if (old_lp->post_landing_pad == NULL)
585 continue;
587 new_lp = gen_eh_landing_pad (new_r);
588 gcc_assert (!data->eh_map->put (old_lp, new_lp));
590 new_lp->post_landing_pad
591 = data->label_map (old_lp->post_landing_pad, data->label_map_data);
592 EH_LANDING_PAD_NR (new_lp->post_landing_pad) = new_lp->index;
595 /* Make sure to preserve the original use of __cxa_end_cleanup. */
596 new_r->use_cxa_end_cleanup = old_r->use_cxa_end_cleanup;
598 for (old_r = old_r->inner; old_r ; old_r = old_r->next_peer)
599 duplicate_eh_regions_1 (data, old_r, new_r);
602 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
603 the current function and root the tree below OUTER_REGION.
604 The special case of COPY_REGION of NULL means all regions.
605 Remap labels using MAP/MAP_DATA callback. Return a pointer map
606 that allows the caller to remap uses of both EH regions and
607 EH landing pads. */
609 hash_map<void *, void *> *
610 duplicate_eh_regions (struct function *ifun,
611 eh_region copy_region, int outer_lp,
612 duplicate_eh_regions_map map, void *map_data)
614 struct duplicate_eh_regions_data data;
615 eh_region outer_region;
617 #ifdef ENABLE_CHECKING
618 verify_eh_tree (ifun);
619 #endif
621 data.label_map = map;
622 data.label_map_data = map_data;
623 data.eh_map = new hash_map<void *, void *>;
625 outer_region = get_eh_region_from_lp_number (outer_lp);
627 /* Copy all the regions in the subtree. */
628 if (copy_region)
629 duplicate_eh_regions_1 (&data, copy_region, outer_region);
630 else
632 eh_region r;
633 for (r = ifun->eh->region_tree; r ; r = r->next_peer)
634 duplicate_eh_regions_1 (&data, r, outer_region);
637 #ifdef ENABLE_CHECKING
638 verify_eh_tree (cfun);
639 #endif
641 return data.eh_map;
644 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
646 eh_region
647 eh_region_outermost (struct function *ifun, eh_region region_a,
648 eh_region region_b)
650 sbitmap b_outer;
652 gcc_assert (ifun->eh->region_array);
653 gcc_assert (ifun->eh->region_tree);
655 b_outer = sbitmap_alloc (ifun->eh->region_array->length ());
656 bitmap_clear (b_outer);
660 bitmap_set_bit (b_outer, region_b->index);
661 region_b = region_b->outer;
663 while (region_b);
667 if (bitmap_bit_p (b_outer, region_a->index))
668 break;
669 region_a = region_a->outer;
671 while (region_a);
673 sbitmap_free (b_outer);
674 return region_a;
677 void
678 add_type_for_runtime (tree type)
680 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
681 if (TREE_CODE (type) == NOP_EXPR)
682 return;
684 bool existed = false;
685 tree *slot = &type_to_runtime_map->get_or_insert (type, &existed);
686 if (!existed)
687 *slot = lang_hooks.eh_runtime_type (type);
690 tree
691 lookup_type_for_runtime (tree type)
693 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
694 if (TREE_CODE (type) == NOP_EXPR)
695 return type;
697 /* We should have always inserted the data earlier. */
698 return *type_to_runtime_map->get (type);
702 /* Represent an entry in @TTypes for either catch actions
703 or exception filter actions. */
704 struct ttypes_filter {
705 tree t;
706 int filter;
709 /* Helper for ttypes_filter hashing. */
711 struct ttypes_filter_hasher : typed_free_remove <ttypes_filter>
713 typedef ttypes_filter value_type;
714 typedef tree_node compare_type;
715 static inline hashval_t hash (const value_type *);
716 static inline bool equal (const value_type *, const compare_type *);
719 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
720 (a tree) for a @TTypes type node we are thinking about adding. */
722 inline bool
723 ttypes_filter_hasher::equal (const value_type *entry, const compare_type *data)
725 return entry->t == data;
728 inline hashval_t
729 ttypes_filter_hasher::hash (const value_type *entry)
731 return TREE_HASH (entry->t);
734 typedef hash_table<ttypes_filter_hasher> ttypes_hash_type;
737 /* Helper for ehspec hashing. */
739 struct ehspec_hasher : typed_free_remove <ttypes_filter>
741 typedef ttypes_filter value_type;
742 typedef ttypes_filter compare_type;
743 static inline hashval_t hash (const value_type *);
744 static inline bool equal (const value_type *, const compare_type *);
747 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
748 exception specification list we are thinking about adding. */
749 /* ??? Currently we use the type lists in the order given. Someone
750 should put these in some canonical order. */
752 inline bool
753 ehspec_hasher::equal (const value_type *entry, const compare_type *data)
755 return type_list_equal (entry->t, data->t);
758 /* Hash function for exception specification lists. */
760 inline hashval_t
761 ehspec_hasher::hash (const value_type *entry)
763 hashval_t h = 0;
764 tree list;
766 for (list = entry->t; list ; list = TREE_CHAIN (list))
767 h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list));
768 return h;
771 typedef hash_table<ehspec_hasher> ehspec_hash_type;
774 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
775 to speed up the search. Return the filter value to be used. */
777 static int
778 add_ttypes_entry (ttypes_hash_type *ttypes_hash, tree type)
780 struct ttypes_filter **slot, *n;
782 slot = ttypes_hash->find_slot_with_hash (type, (hashval_t) TREE_HASH (type),
783 INSERT);
785 if ((n = *slot) == NULL)
787 /* Filter value is a 1 based table index. */
789 n = XNEW (struct ttypes_filter);
790 n->t = type;
791 n->filter = vec_safe_length (cfun->eh->ttype_data) + 1;
792 *slot = n;
794 vec_safe_push (cfun->eh->ttype_data, type);
797 return n->filter;
800 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
801 to speed up the search. Return the filter value to be used. */
803 static int
804 add_ehspec_entry (ehspec_hash_type *ehspec_hash, ttypes_hash_type *ttypes_hash,
805 tree list)
807 struct ttypes_filter **slot, *n;
808 struct ttypes_filter dummy;
810 dummy.t = list;
811 slot = ehspec_hash->find_slot (&dummy, INSERT);
813 if ((n = *slot) == NULL)
815 int len;
817 if (targetm.arm_eabi_unwinder)
818 len = vec_safe_length (cfun->eh->ehspec_data.arm_eabi);
819 else
820 len = vec_safe_length (cfun->eh->ehspec_data.other);
822 /* Filter value is a -1 based byte index into a uleb128 buffer. */
824 n = XNEW (struct ttypes_filter);
825 n->t = list;
826 n->filter = -(len + 1);
827 *slot = n;
829 /* Generate a 0 terminated list of filter values. */
830 for (; list ; list = TREE_CHAIN (list))
832 if (targetm.arm_eabi_unwinder)
833 vec_safe_push (cfun->eh->ehspec_data.arm_eabi, TREE_VALUE (list));
834 else
836 /* Look up each type in the list and encode its filter
837 value as a uleb128. */
838 push_uleb128 (&cfun->eh->ehspec_data.other,
839 add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
842 if (targetm.arm_eabi_unwinder)
843 vec_safe_push (cfun->eh->ehspec_data.arm_eabi, NULL_TREE);
844 else
845 vec_safe_push (cfun->eh->ehspec_data.other, (uchar)0);
848 return n->filter;
851 /* Generate the action filter values to be used for CATCH and
852 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
853 we use lots of landing pads, and so every type or list can share
854 the same filter value, which saves table space. */
856 void
857 assign_filter_values (void)
859 int i;
860 eh_region r;
861 eh_catch c;
863 vec_alloc (cfun->eh->ttype_data, 16);
864 if (targetm.arm_eabi_unwinder)
865 vec_alloc (cfun->eh->ehspec_data.arm_eabi, 64);
866 else
867 vec_alloc (cfun->eh->ehspec_data.other, 64);
869 ehspec_hash_type ehspec (31);
870 ttypes_hash_type ttypes (31);
872 for (i = 1; vec_safe_iterate (cfun->eh->region_array, i, &r); ++i)
874 if (r == NULL)
875 continue;
877 switch (r->type)
879 case ERT_TRY:
880 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
882 /* Whatever type_list is (NULL or true list), we build a list
883 of filters for the region. */
884 c->filter_list = NULL_TREE;
886 if (c->type_list != NULL)
888 /* Get a filter value for each of the types caught and store
889 them in the region's dedicated list. */
890 tree tp_node = c->type_list;
892 for ( ; tp_node; tp_node = TREE_CHAIN (tp_node))
894 int flt
895 = add_ttypes_entry (&ttypes, TREE_VALUE (tp_node));
896 tree flt_node = build_int_cst (integer_type_node, flt);
898 c->filter_list
899 = tree_cons (NULL_TREE, flt_node, c->filter_list);
902 else
904 /* Get a filter value for the NULL list also since it
905 will need an action record anyway. */
906 int flt = add_ttypes_entry (&ttypes, NULL);
907 tree flt_node = build_int_cst (integer_type_node, flt);
909 c->filter_list
910 = tree_cons (NULL_TREE, flt_node, NULL);
913 break;
915 case ERT_ALLOWED_EXCEPTIONS:
916 r->u.allowed.filter
917 = add_ehspec_entry (&ehspec, &ttypes, r->u.allowed.type_list);
918 break;
920 default:
921 break;
926 /* Emit SEQ into basic block just before INSN (that is assumed to be
927 first instruction of some existing BB and return the newly
928 produced block. */
929 static basic_block
930 emit_to_new_bb_before (rtx_insn *seq, rtx insn)
932 rtx_insn *last;
933 basic_block bb;
934 edge e;
935 edge_iterator ei;
937 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
938 call), we don't want it to go into newly created landing pad or other EH
939 construct. */
940 for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); )
941 if (e->flags & EDGE_FALLTHRU)
942 force_nonfallthru (e);
943 else
944 ei_next (&ei);
945 last = emit_insn_before (seq, insn);
946 if (BARRIER_P (last))
947 last = PREV_INSN (last);
948 bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);
949 update_bb_for_insn (bb);
950 bb->flags |= BB_SUPERBLOCK;
951 return bb;
954 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
955 at the rtl level. Emit the code required by the target at a landing
956 pad for the given region. */
958 void
959 expand_dw2_landing_pad_for_region (eh_region region)
961 #ifdef HAVE_exception_receiver
962 if (HAVE_exception_receiver)
963 emit_insn (gen_exception_receiver ());
964 else
965 #endif
966 #ifdef HAVE_nonlocal_goto_receiver
967 if (HAVE_nonlocal_goto_receiver)
968 emit_insn (gen_nonlocal_goto_receiver ());
969 else
970 #endif
971 { /* Nothing */ }
973 if (region->exc_ptr_reg)
974 emit_move_insn (region->exc_ptr_reg,
975 gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
976 if (region->filter_reg)
977 emit_move_insn (region->filter_reg,
978 gen_rtx_REG (targetm.eh_return_filter_mode (),
979 EH_RETURN_DATA_REGNO (1)));
982 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
984 static void
985 dw2_build_landing_pads (void)
987 int i;
988 eh_landing_pad lp;
989 int e_flags = EDGE_FALLTHRU;
991 /* If we're going to partition blocks, we need to be able to add
992 new landing pads later, which means that we need to hold on to
993 the post-landing-pad block. Prevent it from being merged away.
994 We'll remove this bit after partitioning. */
995 if (flag_reorder_blocks_and_partition)
996 e_flags |= EDGE_PRESERVE;
998 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1000 basic_block bb;
1001 rtx_insn *seq;
1002 edge e;
1004 if (lp == NULL || lp->post_landing_pad == NULL)
1005 continue;
1007 start_sequence ();
1009 lp->landing_pad = gen_label_rtx ();
1010 emit_label (lp->landing_pad);
1011 LABEL_PRESERVE_P (lp->landing_pad) = 1;
1013 expand_dw2_landing_pad_for_region (lp->region);
1015 seq = get_insns ();
1016 end_sequence ();
1018 bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad));
1019 e = make_edge (bb, bb->next_bb, e_flags);
1020 e->count = bb->count;
1021 e->probability = REG_BR_PROB_BASE;
1022 if (current_loops)
1024 struct loop *loop = bb->next_bb->loop_father;
1025 /* If we created a pre-header block, add the new block to the
1026 outer loop, otherwise to the loop itself. */
1027 if (bb->next_bb == loop->header)
1028 add_bb_to_loop (bb, loop_outer (loop));
1029 else
1030 add_bb_to_loop (bb, loop);
1036 static vec<int> sjlj_lp_call_site_index;
1038 /* Process all active landing pads. Assign each one a compact dispatch
1039 index, and a call-site index. */
1041 static int
1042 sjlj_assign_call_site_values (void)
1044 action_hash_type ar_hash (31);
1045 int i, disp_index;
1046 eh_landing_pad lp;
1048 vec_alloc (crtl->eh.action_record_data, 64);
1050 disp_index = 0;
1051 call_site_base = 1;
1052 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1053 if (lp && lp->post_landing_pad)
1055 int action, call_site;
1057 /* First: build the action table. */
1058 action = collect_one_action_chain (&ar_hash, lp->region);
1060 /* Next: assign call-site values. If dwarf2 terms, this would be
1061 the region number assigned by convert_to_eh_region_ranges, but
1062 handles no-action and must-not-throw differently. */
1063 /* Map must-not-throw to otherwise unused call-site index 0. */
1064 if (action == -2)
1065 call_site = 0;
1066 /* Map no-action to otherwise unused call-site index -1. */
1067 else if (action == -1)
1068 call_site = -1;
1069 /* Otherwise, look it up in the table. */
1070 else
1071 call_site = add_call_site (GEN_INT (disp_index), action, 0);
1072 sjlj_lp_call_site_index[i] = call_site;
1074 disp_index++;
1077 return disp_index;
1080 /* Emit code to record the current call-site index before every
1081 insn that can throw. */
1083 static void
1084 sjlj_mark_call_sites (void)
1086 int last_call_site = -2;
1087 rtx_insn *insn;
1088 rtx mem;
1090 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
1092 eh_landing_pad lp;
1093 eh_region r;
1094 bool nothrow;
1095 int this_call_site;
1096 rtx_insn *before, *p;
1098 /* Reset value tracking at extended basic block boundaries. */
1099 if (LABEL_P (insn))
1100 last_call_site = -2;
1102 if (! INSN_P (insn))
1103 continue;
1105 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1106 if (nothrow)
1107 continue;
1108 if (lp)
1109 this_call_site = sjlj_lp_call_site_index[lp->index];
1110 else if (r == NULL)
1112 /* Calls (and trapping insns) without notes are outside any
1113 exception handling region in this function. Mark them as
1114 no action. */
1115 this_call_site = -1;
1117 else
1119 gcc_assert (r->type == ERT_MUST_NOT_THROW);
1120 this_call_site = 0;
1123 if (this_call_site != -1)
1124 crtl->uses_eh_lsda = 1;
1126 if (this_call_site == last_call_site)
1127 continue;
1129 /* Don't separate a call from it's argument loads. */
1130 before = insn;
1131 if (CALL_P (insn))
1132 before = find_first_parameter_load (insn, NULL);
1134 start_sequence ();
1135 mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node),
1136 sjlj_fc_call_site_ofs);
1137 emit_move_insn (mem, gen_int_mode (this_call_site, GET_MODE (mem)));
1138 p = get_insns ();
1139 end_sequence ();
1141 emit_insn_before (p, before);
1142 last_call_site = this_call_site;
1146 /* Construct the SjLj_Function_Context. */
1148 static void
1149 sjlj_emit_function_enter (rtx_code_label *dispatch_label)
1151 rtx_insn *fn_begin, *seq;
1152 rtx fc, mem;
1153 bool fn_begin_outside_block;
1154 rtx personality = get_personality_function (current_function_decl);
1156 fc = crtl->eh.sjlj_fc;
1158 start_sequence ();
1160 /* We're storing this libcall's address into memory instead of
1161 calling it directly. Thus, we must call assemble_external_libcall
1162 here, as we can not depend on emit_library_call to do it for us. */
1163 assemble_external_libcall (personality);
1164 mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
1165 emit_move_insn (mem, personality);
1167 mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
1168 if (crtl->uses_eh_lsda)
1170 char buf[20];
1171 rtx sym;
1173 ASM_GENERATE_INTERNAL_LABEL (buf, "LLSDA", current_function_funcdef_no);
1174 sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
1175 SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_LOCAL;
1176 emit_move_insn (mem, sym);
1178 else
1179 emit_move_insn (mem, const0_rtx);
1181 if (dispatch_label)
1183 #ifdef DONT_USE_BUILTIN_SETJMP
1184 rtx x;
1185 x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE,
1186 TYPE_MODE (integer_type_node), 1,
1187 plus_constant (Pmode, XEXP (fc, 0),
1188 sjlj_fc_jbuf_ofs), Pmode);
1190 emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
1191 TYPE_MODE (integer_type_node), 0,
1192 dispatch_label, REG_BR_PROB_BASE / 100);
1193 #else
1194 expand_builtin_setjmp_setup (plus_constant (Pmode, XEXP (fc, 0),
1195 sjlj_fc_jbuf_ofs),
1196 dispatch_label);
1197 #endif
1200 emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
1201 1, XEXP (fc, 0), Pmode);
1203 seq = get_insns ();
1204 end_sequence ();
1206 /* ??? Instead of doing this at the beginning of the function,
1207 do this in a block that is at loop level 0 and dominates all
1208 can_throw_internal instructions. */
1210 fn_begin_outside_block = true;
1211 for (fn_begin = get_insns (); ; fn_begin = NEXT_INSN (fn_begin))
1212 if (NOTE_P (fn_begin))
1214 if (NOTE_KIND (fn_begin) == NOTE_INSN_FUNCTION_BEG)
1215 break;
1216 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin))
1217 fn_begin_outside_block = false;
1220 if (fn_begin_outside_block)
1221 insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
1222 else
1223 emit_insn_after (seq, fn_begin);
1226 /* Call back from expand_function_end to know where we should put
1227 the call to unwind_sjlj_unregister_libfunc if needed. */
1229 void
1230 sjlj_emit_function_exit_after (rtx_insn *after)
1232 crtl->eh.sjlj_exit_after = after;
1235 static void
1236 sjlj_emit_function_exit (void)
1238 rtx_insn *seq, *insn;
1240 start_sequence ();
1242 emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
1243 1, XEXP (crtl->eh.sjlj_fc, 0), Pmode);
1245 seq = get_insns ();
1246 end_sequence ();
1248 /* ??? Really this can be done in any block at loop level 0 that
1249 post-dominates all can_throw_internal instructions. This is
1250 the last possible moment. */
1252 insn = crtl->eh.sjlj_exit_after;
1253 if (LABEL_P (insn))
1254 insn = NEXT_INSN (insn);
1256 emit_insn_after (seq, insn);
1259 static void
1260 sjlj_emit_dispatch_table (rtx_code_label *dispatch_label, int num_dispatch)
1262 enum machine_mode unwind_word_mode = targetm.unwind_word_mode ();
1263 enum machine_mode filter_mode = targetm.eh_return_filter_mode ();
1264 eh_landing_pad lp;
1265 rtx mem, fc, before, exc_ptr_reg, filter_reg;
1266 rtx_insn *seq;
1267 rtx first_reachable_label;
1268 basic_block bb;
1269 eh_region r;
1270 edge e;
1271 int i, disp_index;
1272 vec<tree> dispatch_labels = vNULL;
1274 fc = crtl->eh.sjlj_fc;
1276 start_sequence ();
1278 emit_label (dispatch_label);
1280 #ifndef DONT_USE_BUILTIN_SETJMP
1281 expand_builtin_setjmp_receiver (dispatch_label);
1283 /* The caller of expand_builtin_setjmp_receiver is responsible for
1284 making sure that the label doesn't vanish. The only other caller
1285 is the expander for __builtin_setjmp_receiver, which places this
1286 label on the nonlocal_goto_label list. Since we're modeling these
1287 CFG edges more exactly, we can use the forced_labels list instead. */
1288 LABEL_PRESERVE_P (dispatch_label) = 1;
1289 forced_labels
1290 = gen_rtx_INSN_LIST (VOIDmode, dispatch_label, forced_labels);
1291 #endif
1293 /* Load up exc_ptr and filter values from the function context. */
1294 mem = adjust_address (fc, unwind_word_mode, sjlj_fc_data_ofs);
1295 if (unwind_word_mode != ptr_mode)
1297 #ifdef POINTERS_EXTEND_UNSIGNED
1298 mem = convert_memory_address (ptr_mode, mem);
1299 #else
1300 mem = convert_to_mode (ptr_mode, mem, 0);
1301 #endif
1303 exc_ptr_reg = force_reg (ptr_mode, mem);
1305 mem = adjust_address (fc, unwind_word_mode,
1306 sjlj_fc_data_ofs + GET_MODE_SIZE (unwind_word_mode));
1307 if (unwind_word_mode != filter_mode)
1308 mem = convert_to_mode (filter_mode, mem, 0);
1309 filter_reg = force_reg (filter_mode, mem);
1311 /* Jump to one of the directly reachable regions. */
1313 disp_index = 0;
1314 first_reachable_label = NULL;
1316 /* If there's exactly one call site in the function, don't bother
1317 generating a switch statement. */
1318 if (num_dispatch > 1)
1319 dispatch_labels.create (num_dispatch);
1321 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1322 if (lp && lp->post_landing_pad)
1324 rtx_insn *seq2;
1325 rtx label;
1327 start_sequence ();
1329 lp->landing_pad = dispatch_label;
1331 if (num_dispatch > 1)
1333 tree t_label, case_elt, t;
1335 t_label = create_artificial_label (UNKNOWN_LOCATION);
1336 t = build_int_cst (integer_type_node, disp_index);
1337 case_elt = build_case_label (t, NULL, t_label);
1338 dispatch_labels.quick_push (case_elt);
1339 label = label_rtx (t_label);
1341 else
1342 label = gen_label_rtx ();
1344 if (disp_index == 0)
1345 first_reachable_label = label;
1346 emit_label (label);
1348 r = lp->region;
1349 if (r->exc_ptr_reg)
1350 emit_move_insn (r->exc_ptr_reg, exc_ptr_reg);
1351 if (r->filter_reg)
1352 emit_move_insn (r->filter_reg, filter_reg);
1354 seq2 = get_insns ();
1355 end_sequence ();
1357 before = label_rtx (lp->post_landing_pad);
1358 bb = emit_to_new_bb_before (seq2, before);
1359 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
1360 e->count = bb->count;
1361 e->probability = REG_BR_PROB_BASE;
1362 if (current_loops)
1364 struct loop *loop = bb->next_bb->loop_father;
1365 /* If we created a pre-header block, add the new block to the
1366 outer loop, otherwise to the loop itself. */
1367 if (bb->next_bb == loop->header)
1368 add_bb_to_loop (bb, loop_outer (loop));
1369 else
1370 add_bb_to_loop (bb, loop);
1371 /* ??? For multiple dispatches we will end up with edges
1372 from the loop tree root into this loop, making it a
1373 multiple-entry loop. Discard all affected loops. */
1374 if (num_dispatch > 1)
1376 for (loop = bb->loop_father;
1377 loop_outer (loop); loop = loop_outer (loop))
1378 mark_loop_for_removal (loop);
1382 disp_index++;
1384 gcc_assert (disp_index == num_dispatch);
1386 if (num_dispatch > 1)
1388 rtx disp = adjust_address (fc, TYPE_MODE (integer_type_node),
1389 sjlj_fc_call_site_ofs);
1390 expand_sjlj_dispatch_table (disp, dispatch_labels);
1393 seq = get_insns ();
1394 end_sequence ();
1396 bb = emit_to_new_bb_before (seq, first_reachable_label);
1397 if (num_dispatch == 1)
1399 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
1400 e->count = bb->count;
1401 e->probability = REG_BR_PROB_BASE;
1402 if (current_loops)
1404 struct loop *loop = bb->next_bb->loop_father;
1405 /* If we created a pre-header block, add the new block to the
1406 outer loop, otherwise to the loop itself. */
1407 if (bb->next_bb == loop->header)
1408 add_bb_to_loop (bb, loop_outer (loop));
1409 else
1410 add_bb_to_loop (bb, loop);
1413 else
1415 /* We are not wiring up edges here, but as the dispatcher call
1416 is at function begin simply associate the block with the
1417 outermost (non-)loop. */
1418 if (current_loops)
1419 add_bb_to_loop (bb, current_loops->tree_root);
1423 static void
1424 sjlj_build_landing_pads (void)
1426 int num_dispatch;
1428 num_dispatch = vec_safe_length (cfun->eh->lp_array);
1429 if (num_dispatch == 0)
1430 return;
1431 sjlj_lp_call_site_index.safe_grow_cleared (num_dispatch);
1433 num_dispatch = sjlj_assign_call_site_values ();
1434 if (num_dispatch > 0)
1436 rtx_code_label *dispatch_label = gen_label_rtx ();
1437 int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node,
1438 TYPE_MODE (sjlj_fc_type_node),
1439 TYPE_ALIGN (sjlj_fc_type_node));
1440 crtl->eh.sjlj_fc
1441 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
1442 int_size_in_bytes (sjlj_fc_type_node),
1443 align);
1445 sjlj_mark_call_sites ();
1446 sjlj_emit_function_enter (dispatch_label);
1447 sjlj_emit_dispatch_table (dispatch_label, num_dispatch);
1448 sjlj_emit_function_exit ();
1451 /* If we do not have any landing pads, we may still need to register a
1452 personality routine and (empty) LSDA to handle must-not-throw regions. */
1453 else if (function_needs_eh_personality (cfun) != eh_personality_none)
1455 int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node,
1456 TYPE_MODE (sjlj_fc_type_node),
1457 TYPE_ALIGN (sjlj_fc_type_node));
1458 crtl->eh.sjlj_fc
1459 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
1460 int_size_in_bytes (sjlj_fc_type_node),
1461 align);
1463 sjlj_mark_call_sites ();
1464 sjlj_emit_function_enter (NULL);
1465 sjlj_emit_function_exit ();
1468 sjlj_lp_call_site_index.release ();
1471 /* After initial rtl generation, call back to finish generating
1472 exception support code. */
1474 void
1475 finish_eh_generation (void)
1477 basic_block bb;
1479 /* Construct the landing pads. */
1480 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
1481 sjlj_build_landing_pads ();
1482 else
1483 dw2_build_landing_pads ();
1484 break_superblocks ();
1486 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ
1487 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1488 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun))->insns.r)
1489 commit_edge_insertions ();
1491 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1492 FOR_EACH_BB_FN (bb, cfun)
1494 eh_landing_pad lp;
1495 edge_iterator ei;
1496 edge e;
1498 lp = get_eh_landing_pad_from_rtx (BB_END (bb));
1500 FOR_EACH_EDGE (e, ei, bb->succs)
1501 if (e->flags & EDGE_EH)
1502 break;
1504 /* We should not have generated any new throwing insns during this
1505 pass, and we should not have lost any EH edges, so we only need
1506 to handle two cases here:
1507 (1) reachable handler and an existing edge to post-landing-pad,
1508 (2) no reachable handler and no edge. */
1509 gcc_assert ((lp != NULL) == (e != NULL));
1510 if (lp != NULL)
1512 gcc_assert (BB_HEAD (e->dest) == label_rtx (lp->post_landing_pad));
1514 redirect_edge_succ (e, BLOCK_FOR_INSN (lp->landing_pad));
1515 e->flags |= (CALL_P (BB_END (bb))
1516 ? EDGE_ABNORMAL | EDGE_ABNORMAL_CALL
1517 : EDGE_ABNORMAL);
1522 /* This section handles removing dead code for flow. */
1524 void
1525 remove_eh_landing_pad (eh_landing_pad lp)
1527 eh_landing_pad *pp;
1529 for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp)
1530 continue;
1531 *pp = lp->next_lp;
1533 if (lp->post_landing_pad)
1534 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1535 (*cfun->eh->lp_array)[lp->index] = NULL;
1538 /* Splice the EH region at PP from the region tree. */
1540 static void
1541 remove_eh_handler_splicer (eh_region *pp)
1543 eh_region region = *pp;
1544 eh_landing_pad lp;
1546 for (lp = region->landing_pads; lp ; lp = lp->next_lp)
1548 if (lp->post_landing_pad)
1549 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1550 (*cfun->eh->lp_array)[lp->index] = NULL;
1553 if (region->inner)
1555 eh_region p, outer;
1556 outer = region->outer;
1558 *pp = p = region->inner;
1561 p->outer = outer;
1562 pp = &p->next_peer;
1563 p = *pp;
1565 while (p);
1567 *pp = region->next_peer;
1569 (*cfun->eh->region_array)[region->index] = NULL;
1572 /* Splice a single EH region REGION from the region tree.
1574 To unlink REGION, we need to find the pointer to it with a relatively
1575 expensive search in REGION's outer region. If you are going to
1576 remove a number of handlers, using remove_unreachable_eh_regions may
1577 be a better option. */
1579 void
1580 remove_eh_handler (eh_region region)
1582 eh_region *pp, *pp_start, p, outer;
1584 outer = region->outer;
1585 if (outer)
1586 pp_start = &outer->inner;
1587 else
1588 pp_start = &cfun->eh->region_tree;
1589 for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp)
1590 continue;
1592 remove_eh_handler_splicer (pp);
1595 /* Worker for remove_unreachable_eh_regions.
1596 PP is a pointer to the region to start a region tree depth-first
1597 search from. R_REACHABLE is the set of regions that have to be
1598 preserved. */
1600 static void
1601 remove_unreachable_eh_regions_worker (eh_region *pp, sbitmap r_reachable)
1603 while (*pp)
1605 eh_region region = *pp;
1606 remove_unreachable_eh_regions_worker (&region->inner, r_reachable);
1607 if (!bitmap_bit_p (r_reachable, region->index))
1608 remove_eh_handler_splicer (pp);
1609 else
1610 pp = &region->next_peer;
1614 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1615 Do this by traversing the EH tree top-down and splice out regions that
1616 are not marked. By removing regions from the leaves, we avoid costly
1617 searches in the region tree. */
1619 void
1620 remove_unreachable_eh_regions (sbitmap r_reachable)
1622 remove_unreachable_eh_regions_worker (&cfun->eh->region_tree, r_reachable);
1625 /* Invokes CALLBACK for every exception handler landing pad label.
1626 Only used by reload hackery; should not be used by new code. */
1628 void
1629 for_each_eh_label (void (*callback) (rtx))
1631 eh_landing_pad lp;
1632 int i;
1634 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1636 if (lp)
1638 rtx lab = lp->landing_pad;
1639 if (lab && LABEL_P (lab))
1640 (*callback) (lab);
1645 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1646 call insn.
1648 At the gimple level, we use LP_NR
1649 > 0 : The statement transfers to landing pad LP_NR
1650 = 0 : The statement is outside any EH region
1651 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1653 At the rtl level, we use LP_NR
1654 > 0 : The insn transfers to landing pad LP_NR
1655 = 0 : The insn cannot throw
1656 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1657 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1658 missing note: The insn is outside any EH region.
1660 ??? This difference probably ought to be avoided. We could stand
1661 to record nothrow for arbitrary gimple statements, and so avoid
1662 some moderately complex lookups in stmt_could_throw_p. Perhaps
1663 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1664 no-nonlocal-goto property should be recorded elsewhere as a bit
1665 on the call_insn directly. Perhaps we should make more use of
1666 attaching the trees to call_insns (reachable via symbol_ref in
1667 direct call cases) and just pull the data out of the trees. */
1669 void
1670 make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr)
1672 rtx value;
1673 if (ecf_flags & ECF_NOTHROW)
1674 value = const0_rtx;
1675 else if (lp_nr != 0)
1676 value = GEN_INT (lp_nr);
1677 else
1678 return;
1679 add_reg_note (insn, REG_EH_REGION, value);
1682 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1683 nor perform a non-local goto. Replace the region note if it
1684 already exists. */
1686 void
1687 make_reg_eh_region_note_nothrow_nononlocal (rtx insn)
1689 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1690 rtx intmin = GEN_INT (INT_MIN);
1692 if (note != 0)
1693 XEXP (note, 0) = intmin;
1694 else
1695 add_reg_note (insn, REG_EH_REGION, intmin);
1698 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1699 to the contrary. */
1701 bool
1702 insn_could_throw_p (const_rtx insn)
1704 if (!flag_exceptions)
1705 return false;
1706 if (CALL_P (insn))
1707 return true;
1708 if (INSN_P (insn) && cfun->can_throw_non_call_exceptions)
1709 return may_trap_p (PATTERN (insn));
1710 return false;
1713 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1714 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1715 to look for a note, or the note itself. */
1717 void
1718 copy_reg_eh_region_note_forward (rtx note_or_insn, rtx_insn *first, rtx last)
1720 rtx_insn *insn;
1721 rtx note = note_or_insn;
1723 if (INSN_P (note_or_insn))
1725 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
1726 if (note == NULL)
1727 return;
1729 note = XEXP (note, 0);
1731 for (insn = first; insn != last ; insn = NEXT_INSN (insn))
1732 if (!find_reg_note (insn, REG_EH_REGION, NULL_RTX)
1733 && insn_could_throw_p (insn))
1734 add_reg_note (insn, REG_EH_REGION, note);
1737 /* Likewise, but iterate backward. */
1739 void
1740 copy_reg_eh_region_note_backward (rtx note_or_insn, rtx_insn *last, rtx first)
1742 rtx_insn *insn;
1743 rtx note = note_or_insn;
1745 if (INSN_P (note_or_insn))
1747 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
1748 if (note == NULL)
1749 return;
1751 note = XEXP (note, 0);
1753 for (insn = last; insn != first; insn = PREV_INSN (insn))
1754 if (insn_could_throw_p (insn))
1755 add_reg_note (insn, REG_EH_REGION, note);
1759 /* Extract all EH information from INSN. Return true if the insn
1760 was marked NOTHROW. */
1762 static bool
1763 get_eh_region_and_lp_from_rtx (const_rtx insn, eh_region *pr,
1764 eh_landing_pad *plp)
1766 eh_landing_pad lp = NULL;
1767 eh_region r = NULL;
1768 bool ret = false;
1769 rtx note;
1770 int lp_nr;
1772 if (! INSN_P (insn))
1773 goto egress;
1775 if (NONJUMP_INSN_P (insn)
1776 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1777 insn = XVECEXP (PATTERN (insn), 0, 0);
1779 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1780 if (!note)
1782 ret = !insn_could_throw_p (insn);
1783 goto egress;
1786 lp_nr = INTVAL (XEXP (note, 0));
1787 if (lp_nr == 0 || lp_nr == INT_MIN)
1789 ret = true;
1790 goto egress;
1793 if (lp_nr < 0)
1794 r = (*cfun->eh->region_array)[-lp_nr];
1795 else
1797 lp = (*cfun->eh->lp_array)[lp_nr];
1798 r = lp->region;
1801 egress:
1802 *plp = lp;
1803 *pr = r;
1804 return ret;
1807 /* Return the landing pad to which INSN may go, or NULL if it does not
1808 have a reachable landing pad within this function. */
1810 eh_landing_pad
1811 get_eh_landing_pad_from_rtx (const_rtx insn)
1813 eh_landing_pad lp;
1814 eh_region r;
1816 get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1817 return lp;
1820 /* Return the region to which INSN may go, or NULL if it does not
1821 have a reachable region within this function. */
1823 eh_region
1824 get_eh_region_from_rtx (const_rtx insn)
1826 eh_landing_pad lp;
1827 eh_region r;
1829 get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1830 return r;
1833 /* Return true if INSN throws and is caught by something in this function. */
1835 bool
1836 can_throw_internal (const_rtx insn)
1838 return get_eh_landing_pad_from_rtx (insn) != NULL;
1841 /* Return true if INSN throws and escapes from the current function. */
1843 bool
1844 can_throw_external (const_rtx insn)
1846 eh_landing_pad lp;
1847 eh_region r;
1848 bool nothrow;
1850 if (! INSN_P (insn))
1851 return false;
1853 if (NONJUMP_INSN_P (insn)
1854 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1856 rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (insn));
1857 int i, n = seq->len ();
1859 for (i = 0; i < n; i++)
1860 if (can_throw_external (seq->element (i)))
1861 return true;
1863 return false;
1866 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1868 /* If we can't throw, we obviously can't throw external. */
1869 if (nothrow)
1870 return false;
1872 /* If we have an internal landing pad, then we're not external. */
1873 if (lp != NULL)
1874 return false;
1876 /* If we're not within an EH region, then we are external. */
1877 if (r == NULL)
1878 return true;
1880 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1881 which don't always have landing pads. */
1882 gcc_assert (r->type == ERT_MUST_NOT_THROW);
1883 return false;
1886 /* Return true if INSN cannot throw at all. */
1888 bool
1889 insn_nothrow_p (const_rtx insn)
1891 eh_landing_pad lp;
1892 eh_region r;
1894 if (! INSN_P (insn))
1895 return true;
1897 if (NONJUMP_INSN_P (insn)
1898 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1900 rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (insn));
1901 int i, n = seq->len ();
1903 for (i = 0; i < n; i++)
1904 if (!insn_nothrow_p (seq->element (i)))
1905 return false;
1907 return true;
1910 return get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1913 /* Return true if INSN can perform a non-local goto. */
1914 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1916 bool
1917 can_nonlocal_goto (const_rtx insn)
1919 if (nonlocal_goto_handler_labels && CALL_P (insn))
1921 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1922 if (!note || INTVAL (XEXP (note, 0)) != INT_MIN)
1923 return true;
1925 return false;
1928 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1930 static unsigned int
1931 set_nothrow_function_flags (void)
1933 rtx_insn *insn;
1935 crtl->nothrow = 1;
1937 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1938 something that can throw an exception. We specifically exempt
1939 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1940 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1941 is optimistic. */
1943 crtl->all_throwers_are_sibcalls = 1;
1945 /* If we don't know that this implementation of the function will
1946 actually be used, then we must not set TREE_NOTHROW, since
1947 callers must not assume that this function does not throw. */
1948 if (TREE_NOTHROW (current_function_decl))
1949 return 0;
1951 if (! flag_exceptions)
1952 return 0;
1954 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1955 if (can_throw_external (insn))
1957 crtl->nothrow = 0;
1959 if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
1961 crtl->all_throwers_are_sibcalls = 0;
1962 return 0;
1966 if (crtl->nothrow
1967 && (cgraph_node::get (current_function_decl)->get_availability ()
1968 >= AVAIL_AVAILABLE))
1970 struct cgraph_node *node = cgraph_node::get (current_function_decl);
1971 struct cgraph_edge *e;
1972 for (e = node->callers; e; e = e->next_caller)
1973 e->can_throw_external = false;
1974 node->set_nothrow_flag (true);
1976 if (dump_file)
1977 fprintf (dump_file, "Marking function nothrow: %s\n\n",
1978 current_function_name ());
1980 return 0;
1983 namespace {
1985 const pass_data pass_data_set_nothrow_function_flags =
1987 RTL_PASS, /* type */
1988 "nothrow", /* name */
1989 OPTGROUP_NONE, /* optinfo_flags */
1990 TV_NONE, /* tv_id */
1991 0, /* properties_required */
1992 0, /* properties_provided */
1993 0, /* properties_destroyed */
1994 0, /* todo_flags_start */
1995 0, /* todo_flags_finish */
1998 class pass_set_nothrow_function_flags : public rtl_opt_pass
2000 public:
2001 pass_set_nothrow_function_flags (gcc::context *ctxt)
2002 : rtl_opt_pass (pass_data_set_nothrow_function_flags, ctxt)
2005 /* opt_pass methods: */
2006 virtual unsigned int execute (function *)
2008 return set_nothrow_function_flags ();
2011 }; // class pass_set_nothrow_function_flags
2013 } // anon namespace
2015 rtl_opt_pass *
2016 make_pass_set_nothrow_function_flags (gcc::context *ctxt)
2018 return new pass_set_nothrow_function_flags (ctxt);
2022 /* Various hooks for unwind library. */
2024 /* Expand the EH support builtin functions:
2025 __builtin_eh_pointer and __builtin_eh_filter. */
2027 static eh_region
2028 expand_builtin_eh_common (tree region_nr_t)
2030 HOST_WIDE_INT region_nr;
2031 eh_region region;
2033 gcc_assert (tree_fits_shwi_p (region_nr_t));
2034 region_nr = tree_to_shwi (region_nr_t);
2036 region = (*cfun->eh->region_array)[region_nr];
2038 /* ??? We shouldn't have been able to delete a eh region without
2039 deleting all the code that depended on it. */
2040 gcc_assert (region != NULL);
2042 return region;
2045 /* Expand to the exc_ptr value from the given eh region. */
2048 expand_builtin_eh_pointer (tree exp)
2050 eh_region region
2051 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
2052 if (region->exc_ptr_reg == NULL)
2053 region->exc_ptr_reg = gen_reg_rtx (ptr_mode);
2054 return region->exc_ptr_reg;
2057 /* Expand to the filter value from the given eh region. */
2060 expand_builtin_eh_filter (tree exp)
2062 eh_region region
2063 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
2064 if (region->filter_reg == NULL)
2065 region->filter_reg = gen_reg_rtx (targetm.eh_return_filter_mode ());
2066 return region->filter_reg;
2069 /* Copy the exc_ptr and filter values from one landing pad's registers
2070 to another. This is used to inline the resx statement. */
2073 expand_builtin_eh_copy_values (tree exp)
2075 eh_region dst
2076 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
2077 eh_region src
2078 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1));
2079 enum machine_mode fmode = targetm.eh_return_filter_mode ();
2081 if (dst->exc_ptr_reg == NULL)
2082 dst->exc_ptr_reg = gen_reg_rtx (ptr_mode);
2083 if (src->exc_ptr_reg == NULL)
2084 src->exc_ptr_reg = gen_reg_rtx (ptr_mode);
2086 if (dst->filter_reg == NULL)
2087 dst->filter_reg = gen_reg_rtx (fmode);
2088 if (src->filter_reg == NULL)
2089 src->filter_reg = gen_reg_rtx (fmode);
2091 emit_move_insn (dst->exc_ptr_reg, src->exc_ptr_reg);
2092 emit_move_insn (dst->filter_reg, src->filter_reg);
2094 return const0_rtx;
2097 /* Do any necessary initialization to access arbitrary stack frames.
2098 On the SPARC, this means flushing the register windows. */
2100 void
2101 expand_builtin_unwind_init (void)
2103 /* Set this so all the registers get saved in our frame; we need to be
2104 able to copy the saved values for any registers from frames we unwind. */
2105 crtl->saves_all_registers = 1;
2107 #ifdef SETUP_FRAME_ADDRESSES
2108 SETUP_FRAME_ADDRESSES ();
2109 #endif
2112 /* Map a non-negative number to an eh return data register number; expands
2113 to -1 if no return data register is associated with the input number.
2114 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2117 expand_builtin_eh_return_data_regno (tree exp)
2119 tree which = CALL_EXPR_ARG (exp, 0);
2120 unsigned HOST_WIDE_INT iwhich;
2122 if (TREE_CODE (which) != INTEGER_CST)
2124 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2125 return constm1_rtx;
2128 iwhich = tree_to_uhwi (which);
2129 iwhich = EH_RETURN_DATA_REGNO (iwhich);
2130 if (iwhich == INVALID_REGNUM)
2131 return constm1_rtx;
2133 #ifdef DWARF_FRAME_REGNUM
2134 iwhich = DWARF_FRAME_REGNUM (iwhich);
2135 #else
2136 iwhich = DBX_REGISTER_NUMBER (iwhich);
2137 #endif
2139 return GEN_INT (iwhich);
2142 /* Given a value extracted from the return address register or stack slot,
2143 return the actual address encoded in that value. */
2146 expand_builtin_extract_return_addr (tree addr_tree)
2148 rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
2150 if (GET_MODE (addr) != Pmode
2151 && GET_MODE (addr) != VOIDmode)
2153 #ifdef POINTERS_EXTEND_UNSIGNED
2154 addr = convert_memory_address (Pmode, addr);
2155 #else
2156 addr = convert_to_mode (Pmode, addr, 0);
2157 #endif
2160 /* First mask out any unwanted bits. */
2161 #ifdef MASK_RETURN_ADDR
2162 expand_and (Pmode, addr, MASK_RETURN_ADDR, addr);
2163 #endif
2165 /* Then adjust to find the real return address. */
2166 #if defined (RETURN_ADDR_OFFSET)
2167 addr = plus_constant (Pmode, addr, RETURN_ADDR_OFFSET);
2168 #endif
2170 return addr;
2173 /* Given an actual address in addr_tree, do any necessary encoding
2174 and return the value to be stored in the return address register or
2175 stack slot so the epilogue will return to that address. */
2178 expand_builtin_frob_return_addr (tree addr_tree)
2180 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
2182 addr = convert_memory_address (Pmode, addr);
2184 #ifdef RETURN_ADDR_OFFSET
2185 addr = force_reg (Pmode, addr);
2186 addr = plus_constant (Pmode, addr, -RETURN_ADDR_OFFSET);
2187 #endif
2189 return addr;
2192 /* Set up the epilogue with the magic bits we'll need to return to the
2193 exception handler. */
2195 void
2196 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED,
2197 tree handler_tree)
2199 rtx tmp;
2201 #ifdef EH_RETURN_STACKADJ_RTX
2202 tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj,
2203 VOIDmode, EXPAND_NORMAL);
2204 tmp = convert_memory_address (Pmode, tmp);
2205 if (!crtl->eh.ehr_stackadj)
2206 crtl->eh.ehr_stackadj = copy_to_reg (tmp);
2207 else if (tmp != crtl->eh.ehr_stackadj)
2208 emit_move_insn (crtl->eh.ehr_stackadj, tmp);
2209 #endif
2211 tmp = expand_expr (handler_tree, crtl->eh.ehr_handler,
2212 VOIDmode, EXPAND_NORMAL);
2213 tmp = convert_memory_address (Pmode, tmp);
2214 if (!crtl->eh.ehr_handler)
2215 crtl->eh.ehr_handler = copy_to_reg (tmp);
2216 else if (tmp != crtl->eh.ehr_handler)
2217 emit_move_insn (crtl->eh.ehr_handler, tmp);
2219 if (!crtl->eh.ehr_label)
2220 crtl->eh.ehr_label = gen_label_rtx ();
2221 emit_jump (crtl->eh.ehr_label);
2224 /* Expand __builtin_eh_return. This exit path from the function loads up
2225 the eh return data registers, adjusts the stack, and branches to a
2226 given PC other than the normal return address. */
2228 void
2229 expand_eh_return (void)
2231 rtx_code_label *around_label;
2233 if (! crtl->eh.ehr_label)
2234 return;
2236 crtl->calls_eh_return = 1;
2238 #ifdef EH_RETURN_STACKADJ_RTX
2239 emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx);
2240 #endif
2242 around_label = gen_label_rtx ();
2243 emit_jump (around_label);
2245 emit_label (crtl->eh.ehr_label);
2246 clobber_return_register ();
2248 #ifdef EH_RETURN_STACKADJ_RTX
2249 emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj);
2250 #endif
2252 #ifdef HAVE_eh_return
2253 if (HAVE_eh_return)
2254 emit_insn (gen_eh_return (crtl->eh.ehr_handler));
2255 else
2256 #endif
2258 #ifdef EH_RETURN_HANDLER_RTX
2259 emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler);
2260 #else
2261 error ("__builtin_eh_return not supported on this target");
2262 #endif
2265 emit_label (around_label);
2268 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2269 POINTERS_EXTEND_UNSIGNED and return it. */
2272 expand_builtin_extend_pointer (tree addr_tree)
2274 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
2275 int extend;
2277 #ifdef POINTERS_EXTEND_UNSIGNED
2278 extend = POINTERS_EXTEND_UNSIGNED;
2279 #else
2280 /* The previous EH code did an unsigned extend by default, so we do this also
2281 for consistency. */
2282 extend = 1;
2283 #endif
2285 return convert_modes (targetm.unwind_word_mode (), ptr_mode, addr, extend);
2288 static int
2289 add_action_record (action_hash_type *ar_hash, int filter, int next)
2291 struct action_record **slot, *new_ar, tmp;
2293 tmp.filter = filter;
2294 tmp.next = next;
2295 slot = ar_hash->find_slot (&tmp, INSERT);
2297 if ((new_ar = *slot) == NULL)
2299 new_ar = XNEW (struct action_record);
2300 new_ar->offset = crtl->eh.action_record_data->length () + 1;
2301 new_ar->filter = filter;
2302 new_ar->next = next;
2303 *slot = new_ar;
2305 /* The filter value goes in untouched. The link to the next
2306 record is a "self-relative" byte offset, or zero to indicate
2307 that there is no next record. So convert the absolute 1 based
2308 indices we've been carrying around into a displacement. */
2310 push_sleb128 (&crtl->eh.action_record_data, filter);
2311 if (next)
2312 next -= crtl->eh.action_record_data->length () + 1;
2313 push_sleb128 (&crtl->eh.action_record_data, next);
2316 return new_ar->offset;
2319 static int
2320 collect_one_action_chain (action_hash_type *ar_hash, eh_region region)
2322 int next;
2324 /* If we've reached the top of the region chain, then we have
2325 no actions, and require no landing pad. */
2326 if (region == NULL)
2327 return -1;
2329 switch (region->type)
2331 case ERT_CLEANUP:
2333 eh_region r;
2334 /* A cleanup adds a zero filter to the beginning of the chain, but
2335 there are special cases to look out for. If there are *only*
2336 cleanups along a path, then it compresses to a zero action.
2337 Further, if there are multiple cleanups along a path, we only
2338 need to represent one of them, as that is enough to trigger
2339 entry to the landing pad at runtime. */
2340 next = collect_one_action_chain (ar_hash, region->outer);
2341 if (next <= 0)
2342 return 0;
2343 for (r = region->outer; r ; r = r->outer)
2344 if (r->type == ERT_CLEANUP)
2345 return next;
2346 return add_action_record (ar_hash, 0, next);
2349 case ERT_TRY:
2351 eh_catch c;
2353 /* Process the associated catch regions in reverse order.
2354 If there's a catch-all handler, then we don't need to
2355 search outer regions. Use a magic -3 value to record
2356 that we haven't done the outer search. */
2357 next = -3;
2358 for (c = region->u.eh_try.last_catch; c ; c = c->prev_catch)
2360 if (c->type_list == NULL)
2362 /* Retrieve the filter from the head of the filter list
2363 where we have stored it (see assign_filter_values). */
2364 int filter = TREE_INT_CST_LOW (TREE_VALUE (c->filter_list));
2365 next = add_action_record (ar_hash, filter, 0);
2367 else
2369 /* Once the outer search is done, trigger an action record for
2370 each filter we have. */
2371 tree flt_node;
2373 if (next == -3)
2375 next = collect_one_action_chain (ar_hash, region->outer);
2377 /* If there is no next action, terminate the chain. */
2378 if (next == -1)
2379 next = 0;
2380 /* If all outer actions are cleanups or must_not_throw,
2381 we'll have no action record for it, since we had wanted
2382 to encode these states in the call-site record directly.
2383 Add a cleanup action to the chain to catch these. */
2384 else if (next <= 0)
2385 next = add_action_record (ar_hash, 0, 0);
2388 flt_node = c->filter_list;
2389 for (; flt_node; flt_node = TREE_CHAIN (flt_node))
2391 int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node));
2392 next = add_action_record (ar_hash, filter, next);
2396 return next;
2399 case ERT_ALLOWED_EXCEPTIONS:
2400 /* An exception specification adds its filter to the
2401 beginning of the chain. */
2402 next = collect_one_action_chain (ar_hash, region->outer);
2404 /* If there is no next action, terminate the chain. */
2405 if (next == -1)
2406 next = 0;
2407 /* If all outer actions are cleanups or must_not_throw,
2408 we'll have no action record for it, since we had wanted
2409 to encode these states in the call-site record directly.
2410 Add a cleanup action to the chain to catch these. */
2411 else if (next <= 0)
2412 next = add_action_record (ar_hash, 0, 0);
2414 return add_action_record (ar_hash, region->u.allowed.filter, next);
2416 case ERT_MUST_NOT_THROW:
2417 /* A must-not-throw region with no inner handlers or cleanups
2418 requires no call-site entry. Note that this differs from
2419 the no handler or cleanup case in that we do require an lsda
2420 to be generated. Return a magic -2 value to record this. */
2421 return -2;
2424 gcc_unreachable ();
2427 static int
2428 add_call_site (rtx landing_pad, int action, int section)
2430 call_site_record record;
2432 record = ggc_alloc<call_site_record_d> ();
2433 record->landing_pad = landing_pad;
2434 record->action = action;
2436 vec_safe_push (crtl->eh.call_site_record_v[section], record);
2438 return call_site_base + crtl->eh.call_site_record_v[section]->length () - 1;
2441 static rtx_note *
2442 emit_note_eh_region_end (rtx_insn *insn)
2444 rtx_insn *next = NEXT_INSN (insn);
2446 /* Make sure we do not split a call and its corresponding
2447 CALL_ARG_LOCATION note. */
2448 if (next && NOTE_P (next)
2449 && NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
2450 insn = next;
2452 return emit_note_after (NOTE_INSN_EH_REGION_END, insn);
2455 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2456 The new note numbers will not refer to region numbers, but
2457 instead to call site entries. */
2459 static unsigned int
2460 convert_to_eh_region_ranges (void)
2462 rtx insn;
2463 rtx_insn *iter;
2464 rtx_note *note;
2465 action_hash_type ar_hash (31);
2466 int last_action = -3;
2467 rtx_insn *last_action_insn = NULL;
2468 rtx last_landing_pad = NULL_RTX;
2469 rtx_insn *first_no_action_insn = NULL;
2470 int call_site = 0;
2471 int cur_sec = 0;
2472 rtx section_switch_note = NULL_RTX;
2473 rtx_insn *first_no_action_insn_before_switch = NULL;
2474 rtx_insn *last_no_action_insn_before_switch = NULL;
2475 int saved_call_site_base = call_site_base;
2477 vec_alloc (crtl->eh.action_record_data, 64);
2479 for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
2480 if (INSN_P (iter))
2482 eh_landing_pad lp;
2483 eh_region region;
2484 bool nothrow;
2485 int this_action;
2486 rtx this_landing_pad;
2488 insn = iter;
2489 if (NONJUMP_INSN_P (insn)
2490 && GET_CODE (PATTERN (insn)) == SEQUENCE)
2491 insn = XVECEXP (PATTERN (insn), 0, 0);
2493 nothrow = get_eh_region_and_lp_from_rtx (insn, &region, &lp);
2494 if (nothrow)
2495 continue;
2496 if (region)
2497 this_action = collect_one_action_chain (&ar_hash, region);
2498 else
2499 this_action = -1;
2501 /* Existence of catch handlers, or must-not-throw regions
2502 implies that an lsda is needed (even if empty). */
2503 if (this_action != -1)
2504 crtl->uses_eh_lsda = 1;
2506 /* Delay creation of region notes for no-action regions
2507 until we're sure that an lsda will be required. */
2508 else if (last_action == -3)
2510 first_no_action_insn = iter;
2511 last_action = -1;
2514 if (this_action >= 0)
2515 this_landing_pad = lp->landing_pad;
2516 else
2517 this_landing_pad = NULL_RTX;
2519 /* Differing actions or landing pads implies a change in call-site
2520 info, which implies some EH_REGION note should be emitted. */
2521 if (last_action != this_action
2522 || last_landing_pad != this_landing_pad)
2524 /* If there is a queued no-action region in the other section
2525 with hot/cold partitioning, emit it now. */
2526 if (first_no_action_insn_before_switch)
2528 gcc_assert (this_action != -1
2529 && last_action == (first_no_action_insn
2530 ? -1 : -3));
2531 call_site = add_call_site (NULL_RTX, 0, 0);
2532 note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
2533 first_no_action_insn_before_switch);
2534 NOTE_EH_HANDLER (note) = call_site;
2535 note
2536 = emit_note_eh_region_end (last_no_action_insn_before_switch);
2537 NOTE_EH_HANDLER (note) = call_site;
2538 gcc_assert (last_action != -3
2539 || (last_action_insn
2540 == last_no_action_insn_before_switch));
2541 first_no_action_insn_before_switch = NULL;
2542 last_no_action_insn_before_switch = NULL;
2543 call_site_base++;
2545 /* If we'd not seen a previous action (-3) or the previous
2546 action was must-not-throw (-2), then we do not need an
2547 end note. */
2548 if (last_action >= -1)
2550 /* If we delayed the creation of the begin, do it now. */
2551 if (first_no_action_insn)
2553 call_site = add_call_site (NULL_RTX, 0, cur_sec);
2554 note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
2555 first_no_action_insn);
2556 NOTE_EH_HANDLER (note) = call_site;
2557 first_no_action_insn = NULL;
2560 note = emit_note_eh_region_end (last_action_insn);
2561 NOTE_EH_HANDLER (note) = call_site;
2564 /* If the new action is must-not-throw, then no region notes
2565 are created. */
2566 if (this_action >= -1)
2568 call_site = add_call_site (this_landing_pad,
2569 this_action < 0 ? 0 : this_action,
2570 cur_sec);
2571 note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter);
2572 NOTE_EH_HANDLER (note) = call_site;
2575 last_action = this_action;
2576 last_landing_pad = this_landing_pad;
2578 last_action_insn = iter;
2580 else if (NOTE_P (iter)
2581 && NOTE_KIND (iter) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
2583 gcc_assert (section_switch_note == NULL_RTX);
2584 gcc_assert (flag_reorder_blocks_and_partition);
2585 section_switch_note = iter;
2586 if (first_no_action_insn)
2588 first_no_action_insn_before_switch = first_no_action_insn;
2589 last_no_action_insn_before_switch = last_action_insn;
2590 first_no_action_insn = NULL;
2591 gcc_assert (last_action == -1);
2592 last_action = -3;
2594 /* Force closing of current EH region before section switch and
2595 opening a new one afterwards. */
2596 else if (last_action != -3)
2597 last_landing_pad = pc_rtx;
2598 if (crtl->eh.call_site_record_v[cur_sec])
2599 call_site_base += crtl->eh.call_site_record_v[cur_sec]->length ();
2600 cur_sec++;
2601 gcc_assert (crtl->eh.call_site_record_v[cur_sec] == NULL);
2602 vec_alloc (crtl->eh.call_site_record_v[cur_sec], 10);
2605 if (last_action >= -1 && ! first_no_action_insn)
2607 note = emit_note_eh_region_end (last_action_insn);
2608 NOTE_EH_HANDLER (note) = call_site;
2611 call_site_base = saved_call_site_base;
2613 return 0;
2616 namespace {
2618 const pass_data pass_data_convert_to_eh_region_ranges =
2620 RTL_PASS, /* type */
2621 "eh_ranges", /* name */
2622 OPTGROUP_NONE, /* optinfo_flags */
2623 TV_NONE, /* tv_id */
2624 0, /* properties_required */
2625 0, /* properties_provided */
2626 0, /* properties_destroyed */
2627 0, /* todo_flags_start */
2628 0, /* todo_flags_finish */
2631 class pass_convert_to_eh_region_ranges : public rtl_opt_pass
2633 public:
2634 pass_convert_to_eh_region_ranges (gcc::context *ctxt)
2635 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges, ctxt)
2638 /* opt_pass methods: */
2639 virtual bool gate (function *);
2640 virtual unsigned int execute (function *)
2642 return convert_to_eh_region_ranges ();
2645 }; // class pass_convert_to_eh_region_ranges
2647 bool
2648 pass_convert_to_eh_region_ranges::gate (function *)
2650 /* Nothing to do for SJLJ exceptions or if no regions created. */
2651 if (cfun->eh->region_tree == NULL)
2652 return false;
2653 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
2654 return false;
2655 return true;
2658 } // anon namespace
2660 rtl_opt_pass *
2661 make_pass_convert_to_eh_region_ranges (gcc::context *ctxt)
2663 return new pass_convert_to_eh_region_ranges (ctxt);
2666 static void
2667 push_uleb128 (vec<uchar, va_gc> **data_area, unsigned int value)
2671 unsigned char byte = value & 0x7f;
2672 value >>= 7;
2673 if (value)
2674 byte |= 0x80;
2675 vec_safe_push (*data_area, byte);
2677 while (value);
2680 static void
2681 push_sleb128 (vec<uchar, va_gc> **data_area, int value)
2683 unsigned char byte;
2684 int more;
2688 byte = value & 0x7f;
2689 value >>= 7;
2690 more = ! ((value == 0 && (byte & 0x40) == 0)
2691 || (value == -1 && (byte & 0x40) != 0));
2692 if (more)
2693 byte |= 0x80;
2694 vec_safe_push (*data_area, byte);
2696 while (more);
2700 #ifndef HAVE_AS_LEB128
2701 static int
2702 dw2_size_of_call_site_table (int section)
2704 int n = vec_safe_length (crtl->eh.call_site_record_v[section]);
2705 int size = n * (4 + 4 + 4);
2706 int i;
2708 for (i = 0; i < n; ++i)
2710 struct call_site_record_d *cs =
2711 (*crtl->eh.call_site_record_v[section])[i];
2712 size += size_of_uleb128 (cs->action);
2715 return size;
2718 static int
2719 sjlj_size_of_call_site_table (void)
2721 int n = vec_safe_length (crtl->eh.call_site_record_v[0]);
2722 int size = 0;
2723 int i;
2725 for (i = 0; i < n; ++i)
2727 struct call_site_record_d *cs =
2728 (*crtl->eh.call_site_record_v[0])[i];
2729 size += size_of_uleb128 (INTVAL (cs->landing_pad));
2730 size += size_of_uleb128 (cs->action);
2733 return size;
2735 #endif
2737 static void
2738 dw2_output_call_site_table (int cs_format, int section)
2740 int n = vec_safe_length (crtl->eh.call_site_record_v[section]);
2741 int i;
2742 const char *begin;
2744 if (section == 0)
2745 begin = current_function_func_begin_label;
2746 else if (first_function_block_is_cold)
2747 begin = crtl->subsections.hot_section_label;
2748 else
2749 begin = crtl->subsections.cold_section_label;
2751 for (i = 0; i < n; ++i)
2753 struct call_site_record_d *cs = (*crtl->eh.call_site_record_v[section])[i];
2754 char reg_start_lab[32];
2755 char reg_end_lab[32];
2756 char landing_pad_lab[32];
2758 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab, "LEHB", call_site_base + i);
2759 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab, "LEHE", call_site_base + i);
2761 if (cs->landing_pad)
2762 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab, "L",
2763 CODE_LABEL_NUMBER (cs->landing_pad));
2765 /* ??? Perhaps use insn length scaling if the assembler supports
2766 generic arithmetic. */
2767 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2768 data4 if the function is small enough. */
2769 if (cs_format == DW_EH_PE_uleb128)
2771 dw2_asm_output_delta_uleb128 (reg_start_lab, begin,
2772 "region %d start", i);
2773 dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab,
2774 "length");
2775 if (cs->landing_pad)
2776 dw2_asm_output_delta_uleb128 (landing_pad_lab, begin,
2777 "landing pad");
2778 else
2779 dw2_asm_output_data_uleb128 (0, "landing pad");
2781 else
2783 dw2_asm_output_delta (4, reg_start_lab, begin,
2784 "region %d start", i);
2785 dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length");
2786 if (cs->landing_pad)
2787 dw2_asm_output_delta (4, landing_pad_lab, begin,
2788 "landing pad");
2789 else
2790 dw2_asm_output_data (4, 0, "landing pad");
2792 dw2_asm_output_data_uleb128 (cs->action, "action");
2795 call_site_base += n;
2798 static void
2799 sjlj_output_call_site_table (void)
2801 int n = vec_safe_length (crtl->eh.call_site_record_v[0]);
2802 int i;
2804 for (i = 0; i < n; ++i)
2806 struct call_site_record_d *cs = (*crtl->eh.call_site_record_v[0])[i];
2808 dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
2809 "region %d landing pad", i);
2810 dw2_asm_output_data_uleb128 (cs->action, "action");
2813 call_site_base += n;
2816 /* Switch to the section that should be used for exception tables. */
2818 static void
2819 switch_to_exception_section (const char * ARG_UNUSED (fnname))
2821 section *s;
2823 if (exception_section)
2824 s = exception_section;
2825 else
2827 /* Compute the section and cache it into exception_section,
2828 unless it depends on the function name. */
2829 if (targetm_common.have_named_sections)
2831 int flags;
2833 if (EH_TABLES_CAN_BE_READ_ONLY)
2835 int tt_format =
2836 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2837 flags = ((! flag_pic
2838 || ((tt_format & 0x70) != DW_EH_PE_absptr
2839 && (tt_format & 0x70) != DW_EH_PE_aligned))
2840 ? 0 : SECTION_WRITE);
2842 else
2843 flags = SECTION_WRITE;
2845 #ifdef HAVE_LD_EH_GC_SECTIONS
2846 if (flag_function_sections
2847 || (DECL_COMDAT_GROUP (current_function_decl) && HAVE_COMDAT_GROUP))
2849 char *section_name = XNEWVEC (char, strlen (fnname) + 32);
2850 /* The EH table must match the code section, so only mark
2851 it linkonce if we have COMDAT groups to tie them together. */
2852 if (DECL_COMDAT_GROUP (current_function_decl) && HAVE_COMDAT_GROUP)
2853 flags |= SECTION_LINKONCE;
2854 sprintf (section_name, ".gcc_except_table.%s", fnname);
2855 s = get_section (section_name, flags, current_function_decl);
2856 free (section_name);
2858 else
2859 #endif
2860 exception_section
2861 = s = get_section (".gcc_except_table", flags, NULL);
2863 else
2864 exception_section
2865 = s = flag_pic ? data_section : readonly_data_section;
2868 switch_to_section (s);
2872 /* Output a reference from an exception table to the type_info object TYPE.
2873 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2874 the value. */
2876 static void
2877 output_ttype (tree type, int tt_format, int tt_format_size)
2879 rtx value;
2880 bool is_public = true;
2882 if (type == NULL_TREE)
2883 value = const0_rtx;
2884 else
2886 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2887 runtime types so TYPE should already be a runtime type
2888 reference. When pass_ipa_free_lang data is made a default
2889 pass, we can then remove the call to lookup_type_for_runtime
2890 below. */
2891 if (TYPE_P (type))
2892 type = lookup_type_for_runtime (type);
2894 value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2896 /* Let cgraph know that the rtti decl is used. Not all of the
2897 paths below go through assemble_integer, which would take
2898 care of this for us. */
2899 STRIP_NOPS (type);
2900 if (TREE_CODE (type) == ADDR_EXPR)
2902 type = TREE_OPERAND (type, 0);
2903 if (TREE_CODE (type) == VAR_DECL)
2904 is_public = TREE_PUBLIC (type);
2906 else
2907 gcc_assert (TREE_CODE (type) == INTEGER_CST);
2910 /* Allow the target to override the type table entry format. */
2911 if (targetm.asm_out.ttype (value))
2912 return;
2914 if (tt_format == DW_EH_PE_absptr || tt_format == DW_EH_PE_aligned)
2915 assemble_integer (value, tt_format_size,
2916 tt_format_size * BITS_PER_UNIT, 1);
2917 else
2918 dw2_asm_output_encoded_addr_rtx (tt_format, value, is_public, NULL);
2921 static void
2922 output_one_function_exception_table (int section)
2924 int tt_format, cs_format, lp_format, i;
2925 #ifdef HAVE_AS_LEB128
2926 char ttype_label[32];
2927 char cs_after_size_label[32];
2928 char cs_end_label[32];
2929 #else
2930 int call_site_len;
2931 #endif
2932 int have_tt_data;
2933 int tt_format_size = 0;
2935 have_tt_data = (vec_safe_length (cfun->eh->ttype_data)
2936 || (targetm.arm_eabi_unwinder
2937 ? vec_safe_length (cfun->eh->ehspec_data.arm_eabi)
2938 : vec_safe_length (cfun->eh->ehspec_data.other)));
2940 /* Indicate the format of the @TType entries. */
2941 if (! have_tt_data)
2942 tt_format = DW_EH_PE_omit;
2943 else
2945 tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2946 #ifdef HAVE_AS_LEB128
2947 ASM_GENERATE_INTERNAL_LABEL (ttype_label,
2948 section ? "LLSDATTC" : "LLSDATT",
2949 current_function_funcdef_no);
2950 #endif
2951 tt_format_size = size_of_encoded_value (tt_format);
2953 assemble_align (tt_format_size * BITS_PER_UNIT);
2956 targetm.asm_out.internal_label (asm_out_file, section ? "LLSDAC" : "LLSDA",
2957 current_function_funcdef_no);
2959 /* The LSDA header. */
2961 /* Indicate the format of the landing pad start pointer. An omitted
2962 field implies @LPStart == @Start. */
2963 /* Currently we always put @LPStart == @Start. This field would
2964 be most useful in moving the landing pads completely out of
2965 line to another section, but it could also be used to minimize
2966 the size of uleb128 landing pad offsets. */
2967 lp_format = DW_EH_PE_omit;
2968 dw2_asm_output_data (1, lp_format, "@LPStart format (%s)",
2969 eh_data_format_name (lp_format));
2971 /* @LPStart pointer would go here. */
2973 dw2_asm_output_data (1, tt_format, "@TType format (%s)",
2974 eh_data_format_name (tt_format));
2976 #ifndef HAVE_AS_LEB128
2977 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
2978 call_site_len = sjlj_size_of_call_site_table ();
2979 else
2980 call_site_len = dw2_size_of_call_site_table (section);
2981 #endif
2983 /* A pc-relative 4-byte displacement to the @TType data. */
2984 if (have_tt_data)
2986 #ifdef HAVE_AS_LEB128
2987 char ttype_after_disp_label[32];
2988 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label,
2989 section ? "LLSDATTDC" : "LLSDATTD",
2990 current_function_funcdef_no);
2991 dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
2992 "@TType base offset");
2993 ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label);
2994 #else
2995 /* Ug. Alignment queers things. */
2996 unsigned int before_disp, after_disp, last_disp, disp;
2998 before_disp = 1 + 1;
2999 after_disp = (1 + size_of_uleb128 (call_site_len)
3000 + call_site_len
3001 + vec_safe_length (crtl->eh.action_record_data)
3002 + (vec_safe_length (cfun->eh->ttype_data)
3003 * tt_format_size));
3005 disp = after_disp;
3008 unsigned int disp_size, pad;
3010 last_disp = disp;
3011 disp_size = size_of_uleb128 (disp);
3012 pad = before_disp + disp_size + after_disp;
3013 if (pad % tt_format_size)
3014 pad = tt_format_size - (pad % tt_format_size);
3015 else
3016 pad = 0;
3017 disp = after_disp + pad;
3019 while (disp != last_disp);
3021 dw2_asm_output_data_uleb128 (disp, "@TType base offset");
3022 #endif
3025 /* Indicate the format of the call-site offsets. */
3026 #ifdef HAVE_AS_LEB128
3027 cs_format = DW_EH_PE_uleb128;
3028 #else
3029 cs_format = DW_EH_PE_udata4;
3030 #endif
3031 dw2_asm_output_data (1, cs_format, "call-site format (%s)",
3032 eh_data_format_name (cs_format));
3034 #ifdef HAVE_AS_LEB128
3035 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label,
3036 section ? "LLSDACSBC" : "LLSDACSB",
3037 current_function_funcdef_no);
3038 ASM_GENERATE_INTERNAL_LABEL (cs_end_label,
3039 section ? "LLSDACSEC" : "LLSDACSE",
3040 current_function_funcdef_no);
3041 dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label,
3042 "Call-site table length");
3043 ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label);
3044 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
3045 sjlj_output_call_site_table ();
3046 else
3047 dw2_output_call_site_table (cs_format, section);
3048 ASM_OUTPUT_LABEL (asm_out_file, cs_end_label);
3049 #else
3050 dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length");
3051 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
3052 sjlj_output_call_site_table ();
3053 else
3054 dw2_output_call_site_table (cs_format, section);
3055 #endif
3057 /* ??? Decode and interpret the data for flag_debug_asm. */
3059 uchar uc;
3060 FOR_EACH_VEC_ELT (*crtl->eh.action_record_data, i, uc)
3061 dw2_asm_output_data (1, uc, i ? NULL : "Action record table");
3064 if (have_tt_data)
3065 assemble_align (tt_format_size * BITS_PER_UNIT);
3067 i = vec_safe_length (cfun->eh->ttype_data);
3068 while (i-- > 0)
3070 tree type = (*cfun->eh->ttype_data)[i];
3071 output_ttype (type, tt_format, tt_format_size);
3074 #ifdef HAVE_AS_LEB128
3075 if (have_tt_data)
3076 ASM_OUTPUT_LABEL (asm_out_file, ttype_label);
3077 #endif
3079 /* ??? Decode and interpret the data for flag_debug_asm. */
3080 if (targetm.arm_eabi_unwinder)
3082 tree type;
3083 for (i = 0;
3084 vec_safe_iterate (cfun->eh->ehspec_data.arm_eabi, i, &type); ++i)
3085 output_ttype (type, tt_format, tt_format_size);
3087 else
3089 uchar uc;
3090 for (i = 0;
3091 vec_safe_iterate (cfun->eh->ehspec_data.other, i, &uc); ++i)
3092 dw2_asm_output_data (1, uc,
3093 i ? NULL : "Exception specification table");
3097 void
3098 output_function_exception_table (const char *fnname)
3100 rtx personality = get_personality_function (current_function_decl);
3102 /* Not all functions need anything. */
3103 if (! crtl->uses_eh_lsda)
3104 return;
3106 if (personality)
3108 assemble_external_libcall (personality);
3110 if (targetm.asm_out.emit_except_personality)
3111 targetm.asm_out.emit_except_personality (personality);
3114 switch_to_exception_section (fnname);
3116 /* If the target wants a label to begin the table, emit it here. */
3117 targetm.asm_out.emit_except_table_label (asm_out_file);
3119 output_one_function_exception_table (0);
3120 if (crtl->eh.call_site_record_v[1])
3121 output_one_function_exception_table (1);
3123 switch_to_section (current_function_section ());
3126 void
3127 set_eh_throw_stmt_table (function *fun, hash_map<gimple, int> *table)
3129 fun->eh->throw_stmt_table = table;
3132 hash_map<gimple, int> *
3133 get_eh_throw_stmt_table (struct function *fun)
3135 return fun->eh->throw_stmt_table;
3138 /* Determine if the function needs an EH personality function. */
3140 enum eh_personality_kind
3141 function_needs_eh_personality (struct function *fn)
3143 enum eh_personality_kind kind = eh_personality_none;
3144 eh_region i;
3146 FOR_ALL_EH_REGION_FN (i, fn)
3148 switch (i->type)
3150 case ERT_CLEANUP:
3151 /* Can do with any personality including the generic C one. */
3152 kind = eh_personality_any;
3153 break;
3155 case ERT_TRY:
3156 case ERT_ALLOWED_EXCEPTIONS:
3157 /* Always needs a EH personality function. The generic C
3158 personality doesn't handle these even for empty type lists. */
3159 return eh_personality_lang;
3161 case ERT_MUST_NOT_THROW:
3162 /* Always needs a EH personality function. The language may specify
3163 what abort routine that must be used, e.g. std::terminate. */
3164 return eh_personality_lang;
3168 return kind;
3171 /* Dump EH information to OUT. */
3173 void
3174 dump_eh_tree (FILE * out, struct function *fun)
3176 eh_region i;
3177 int depth = 0;
3178 static const char *const type_name[] = {
3179 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3182 i = fun->eh->region_tree;
3183 if (!i)
3184 return;
3186 fprintf (out, "Eh tree:\n");
3187 while (1)
3189 fprintf (out, " %*s %i %s", depth * 2, "",
3190 i->index, type_name[(int) i->type]);
3192 if (i->landing_pads)
3194 eh_landing_pad lp;
3196 fprintf (out, " land:");
3197 if (current_ir_type () == IR_GIMPLE)
3199 for (lp = i->landing_pads; lp ; lp = lp->next_lp)
3201 fprintf (out, "{%i,", lp->index);
3202 print_generic_expr (out, lp->post_landing_pad, 0);
3203 fputc ('}', out);
3204 if (lp->next_lp)
3205 fputc (',', out);
3208 else
3210 for (lp = i->landing_pads; lp ; lp = lp->next_lp)
3212 fprintf (out, "{%i,", lp->index);
3213 if (lp->landing_pad)
3214 fprintf (out, "%i%s,", INSN_UID (lp->landing_pad),
3215 NOTE_P (lp->landing_pad) ? "(del)" : "");
3216 else
3217 fprintf (out, "(nil),");
3218 if (lp->post_landing_pad)
3220 rtx lab = label_rtx (lp->post_landing_pad);
3221 fprintf (out, "%i%s}", INSN_UID (lab),
3222 NOTE_P (lab) ? "(del)" : "");
3224 else
3225 fprintf (out, "(nil)}");
3226 if (lp->next_lp)
3227 fputc (',', out);
3232 switch (i->type)
3234 case ERT_CLEANUP:
3235 case ERT_MUST_NOT_THROW:
3236 break;
3238 case ERT_TRY:
3240 eh_catch c;
3241 fprintf (out, " catch:");
3242 for (c = i->u.eh_try.first_catch; c; c = c->next_catch)
3244 fputc ('{', out);
3245 if (c->label)
3247 fprintf (out, "lab:");
3248 print_generic_expr (out, c->label, 0);
3249 fputc (';', out);
3251 print_generic_expr (out, c->type_list, 0);
3252 fputc ('}', out);
3253 if (c->next_catch)
3254 fputc (',', out);
3257 break;
3259 case ERT_ALLOWED_EXCEPTIONS:
3260 fprintf (out, " filter :%i types:", i->u.allowed.filter);
3261 print_generic_expr (out, i->u.allowed.type_list, 0);
3262 break;
3264 fputc ('\n', out);
3266 /* If there are sub-regions, process them. */
3267 if (i->inner)
3268 i = i->inner, depth++;
3269 /* If there are peers, process them. */
3270 else if (i->next_peer)
3271 i = i->next_peer;
3272 /* Otherwise, step back up the tree to the next peer. */
3273 else
3277 i = i->outer;
3278 depth--;
3279 if (i == NULL)
3280 return;
3282 while (i->next_peer == NULL);
3283 i = i->next_peer;
3288 /* Dump the EH tree for FN on stderr. */
3290 DEBUG_FUNCTION void
3291 debug_eh_tree (struct function *fn)
3293 dump_eh_tree (stderr, fn);
3296 /* Verify invariants on EH datastructures. */
3298 DEBUG_FUNCTION void
3299 verify_eh_tree (struct function *fun)
3301 eh_region r, outer;
3302 int nvisited_lp, nvisited_r;
3303 int count_lp, count_r, depth, i;
3304 eh_landing_pad lp;
3305 bool err = false;
3307 if (!fun->eh->region_tree)
3308 return;
3310 count_r = 0;
3311 for (i = 1; vec_safe_iterate (fun->eh->region_array, i, &r); ++i)
3312 if (r)
3314 if (r->index == i)
3315 count_r++;
3316 else
3318 error ("region_array is corrupted for region %i", r->index);
3319 err = true;
3323 count_lp = 0;
3324 for (i = 1; vec_safe_iterate (fun->eh->lp_array, i, &lp); ++i)
3325 if (lp)
3327 if (lp->index == i)
3328 count_lp++;
3329 else
3331 error ("lp_array is corrupted for lp %i", lp->index);
3332 err = true;
3336 depth = nvisited_lp = nvisited_r = 0;
3337 outer = NULL;
3338 r = fun->eh->region_tree;
3339 while (1)
3341 if ((*fun->eh->region_array)[r->index] != r)
3343 error ("region_array is corrupted for region %i", r->index);
3344 err = true;
3346 if (r->outer != outer)
3348 error ("outer block of region %i is wrong", r->index);
3349 err = true;
3351 if (depth < 0)
3353 error ("negative nesting depth of region %i", r->index);
3354 err = true;
3356 nvisited_r++;
3358 for (lp = r->landing_pads; lp ; lp = lp->next_lp)
3360 if ((*fun->eh->lp_array)[lp->index] != lp)
3362 error ("lp_array is corrupted for lp %i", lp->index);
3363 err = true;
3365 if (lp->region != r)
3367 error ("region of lp %i is wrong", lp->index);
3368 err = true;
3370 nvisited_lp++;
3373 if (r->inner)
3374 outer = r, r = r->inner, depth++;
3375 else if (r->next_peer)
3376 r = r->next_peer;
3377 else
3381 r = r->outer;
3382 if (r == NULL)
3383 goto region_done;
3384 depth--;
3385 outer = r->outer;
3387 while (r->next_peer == NULL);
3388 r = r->next_peer;
3391 region_done:
3392 if (depth != 0)
3394 error ("tree list ends on depth %i", depth);
3395 err = true;
3397 if (count_r != nvisited_r)
3399 error ("region_array does not match region_tree");
3400 err = true;
3402 if (count_lp != nvisited_lp)
3404 error ("lp_array does not match region_tree");
3405 err = true;
3408 if (err)
3410 dump_eh_tree (stderr, fun);
3411 internal_error ("verify_eh_tree failed");
3415 #include "gt-except.h"