Daily bump.
[official-gcc.git] / gcc / except.c
blob6288eb00fc24b6c86332ba65bbf5f22f98e482ca
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 "hashtab.h"
122 #include "hash-set.h"
123 #include "vec.h"
124 #include "machmode.h"
125 #include "hard-reg-set.h"
126 #include "input.h"
127 #include "function.h"
128 #include "insn-codes.h"
129 #include "optabs.h"
130 #include "expr.h"
131 #include "libfuncs.h"
132 #include "insn-config.h"
133 #include "except.h"
134 #include "output.h"
135 #include "dwarf2asm.h"
136 #include "dwarf2out.h"
137 #include "dwarf2.h"
138 #include "toplev.h"
139 #include "hash-table.h"
140 #include "intl.h"
141 #include "tm_p.h"
142 #include "target.h"
143 #include "common/common-target.h"
144 #include "langhooks.h"
145 #include "predict.h"
146 #include "dominance.h"
147 #include "cfg.h"
148 #include "cfgrtl.h"
149 #include "basic-block.h"
150 #include "hash-map.h"
151 #include "is-a.h"
152 #include "plugin-api.h"
153 #include "ipa-ref.h"
154 #include "cgraph.h"
155 #include "diagnostic.h"
156 #include "tree-pretty-print.h"
157 #include "tree-pass.h"
158 #include "cfgloop.h"
159 #include "builtins.h"
161 /* Provide defaults for stuff that may not be defined when using
162 sjlj exceptions. */
163 #ifndef EH_RETURN_DATA_REGNO
164 #define EH_RETURN_DATA_REGNO(N) INVALID_REGNUM
165 #endif
167 static GTY(()) int call_site_base;
169 struct tree_hash_traits : default_hashmap_traits
171 static hashval_t hash (tree t) { return TREE_HASH (t); }
174 static GTY (()) hash_map<tree, tree, tree_hash_traits> *type_to_runtime_map;
176 /* Describe the SjLj_Function_Context structure. */
177 static GTY(()) tree sjlj_fc_type_node;
178 static int sjlj_fc_call_site_ofs;
179 static int sjlj_fc_data_ofs;
180 static int sjlj_fc_personality_ofs;
181 static int sjlj_fc_lsda_ofs;
182 static int sjlj_fc_jbuf_ofs;
185 struct GTY(()) call_site_record_d
187 rtx landing_pad;
188 int action;
191 /* In the following structure and associated functions,
192 we represent entries in the action table as 1-based indices.
193 Special cases are:
195 0: null action record, non-null landing pad; implies cleanups
196 -1: null action record, null landing pad; implies no action
197 -2: no call-site entry; implies must_not_throw
198 -3: we have yet to process outer regions
200 Further, no special cases apply to the "next" field of the record.
201 For next, 0 means end of list. */
203 struct action_record
205 int offset;
206 int filter;
207 int next;
210 /* Hashtable helpers. */
212 struct action_record_hasher : typed_free_remove <action_record>
214 typedef action_record value_type;
215 typedef action_record compare_type;
216 static inline hashval_t hash (const value_type *);
217 static inline bool equal (const value_type *, const compare_type *);
220 inline hashval_t
221 action_record_hasher::hash (const value_type *entry)
223 return entry->next * 1009 + entry->filter;
226 inline bool
227 action_record_hasher::equal (const value_type *entry, const compare_type *data)
229 return entry->filter == data->filter && entry->next == data->next;
232 typedef hash_table<action_record_hasher> action_hash_type;
234 static bool get_eh_region_and_lp_from_rtx (const_rtx, eh_region *,
235 eh_landing_pad *);
237 static void dw2_build_landing_pads (void);
239 static int collect_one_action_chain (action_hash_type *, eh_region);
240 static int add_call_site (rtx, int, int);
242 static void push_uleb128 (vec<uchar, va_gc> **, unsigned int);
243 static void push_sleb128 (vec<uchar, va_gc> **, int);
244 #ifndef HAVE_AS_LEB128
245 static int dw2_size_of_call_site_table (int);
246 static int sjlj_size_of_call_site_table (void);
247 #endif
248 static void dw2_output_call_site_table (int, int);
249 static void sjlj_output_call_site_table (void);
252 void
253 init_eh (void)
255 if (! flag_exceptions)
256 return;
258 type_to_runtime_map
259 = hash_map<tree, tree, tree_hash_traits>::create_ggc (31);
261 /* Create the SjLj_Function_Context structure. This should match
262 the definition in unwind-sjlj.c. */
263 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
265 tree f_jbuf, f_per, f_lsda, f_prev, f_cs, f_data, tmp;
267 sjlj_fc_type_node = lang_hooks.types.make_type (RECORD_TYPE);
269 f_prev = build_decl (BUILTINS_LOCATION,
270 FIELD_DECL, get_identifier ("__prev"),
271 build_pointer_type (sjlj_fc_type_node));
272 DECL_FIELD_CONTEXT (f_prev) = sjlj_fc_type_node;
274 f_cs = build_decl (BUILTINS_LOCATION,
275 FIELD_DECL, get_identifier ("__call_site"),
276 integer_type_node);
277 DECL_FIELD_CONTEXT (f_cs) = sjlj_fc_type_node;
279 tmp = build_index_type (size_int (4 - 1));
280 tmp = build_array_type (lang_hooks.types.type_for_mode
281 (targetm.unwind_word_mode (), 1),
282 tmp);
283 f_data = build_decl (BUILTINS_LOCATION,
284 FIELD_DECL, get_identifier ("__data"), tmp);
285 DECL_FIELD_CONTEXT (f_data) = sjlj_fc_type_node;
287 f_per = build_decl (BUILTINS_LOCATION,
288 FIELD_DECL, get_identifier ("__personality"),
289 ptr_type_node);
290 DECL_FIELD_CONTEXT (f_per) = sjlj_fc_type_node;
292 f_lsda = build_decl (BUILTINS_LOCATION,
293 FIELD_DECL, get_identifier ("__lsda"),
294 ptr_type_node);
295 DECL_FIELD_CONTEXT (f_lsda) = sjlj_fc_type_node;
297 #ifdef DONT_USE_BUILTIN_SETJMP
298 #ifdef JMP_BUF_SIZE
299 tmp = size_int (JMP_BUF_SIZE - 1);
300 #else
301 /* Should be large enough for most systems, if it is not,
302 JMP_BUF_SIZE should be defined with the proper value. It will
303 also tend to be larger than necessary for most systems, a more
304 optimal port will define JMP_BUF_SIZE. */
305 tmp = size_int (FIRST_PSEUDO_REGISTER + 2 - 1);
306 #endif
307 #else
308 /* Compute a minimally sized jump buffer. We need room to store at
309 least 3 pointers - stack pointer, frame pointer and return address.
310 Plus for some targets we need room for an extra pointer - in the
311 case of MIPS this is the global pointer. This makes a total of four
312 pointers, but to be safe we actually allocate room for 5.
314 If pointers are smaller than words then we allocate enough room for
315 5 words, just in case the backend needs this much room. For more
316 discussion on this issue see:
317 http://gcc.gnu.org/ml/gcc-patches/2014-05/msg00313.html. */
318 if (POINTER_SIZE > BITS_PER_WORD)
319 tmp = size_int (5 - 1);
320 else
321 tmp = size_int ((5 * BITS_PER_WORD / POINTER_SIZE) - 1);
322 #endif
324 tmp = build_index_type (tmp);
325 tmp = build_array_type (ptr_type_node, tmp);
326 f_jbuf = build_decl (BUILTINS_LOCATION,
327 FIELD_DECL, get_identifier ("__jbuf"), tmp);
328 #ifdef DONT_USE_BUILTIN_SETJMP
329 /* We don't know what the alignment requirements of the
330 runtime's jmp_buf has. Overestimate. */
331 DECL_ALIGN (f_jbuf) = BIGGEST_ALIGNMENT;
332 DECL_USER_ALIGN (f_jbuf) = 1;
333 #endif
334 DECL_FIELD_CONTEXT (f_jbuf) = sjlj_fc_type_node;
336 TYPE_FIELDS (sjlj_fc_type_node) = f_prev;
337 TREE_CHAIN (f_prev) = f_cs;
338 TREE_CHAIN (f_cs) = f_data;
339 TREE_CHAIN (f_data) = f_per;
340 TREE_CHAIN (f_per) = f_lsda;
341 TREE_CHAIN (f_lsda) = f_jbuf;
343 layout_type (sjlj_fc_type_node);
345 /* Cache the interesting field offsets so that we have
346 easy access from rtl. */
347 sjlj_fc_call_site_ofs
348 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_cs))
349 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_cs)) / BITS_PER_UNIT);
350 sjlj_fc_data_ofs
351 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_data))
352 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_data)) / BITS_PER_UNIT);
353 sjlj_fc_personality_ofs
354 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_per))
355 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_per)) / BITS_PER_UNIT);
356 sjlj_fc_lsda_ofs
357 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_lsda))
358 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_lsda)) / BITS_PER_UNIT);
359 sjlj_fc_jbuf_ofs
360 = (tree_to_uhwi (DECL_FIELD_OFFSET (f_jbuf))
361 + tree_to_uhwi (DECL_FIELD_BIT_OFFSET (f_jbuf)) / BITS_PER_UNIT);
365 void
366 init_eh_for_function (void)
368 cfun->eh = ggc_cleared_alloc<eh_status> ();
370 /* Make sure zero'th entries are used. */
371 vec_safe_push (cfun->eh->region_array, (eh_region)0);
372 vec_safe_push (cfun->eh->lp_array, (eh_landing_pad)0);
375 /* Routines to generate the exception tree somewhat directly.
376 These are used from tree-eh.c when processing exception related
377 nodes during tree optimization. */
379 static eh_region
380 gen_eh_region (enum eh_region_type type, eh_region outer)
382 eh_region new_eh;
384 /* Insert a new blank region as a leaf in the tree. */
385 new_eh = ggc_cleared_alloc<eh_region_d> ();
386 new_eh->type = type;
387 new_eh->outer = outer;
388 if (outer)
390 new_eh->next_peer = outer->inner;
391 outer->inner = new_eh;
393 else
395 new_eh->next_peer = cfun->eh->region_tree;
396 cfun->eh->region_tree = new_eh;
399 new_eh->index = vec_safe_length (cfun->eh->region_array);
400 vec_safe_push (cfun->eh->region_array, new_eh);
402 /* Copy the language's notion of whether to use __cxa_end_cleanup. */
403 if (targetm.arm_eabi_unwinder && lang_hooks.eh_use_cxa_end_cleanup)
404 new_eh->use_cxa_end_cleanup = true;
406 return new_eh;
409 eh_region
410 gen_eh_region_cleanup (eh_region outer)
412 return gen_eh_region (ERT_CLEANUP, outer);
415 eh_region
416 gen_eh_region_try (eh_region outer)
418 return gen_eh_region (ERT_TRY, outer);
421 eh_catch
422 gen_eh_region_catch (eh_region t, tree type_or_list)
424 eh_catch c, l;
425 tree type_list, type_node;
427 gcc_assert (t->type == ERT_TRY);
429 /* Ensure to always end up with a type list to normalize further
430 processing, then register each type against the runtime types map. */
431 type_list = type_or_list;
432 if (type_or_list)
434 if (TREE_CODE (type_or_list) != TREE_LIST)
435 type_list = tree_cons (NULL_TREE, type_or_list, NULL_TREE);
437 type_node = type_list;
438 for (; type_node; type_node = TREE_CHAIN (type_node))
439 add_type_for_runtime (TREE_VALUE (type_node));
442 c = ggc_cleared_alloc<eh_catch_d> ();
443 c->type_list = type_list;
444 l = t->u.eh_try.last_catch;
445 c->prev_catch = l;
446 if (l)
447 l->next_catch = c;
448 else
449 t->u.eh_try.first_catch = c;
450 t->u.eh_try.last_catch = c;
452 return c;
455 eh_region
456 gen_eh_region_allowed (eh_region outer, tree allowed)
458 eh_region region = gen_eh_region (ERT_ALLOWED_EXCEPTIONS, outer);
459 region->u.allowed.type_list = allowed;
461 for (; allowed ; allowed = TREE_CHAIN (allowed))
462 add_type_for_runtime (TREE_VALUE (allowed));
464 return region;
467 eh_region
468 gen_eh_region_must_not_throw (eh_region outer)
470 return gen_eh_region (ERT_MUST_NOT_THROW, outer);
473 eh_landing_pad
474 gen_eh_landing_pad (eh_region region)
476 eh_landing_pad lp = ggc_cleared_alloc<eh_landing_pad_d> ();
478 lp->next_lp = region->landing_pads;
479 lp->region = region;
480 lp->index = vec_safe_length (cfun->eh->lp_array);
481 region->landing_pads = lp;
483 vec_safe_push (cfun->eh->lp_array, lp);
485 return lp;
488 eh_region
489 get_eh_region_from_number_fn (struct function *ifun, int i)
491 return (*ifun->eh->region_array)[i];
494 eh_region
495 get_eh_region_from_number (int i)
497 return get_eh_region_from_number_fn (cfun, i);
500 eh_landing_pad
501 get_eh_landing_pad_from_number_fn (struct function *ifun, int i)
503 return (*ifun->eh->lp_array)[i];
506 eh_landing_pad
507 get_eh_landing_pad_from_number (int i)
509 return get_eh_landing_pad_from_number_fn (cfun, i);
512 eh_region
513 get_eh_region_from_lp_number_fn (struct function *ifun, int i)
515 if (i < 0)
516 return (*ifun->eh->region_array)[-i];
517 else if (i == 0)
518 return NULL;
519 else
521 eh_landing_pad lp;
522 lp = (*ifun->eh->lp_array)[i];
523 return lp->region;
527 eh_region
528 get_eh_region_from_lp_number (int i)
530 return get_eh_region_from_lp_number_fn (cfun, i);
533 /* Returns true if the current function has exception handling regions. */
535 bool
536 current_function_has_exception_handlers (void)
538 return cfun->eh->region_tree != NULL;
541 /* A subroutine of duplicate_eh_regions. Copy the eh_region tree at OLD.
542 Root it at OUTER, and apply LP_OFFSET to the lp numbers. */
544 struct duplicate_eh_regions_data
546 duplicate_eh_regions_map label_map;
547 void *label_map_data;
548 hash_map<void *, void *> *eh_map;
551 static void
552 duplicate_eh_regions_1 (struct duplicate_eh_regions_data *data,
553 eh_region old_r, eh_region outer)
555 eh_landing_pad old_lp, new_lp;
556 eh_region new_r;
558 new_r = gen_eh_region (old_r->type, outer);
559 gcc_assert (!data->eh_map->put (old_r, new_r));
561 switch (old_r->type)
563 case ERT_CLEANUP:
564 break;
566 case ERT_TRY:
568 eh_catch oc, nc;
569 for (oc = old_r->u.eh_try.first_catch; oc ; oc = oc->next_catch)
571 /* We should be doing all our region duplication before and
572 during inlining, which is before filter lists are created. */
573 gcc_assert (oc->filter_list == NULL);
574 nc = gen_eh_region_catch (new_r, oc->type_list);
575 nc->label = data->label_map (oc->label, data->label_map_data);
578 break;
580 case ERT_ALLOWED_EXCEPTIONS:
581 new_r->u.allowed.type_list = old_r->u.allowed.type_list;
582 if (old_r->u.allowed.label)
583 new_r->u.allowed.label
584 = data->label_map (old_r->u.allowed.label, data->label_map_data);
585 else
586 new_r->u.allowed.label = NULL_TREE;
587 break;
589 case ERT_MUST_NOT_THROW:
590 new_r->u.must_not_throw.failure_loc =
591 LOCATION_LOCUS (old_r->u.must_not_throw.failure_loc);
592 new_r->u.must_not_throw.failure_decl =
593 old_r->u.must_not_throw.failure_decl;
594 break;
597 for (old_lp = old_r->landing_pads; old_lp ; old_lp = old_lp->next_lp)
599 /* Don't bother copying unused landing pads. */
600 if (old_lp->post_landing_pad == NULL)
601 continue;
603 new_lp = gen_eh_landing_pad (new_r);
604 gcc_assert (!data->eh_map->put (old_lp, new_lp));
606 new_lp->post_landing_pad
607 = data->label_map (old_lp->post_landing_pad, data->label_map_data);
608 EH_LANDING_PAD_NR (new_lp->post_landing_pad) = new_lp->index;
611 /* Make sure to preserve the original use of __cxa_end_cleanup. */
612 new_r->use_cxa_end_cleanup = old_r->use_cxa_end_cleanup;
614 for (old_r = old_r->inner; old_r ; old_r = old_r->next_peer)
615 duplicate_eh_regions_1 (data, old_r, new_r);
618 /* Duplicate the EH regions from IFUN rooted at COPY_REGION into
619 the current function and root the tree below OUTER_REGION.
620 The special case of COPY_REGION of NULL means all regions.
621 Remap labels using MAP/MAP_DATA callback. Return a pointer map
622 that allows the caller to remap uses of both EH regions and
623 EH landing pads. */
625 hash_map<void *, void *> *
626 duplicate_eh_regions (struct function *ifun,
627 eh_region copy_region, int outer_lp,
628 duplicate_eh_regions_map map, void *map_data)
630 struct duplicate_eh_regions_data data;
631 eh_region outer_region;
633 #ifdef ENABLE_CHECKING
634 verify_eh_tree (ifun);
635 #endif
637 data.label_map = map;
638 data.label_map_data = map_data;
639 data.eh_map = new hash_map<void *, void *>;
641 outer_region = get_eh_region_from_lp_number (outer_lp);
643 /* Copy all the regions in the subtree. */
644 if (copy_region)
645 duplicate_eh_regions_1 (&data, copy_region, outer_region);
646 else
648 eh_region r;
649 for (r = ifun->eh->region_tree; r ; r = r->next_peer)
650 duplicate_eh_regions_1 (&data, r, outer_region);
653 #ifdef ENABLE_CHECKING
654 verify_eh_tree (cfun);
655 #endif
657 return data.eh_map;
660 /* Return the region that is outer to both REGION_A and REGION_B in IFUN. */
662 eh_region
663 eh_region_outermost (struct function *ifun, eh_region region_a,
664 eh_region region_b)
666 sbitmap b_outer;
668 gcc_assert (ifun->eh->region_array);
669 gcc_assert (ifun->eh->region_tree);
671 b_outer = sbitmap_alloc (ifun->eh->region_array->length ());
672 bitmap_clear (b_outer);
676 bitmap_set_bit (b_outer, region_b->index);
677 region_b = region_b->outer;
679 while (region_b);
683 if (bitmap_bit_p (b_outer, region_a->index))
684 break;
685 region_a = region_a->outer;
687 while (region_a);
689 sbitmap_free (b_outer);
690 return region_a;
693 void
694 add_type_for_runtime (tree type)
696 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
697 if (TREE_CODE (type) == NOP_EXPR)
698 return;
700 bool existed = false;
701 tree *slot = &type_to_runtime_map->get_or_insert (type, &existed);
702 if (!existed)
703 *slot = lang_hooks.eh_runtime_type (type);
706 tree
707 lookup_type_for_runtime (tree type)
709 /* If TYPE is NOP_EXPR, it means that it already is a runtime type. */
710 if (TREE_CODE (type) == NOP_EXPR)
711 return type;
713 /* We should have always inserted the data earlier. */
714 return *type_to_runtime_map->get (type);
718 /* Represent an entry in @TTypes for either catch actions
719 or exception filter actions. */
720 struct ttypes_filter {
721 tree t;
722 int filter;
725 /* Helper for ttypes_filter hashing. */
727 struct ttypes_filter_hasher : typed_free_remove <ttypes_filter>
729 typedef ttypes_filter value_type;
730 typedef tree_node compare_type;
731 static inline hashval_t hash (const value_type *);
732 static inline bool equal (const value_type *, const compare_type *);
735 /* Compare ENTRY (a ttypes_filter entry in the hash table) with DATA
736 (a tree) for a @TTypes type node we are thinking about adding. */
738 inline bool
739 ttypes_filter_hasher::equal (const value_type *entry, const compare_type *data)
741 return entry->t == data;
744 inline hashval_t
745 ttypes_filter_hasher::hash (const value_type *entry)
747 return TREE_HASH (entry->t);
750 typedef hash_table<ttypes_filter_hasher> ttypes_hash_type;
753 /* Helper for ehspec hashing. */
755 struct ehspec_hasher : typed_free_remove <ttypes_filter>
757 typedef ttypes_filter value_type;
758 typedef ttypes_filter compare_type;
759 static inline hashval_t hash (const value_type *);
760 static inline bool equal (const value_type *, const compare_type *);
763 /* Compare ENTRY with DATA (both struct ttypes_filter) for a @TTypes
764 exception specification list we are thinking about adding. */
765 /* ??? Currently we use the type lists in the order given. Someone
766 should put these in some canonical order. */
768 inline bool
769 ehspec_hasher::equal (const value_type *entry, const compare_type *data)
771 return type_list_equal (entry->t, data->t);
774 /* Hash function for exception specification lists. */
776 inline hashval_t
777 ehspec_hasher::hash (const value_type *entry)
779 hashval_t h = 0;
780 tree list;
782 for (list = entry->t; list ; list = TREE_CHAIN (list))
783 h = (h << 5) + (h >> 27) + TREE_HASH (TREE_VALUE (list));
784 return h;
787 typedef hash_table<ehspec_hasher> ehspec_hash_type;
790 /* Add TYPE (which may be NULL) to cfun->eh->ttype_data, using TYPES_HASH
791 to speed up the search. Return the filter value to be used. */
793 static int
794 add_ttypes_entry (ttypes_hash_type *ttypes_hash, tree type)
796 struct ttypes_filter **slot, *n;
798 slot = ttypes_hash->find_slot_with_hash (type, (hashval_t) TREE_HASH (type),
799 INSERT);
801 if ((n = *slot) == NULL)
803 /* Filter value is a 1 based table index. */
805 n = XNEW (struct ttypes_filter);
806 n->t = type;
807 n->filter = vec_safe_length (cfun->eh->ttype_data) + 1;
808 *slot = n;
810 vec_safe_push (cfun->eh->ttype_data, type);
813 return n->filter;
816 /* Add LIST to cfun->eh->ehspec_data, using EHSPEC_HASH and TYPES_HASH
817 to speed up the search. Return the filter value to be used. */
819 static int
820 add_ehspec_entry (ehspec_hash_type *ehspec_hash, ttypes_hash_type *ttypes_hash,
821 tree list)
823 struct ttypes_filter **slot, *n;
824 struct ttypes_filter dummy;
826 dummy.t = list;
827 slot = ehspec_hash->find_slot (&dummy, INSERT);
829 if ((n = *slot) == NULL)
831 int len;
833 if (targetm.arm_eabi_unwinder)
834 len = vec_safe_length (cfun->eh->ehspec_data.arm_eabi);
835 else
836 len = vec_safe_length (cfun->eh->ehspec_data.other);
838 /* Filter value is a -1 based byte index into a uleb128 buffer. */
840 n = XNEW (struct ttypes_filter);
841 n->t = list;
842 n->filter = -(len + 1);
843 *slot = n;
845 /* Generate a 0 terminated list of filter values. */
846 for (; list ; list = TREE_CHAIN (list))
848 if (targetm.arm_eabi_unwinder)
849 vec_safe_push (cfun->eh->ehspec_data.arm_eabi, TREE_VALUE (list));
850 else
852 /* Look up each type in the list and encode its filter
853 value as a uleb128. */
854 push_uleb128 (&cfun->eh->ehspec_data.other,
855 add_ttypes_entry (ttypes_hash, TREE_VALUE (list)));
858 if (targetm.arm_eabi_unwinder)
859 vec_safe_push (cfun->eh->ehspec_data.arm_eabi, NULL_TREE);
860 else
861 vec_safe_push (cfun->eh->ehspec_data.other, (uchar)0);
864 return n->filter;
867 /* Generate the action filter values to be used for CATCH and
868 ALLOWED_EXCEPTIONS regions. When using dwarf2 exception regions,
869 we use lots of landing pads, and so every type or list can share
870 the same filter value, which saves table space. */
872 void
873 assign_filter_values (void)
875 int i;
876 eh_region r;
877 eh_catch c;
879 vec_alloc (cfun->eh->ttype_data, 16);
880 if (targetm.arm_eabi_unwinder)
881 vec_alloc (cfun->eh->ehspec_data.arm_eabi, 64);
882 else
883 vec_alloc (cfun->eh->ehspec_data.other, 64);
885 ehspec_hash_type ehspec (31);
886 ttypes_hash_type ttypes (31);
888 for (i = 1; vec_safe_iterate (cfun->eh->region_array, i, &r); ++i)
890 if (r == NULL)
891 continue;
893 switch (r->type)
895 case ERT_TRY:
896 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
898 /* Whatever type_list is (NULL or true list), we build a list
899 of filters for the region. */
900 c->filter_list = NULL_TREE;
902 if (c->type_list != NULL)
904 /* Get a filter value for each of the types caught and store
905 them in the region's dedicated list. */
906 tree tp_node = c->type_list;
908 for ( ; tp_node; tp_node = TREE_CHAIN (tp_node))
910 int flt
911 = add_ttypes_entry (&ttypes, TREE_VALUE (tp_node));
912 tree flt_node = build_int_cst (integer_type_node, flt);
914 c->filter_list
915 = tree_cons (NULL_TREE, flt_node, c->filter_list);
918 else
920 /* Get a filter value for the NULL list also since it
921 will need an action record anyway. */
922 int flt = add_ttypes_entry (&ttypes, NULL);
923 tree flt_node = build_int_cst (integer_type_node, flt);
925 c->filter_list
926 = tree_cons (NULL_TREE, flt_node, NULL);
929 break;
931 case ERT_ALLOWED_EXCEPTIONS:
932 r->u.allowed.filter
933 = add_ehspec_entry (&ehspec, &ttypes, r->u.allowed.type_list);
934 break;
936 default:
937 break;
942 /* Emit SEQ into basic block just before INSN (that is assumed to be
943 first instruction of some existing BB and return the newly
944 produced block. */
945 static basic_block
946 emit_to_new_bb_before (rtx_insn *seq, rtx insn)
948 rtx_insn *last;
949 basic_block bb;
950 edge e;
951 edge_iterator ei;
953 /* If there happens to be a fallthru edge (possibly created by cleanup_cfg
954 call), we don't want it to go into newly created landing pad or other EH
955 construct. */
956 for (ei = ei_start (BLOCK_FOR_INSN (insn)->preds); (e = ei_safe_edge (ei)); )
957 if (e->flags & EDGE_FALLTHRU)
958 force_nonfallthru (e);
959 else
960 ei_next (&ei);
961 last = emit_insn_before (seq, insn);
962 if (BARRIER_P (last))
963 last = PREV_INSN (last);
964 bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);
965 update_bb_for_insn (bb);
966 bb->flags |= BB_SUPERBLOCK;
967 return bb;
970 /* A subroutine of dw2_build_landing_pads, also used for edge splitting
971 at the rtl level. Emit the code required by the target at a landing
972 pad for the given region. */
974 void
975 expand_dw2_landing_pad_for_region (eh_region region)
977 #ifdef HAVE_exception_receiver
978 if (HAVE_exception_receiver)
979 emit_insn (gen_exception_receiver ());
980 else
981 #endif
982 #ifdef HAVE_nonlocal_goto_receiver
983 if (HAVE_nonlocal_goto_receiver)
984 emit_insn (gen_nonlocal_goto_receiver ());
985 else
986 #endif
987 { /* Nothing */ }
989 if (region->exc_ptr_reg)
990 emit_move_insn (region->exc_ptr_reg,
991 gen_rtx_REG (ptr_mode, EH_RETURN_DATA_REGNO (0)));
992 if (region->filter_reg)
993 emit_move_insn (region->filter_reg,
994 gen_rtx_REG (targetm.eh_return_filter_mode (),
995 EH_RETURN_DATA_REGNO (1)));
998 /* Expand the extra code needed at landing pads for dwarf2 unwinding. */
1000 static void
1001 dw2_build_landing_pads (void)
1003 int i;
1004 eh_landing_pad lp;
1005 int e_flags = EDGE_FALLTHRU;
1007 /* If we're going to partition blocks, we need to be able to add
1008 new landing pads later, which means that we need to hold on to
1009 the post-landing-pad block. Prevent it from being merged away.
1010 We'll remove this bit after partitioning. */
1011 if (flag_reorder_blocks_and_partition)
1012 e_flags |= EDGE_PRESERVE;
1014 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1016 basic_block bb;
1017 rtx_insn *seq;
1018 edge e;
1020 if (lp == NULL || lp->post_landing_pad == NULL)
1021 continue;
1023 start_sequence ();
1025 lp->landing_pad = gen_label_rtx ();
1026 emit_label (lp->landing_pad);
1027 LABEL_PRESERVE_P (lp->landing_pad) = 1;
1029 expand_dw2_landing_pad_for_region (lp->region);
1031 seq = get_insns ();
1032 end_sequence ();
1034 bb = emit_to_new_bb_before (seq, label_rtx (lp->post_landing_pad));
1035 e = make_edge (bb, bb->next_bb, e_flags);
1036 e->count = bb->count;
1037 e->probability = REG_BR_PROB_BASE;
1038 if (current_loops)
1040 struct loop *loop = bb->next_bb->loop_father;
1041 /* If we created a pre-header block, add the new block to the
1042 outer loop, otherwise to the loop itself. */
1043 if (bb->next_bb == loop->header)
1044 add_bb_to_loop (bb, loop_outer (loop));
1045 else
1046 add_bb_to_loop (bb, loop);
1052 static vec<int> sjlj_lp_call_site_index;
1054 /* Process all active landing pads. Assign each one a compact dispatch
1055 index, and a call-site index. */
1057 static int
1058 sjlj_assign_call_site_values (void)
1060 action_hash_type ar_hash (31);
1061 int i, disp_index;
1062 eh_landing_pad lp;
1064 vec_alloc (crtl->eh.action_record_data, 64);
1066 disp_index = 0;
1067 call_site_base = 1;
1068 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1069 if (lp && lp->post_landing_pad)
1071 int action, call_site;
1073 /* First: build the action table. */
1074 action = collect_one_action_chain (&ar_hash, lp->region);
1076 /* Next: assign call-site values. If dwarf2 terms, this would be
1077 the region number assigned by convert_to_eh_region_ranges, but
1078 handles no-action and must-not-throw differently. */
1079 /* Map must-not-throw to otherwise unused call-site index 0. */
1080 if (action == -2)
1081 call_site = 0;
1082 /* Map no-action to otherwise unused call-site index -1. */
1083 else if (action == -1)
1084 call_site = -1;
1085 /* Otherwise, look it up in the table. */
1086 else
1087 call_site = add_call_site (GEN_INT (disp_index), action, 0);
1088 sjlj_lp_call_site_index[i] = call_site;
1090 disp_index++;
1093 return disp_index;
1096 /* Emit code to record the current call-site index before every
1097 insn that can throw. */
1099 static void
1100 sjlj_mark_call_sites (void)
1102 int last_call_site = -2;
1103 rtx_insn *insn;
1104 rtx mem;
1106 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
1108 eh_landing_pad lp;
1109 eh_region r;
1110 bool nothrow;
1111 int this_call_site;
1112 rtx_insn *before, *p;
1114 /* Reset value tracking at extended basic block boundaries. */
1115 if (LABEL_P (insn))
1116 last_call_site = -2;
1118 if (! INSN_P (insn))
1119 continue;
1121 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1122 if (nothrow)
1123 continue;
1124 if (lp)
1125 this_call_site = sjlj_lp_call_site_index[lp->index];
1126 else if (r == NULL)
1128 /* Calls (and trapping insns) without notes are outside any
1129 exception handling region in this function. Mark them as
1130 no action. */
1131 this_call_site = -1;
1133 else
1135 gcc_assert (r->type == ERT_MUST_NOT_THROW);
1136 this_call_site = 0;
1139 if (this_call_site != -1)
1140 crtl->uses_eh_lsda = 1;
1142 if (this_call_site == last_call_site)
1143 continue;
1145 /* Don't separate a call from it's argument loads. */
1146 before = insn;
1147 if (CALL_P (insn))
1148 before = find_first_parameter_load (insn, NULL);
1150 start_sequence ();
1151 mem = adjust_address (crtl->eh.sjlj_fc, TYPE_MODE (integer_type_node),
1152 sjlj_fc_call_site_ofs);
1153 emit_move_insn (mem, gen_int_mode (this_call_site, GET_MODE (mem)));
1154 p = get_insns ();
1155 end_sequence ();
1157 emit_insn_before (p, before);
1158 last_call_site = this_call_site;
1162 /* Construct the SjLj_Function_Context. */
1164 static void
1165 sjlj_emit_function_enter (rtx_code_label *dispatch_label)
1167 rtx_insn *fn_begin, *seq;
1168 rtx fc, mem;
1169 bool fn_begin_outside_block;
1170 rtx personality = get_personality_function (current_function_decl);
1172 fc = crtl->eh.sjlj_fc;
1174 start_sequence ();
1176 /* We're storing this libcall's address into memory instead of
1177 calling it directly. Thus, we must call assemble_external_libcall
1178 here, as we can not depend on emit_library_call to do it for us. */
1179 assemble_external_libcall (personality);
1180 mem = adjust_address (fc, Pmode, sjlj_fc_personality_ofs);
1181 emit_move_insn (mem, personality);
1183 mem = adjust_address (fc, Pmode, sjlj_fc_lsda_ofs);
1184 if (crtl->uses_eh_lsda)
1186 char buf[20];
1187 rtx sym;
1189 ASM_GENERATE_INTERNAL_LABEL (buf, "LLSDA", current_function_funcdef_no);
1190 sym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
1191 SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_LOCAL;
1192 emit_move_insn (mem, sym);
1194 else
1195 emit_move_insn (mem, const0_rtx);
1197 if (dispatch_label)
1199 #ifdef DONT_USE_BUILTIN_SETJMP
1200 rtx x;
1201 x = emit_library_call_value (setjmp_libfunc, NULL_RTX, LCT_RETURNS_TWICE,
1202 TYPE_MODE (integer_type_node), 1,
1203 plus_constant (Pmode, XEXP (fc, 0),
1204 sjlj_fc_jbuf_ofs), Pmode);
1206 emit_cmp_and_jump_insns (x, const0_rtx, NE, 0,
1207 TYPE_MODE (integer_type_node), 0,
1208 dispatch_label, REG_BR_PROB_BASE / 100);
1209 #else
1210 expand_builtin_setjmp_setup (plus_constant (Pmode, XEXP (fc, 0),
1211 sjlj_fc_jbuf_ofs),
1212 dispatch_label);
1213 #endif
1216 emit_library_call (unwind_sjlj_register_libfunc, LCT_NORMAL, VOIDmode,
1217 1, XEXP (fc, 0), Pmode);
1219 seq = get_insns ();
1220 end_sequence ();
1222 /* ??? Instead of doing this at the beginning of the function,
1223 do this in a block that is at loop level 0 and dominates all
1224 can_throw_internal instructions. */
1226 fn_begin_outside_block = true;
1227 for (fn_begin = get_insns (); ; fn_begin = NEXT_INSN (fn_begin))
1228 if (NOTE_P (fn_begin))
1230 if (NOTE_KIND (fn_begin) == NOTE_INSN_FUNCTION_BEG)
1231 break;
1232 else if (NOTE_INSN_BASIC_BLOCK_P (fn_begin))
1233 fn_begin_outside_block = false;
1236 if (fn_begin_outside_block)
1237 insert_insn_on_edge (seq, single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
1238 else
1239 emit_insn_after (seq, fn_begin);
1242 /* Call back from expand_function_end to know where we should put
1243 the call to unwind_sjlj_unregister_libfunc if needed. */
1245 void
1246 sjlj_emit_function_exit_after (rtx_insn *after)
1248 crtl->eh.sjlj_exit_after = after;
1251 static void
1252 sjlj_emit_function_exit (void)
1254 rtx_insn *seq, *insn;
1256 start_sequence ();
1258 emit_library_call (unwind_sjlj_unregister_libfunc, LCT_NORMAL, VOIDmode,
1259 1, XEXP (crtl->eh.sjlj_fc, 0), Pmode);
1261 seq = get_insns ();
1262 end_sequence ();
1264 /* ??? Really this can be done in any block at loop level 0 that
1265 post-dominates all can_throw_internal instructions. This is
1266 the last possible moment. */
1268 insn = crtl->eh.sjlj_exit_after;
1269 if (LABEL_P (insn))
1270 insn = NEXT_INSN (insn);
1272 emit_insn_after (seq, insn);
1275 static void
1276 sjlj_emit_dispatch_table (rtx_code_label *dispatch_label, int num_dispatch)
1278 machine_mode unwind_word_mode = targetm.unwind_word_mode ();
1279 machine_mode filter_mode = targetm.eh_return_filter_mode ();
1280 eh_landing_pad lp;
1281 rtx mem, fc, before, exc_ptr_reg, filter_reg;
1282 rtx_insn *seq;
1283 rtx first_reachable_label;
1284 basic_block bb;
1285 eh_region r;
1286 edge e;
1287 int i, disp_index;
1288 vec<tree> dispatch_labels = vNULL;
1290 fc = crtl->eh.sjlj_fc;
1292 start_sequence ();
1294 emit_label (dispatch_label);
1296 #ifndef DONT_USE_BUILTIN_SETJMP
1297 expand_builtin_setjmp_receiver (dispatch_label);
1299 /* The caller of expand_builtin_setjmp_receiver is responsible for
1300 making sure that the label doesn't vanish. The only other caller
1301 is the expander for __builtin_setjmp_receiver, which places this
1302 label on the nonlocal_goto_label list. Since we're modeling these
1303 CFG edges more exactly, we can use the forced_labels list instead. */
1304 LABEL_PRESERVE_P (dispatch_label) = 1;
1305 forced_labels
1306 = gen_rtx_INSN_LIST (VOIDmode, dispatch_label, forced_labels);
1307 #endif
1309 /* Load up exc_ptr and filter values from the function context. */
1310 mem = adjust_address (fc, unwind_word_mode, sjlj_fc_data_ofs);
1311 if (unwind_word_mode != ptr_mode)
1313 #ifdef POINTERS_EXTEND_UNSIGNED
1314 mem = convert_memory_address (ptr_mode, mem);
1315 #else
1316 mem = convert_to_mode (ptr_mode, mem, 0);
1317 #endif
1319 exc_ptr_reg = force_reg (ptr_mode, mem);
1321 mem = adjust_address (fc, unwind_word_mode,
1322 sjlj_fc_data_ofs + GET_MODE_SIZE (unwind_word_mode));
1323 if (unwind_word_mode != filter_mode)
1324 mem = convert_to_mode (filter_mode, mem, 0);
1325 filter_reg = force_reg (filter_mode, mem);
1327 /* Jump to one of the directly reachable regions. */
1329 disp_index = 0;
1330 first_reachable_label = NULL;
1332 /* If there's exactly one call site in the function, don't bother
1333 generating a switch statement. */
1334 if (num_dispatch > 1)
1335 dispatch_labels.create (num_dispatch);
1337 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1338 if (lp && lp->post_landing_pad)
1340 rtx_insn *seq2;
1341 rtx label;
1343 start_sequence ();
1345 lp->landing_pad = dispatch_label;
1347 if (num_dispatch > 1)
1349 tree t_label, case_elt, t;
1351 t_label = create_artificial_label (UNKNOWN_LOCATION);
1352 t = build_int_cst (integer_type_node, disp_index);
1353 case_elt = build_case_label (t, NULL, t_label);
1354 dispatch_labels.quick_push (case_elt);
1355 label = label_rtx (t_label);
1357 else
1358 label = gen_label_rtx ();
1360 if (disp_index == 0)
1361 first_reachable_label = label;
1362 emit_label (label);
1364 r = lp->region;
1365 if (r->exc_ptr_reg)
1366 emit_move_insn (r->exc_ptr_reg, exc_ptr_reg);
1367 if (r->filter_reg)
1368 emit_move_insn (r->filter_reg, filter_reg);
1370 seq2 = get_insns ();
1371 end_sequence ();
1373 before = label_rtx (lp->post_landing_pad);
1374 bb = emit_to_new_bb_before (seq2, before);
1375 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
1376 e->count = bb->count;
1377 e->probability = REG_BR_PROB_BASE;
1378 if (current_loops)
1380 struct loop *loop = bb->next_bb->loop_father;
1381 /* If we created a pre-header block, add the new block to the
1382 outer loop, otherwise to the loop itself. */
1383 if (bb->next_bb == loop->header)
1384 add_bb_to_loop (bb, loop_outer (loop));
1385 else
1386 add_bb_to_loop (bb, loop);
1387 /* ??? For multiple dispatches we will end up with edges
1388 from the loop tree root into this loop, making it a
1389 multiple-entry loop. Discard all affected loops. */
1390 if (num_dispatch > 1)
1392 for (loop = bb->loop_father;
1393 loop_outer (loop); loop = loop_outer (loop))
1394 mark_loop_for_removal (loop);
1398 disp_index++;
1400 gcc_assert (disp_index == num_dispatch);
1402 if (num_dispatch > 1)
1404 rtx disp = adjust_address (fc, TYPE_MODE (integer_type_node),
1405 sjlj_fc_call_site_ofs);
1406 expand_sjlj_dispatch_table (disp, dispatch_labels);
1409 seq = get_insns ();
1410 end_sequence ();
1412 bb = emit_to_new_bb_before (seq, first_reachable_label);
1413 if (num_dispatch == 1)
1415 e = make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
1416 e->count = bb->count;
1417 e->probability = REG_BR_PROB_BASE;
1418 if (current_loops)
1420 struct loop *loop = bb->next_bb->loop_father;
1421 /* If we created a pre-header block, add the new block to the
1422 outer loop, otherwise to the loop itself. */
1423 if (bb->next_bb == loop->header)
1424 add_bb_to_loop (bb, loop_outer (loop));
1425 else
1426 add_bb_to_loop (bb, loop);
1429 else
1431 /* We are not wiring up edges here, but as the dispatcher call
1432 is at function begin simply associate the block with the
1433 outermost (non-)loop. */
1434 if (current_loops)
1435 add_bb_to_loop (bb, current_loops->tree_root);
1439 static void
1440 sjlj_build_landing_pads (void)
1442 int num_dispatch;
1444 num_dispatch = vec_safe_length (cfun->eh->lp_array);
1445 if (num_dispatch == 0)
1446 return;
1447 sjlj_lp_call_site_index.safe_grow_cleared (num_dispatch);
1449 num_dispatch = sjlj_assign_call_site_values ();
1450 if (num_dispatch > 0)
1452 rtx_code_label *dispatch_label = gen_label_rtx ();
1453 int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node,
1454 TYPE_MODE (sjlj_fc_type_node),
1455 TYPE_ALIGN (sjlj_fc_type_node));
1456 crtl->eh.sjlj_fc
1457 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
1458 int_size_in_bytes (sjlj_fc_type_node),
1459 align);
1461 sjlj_mark_call_sites ();
1462 sjlj_emit_function_enter (dispatch_label);
1463 sjlj_emit_dispatch_table (dispatch_label, num_dispatch);
1464 sjlj_emit_function_exit ();
1467 /* If we do not have any landing pads, we may still need to register a
1468 personality routine and (empty) LSDA to handle must-not-throw regions. */
1469 else if (function_needs_eh_personality (cfun) != eh_personality_none)
1471 int align = STACK_SLOT_ALIGNMENT (sjlj_fc_type_node,
1472 TYPE_MODE (sjlj_fc_type_node),
1473 TYPE_ALIGN (sjlj_fc_type_node));
1474 crtl->eh.sjlj_fc
1475 = assign_stack_local (TYPE_MODE (sjlj_fc_type_node),
1476 int_size_in_bytes (sjlj_fc_type_node),
1477 align);
1479 sjlj_mark_call_sites ();
1480 sjlj_emit_function_enter (NULL);
1481 sjlj_emit_function_exit ();
1484 sjlj_lp_call_site_index.release ();
1487 /* After initial rtl generation, call back to finish generating
1488 exception support code. */
1490 void
1491 finish_eh_generation (void)
1493 basic_block bb;
1495 /* Construct the landing pads. */
1496 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
1497 sjlj_build_landing_pads ();
1498 else
1499 dw2_build_landing_pads ();
1500 break_superblocks ();
1502 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ
1503 /* Kludge for Alpha (see alpha_gp_save_rtx). */
1504 || single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun))->insns.r)
1505 commit_edge_insertions ();
1507 /* Redirect all EH edges from the post_landing_pad to the landing pad. */
1508 FOR_EACH_BB_FN (bb, cfun)
1510 eh_landing_pad lp;
1511 edge_iterator ei;
1512 edge e;
1514 lp = get_eh_landing_pad_from_rtx (BB_END (bb));
1516 FOR_EACH_EDGE (e, ei, bb->succs)
1517 if (e->flags & EDGE_EH)
1518 break;
1520 /* We should not have generated any new throwing insns during this
1521 pass, and we should not have lost any EH edges, so we only need
1522 to handle two cases here:
1523 (1) reachable handler and an existing edge to post-landing-pad,
1524 (2) no reachable handler and no edge. */
1525 gcc_assert ((lp != NULL) == (e != NULL));
1526 if (lp != NULL)
1528 gcc_assert (BB_HEAD (e->dest) == label_rtx (lp->post_landing_pad));
1530 redirect_edge_succ (e, BLOCK_FOR_INSN (lp->landing_pad));
1531 e->flags |= (CALL_P (BB_END (bb))
1532 ? EDGE_ABNORMAL | EDGE_ABNORMAL_CALL
1533 : EDGE_ABNORMAL);
1538 /* This section handles removing dead code for flow. */
1540 void
1541 remove_eh_landing_pad (eh_landing_pad lp)
1543 eh_landing_pad *pp;
1545 for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp)
1546 continue;
1547 *pp = lp->next_lp;
1549 if (lp->post_landing_pad)
1550 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1551 (*cfun->eh->lp_array)[lp->index] = NULL;
1554 /* Splice the EH region at PP from the region tree. */
1556 static void
1557 remove_eh_handler_splicer (eh_region *pp)
1559 eh_region region = *pp;
1560 eh_landing_pad lp;
1562 for (lp = region->landing_pads; lp ; lp = lp->next_lp)
1564 if (lp->post_landing_pad)
1565 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1566 (*cfun->eh->lp_array)[lp->index] = NULL;
1569 if (region->inner)
1571 eh_region p, outer;
1572 outer = region->outer;
1574 *pp = p = region->inner;
1577 p->outer = outer;
1578 pp = &p->next_peer;
1579 p = *pp;
1581 while (p);
1583 *pp = region->next_peer;
1585 (*cfun->eh->region_array)[region->index] = NULL;
1588 /* Splice a single EH region REGION from the region tree.
1590 To unlink REGION, we need to find the pointer to it with a relatively
1591 expensive search in REGION's outer region. If you are going to
1592 remove a number of handlers, using remove_unreachable_eh_regions may
1593 be a better option. */
1595 void
1596 remove_eh_handler (eh_region region)
1598 eh_region *pp, *pp_start, p, outer;
1600 outer = region->outer;
1601 if (outer)
1602 pp_start = &outer->inner;
1603 else
1604 pp_start = &cfun->eh->region_tree;
1605 for (pp = pp_start, p = *pp; p != region; pp = &p->next_peer, p = *pp)
1606 continue;
1608 remove_eh_handler_splicer (pp);
1611 /* Worker for remove_unreachable_eh_regions.
1612 PP is a pointer to the region to start a region tree depth-first
1613 search from. R_REACHABLE is the set of regions that have to be
1614 preserved. */
1616 static void
1617 remove_unreachable_eh_regions_worker (eh_region *pp, sbitmap r_reachable)
1619 while (*pp)
1621 eh_region region = *pp;
1622 remove_unreachable_eh_regions_worker (&region->inner, r_reachable);
1623 if (!bitmap_bit_p (r_reachable, region->index))
1624 remove_eh_handler_splicer (pp);
1625 else
1626 pp = &region->next_peer;
1630 /* Splice all EH regions *not* marked in R_REACHABLE from the region tree.
1631 Do this by traversing the EH tree top-down and splice out regions that
1632 are not marked. By removing regions from the leaves, we avoid costly
1633 searches in the region tree. */
1635 void
1636 remove_unreachable_eh_regions (sbitmap r_reachable)
1638 remove_unreachable_eh_regions_worker (&cfun->eh->region_tree, r_reachable);
1641 /* Invokes CALLBACK for every exception handler landing pad label.
1642 Only used by reload hackery; should not be used by new code. */
1644 void
1645 for_each_eh_label (void (*callback) (rtx))
1647 eh_landing_pad lp;
1648 int i;
1650 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1652 if (lp)
1654 rtx lab = lp->landing_pad;
1655 if (lab && LABEL_P (lab))
1656 (*callback) (lab);
1661 /* Create the REG_EH_REGION note for INSN, given its ECF_FLAGS for a
1662 call insn.
1664 At the gimple level, we use LP_NR
1665 > 0 : The statement transfers to landing pad LP_NR
1666 = 0 : The statement is outside any EH region
1667 < 0 : The statement is within MUST_NOT_THROW region -LP_NR.
1669 At the rtl level, we use LP_NR
1670 > 0 : The insn transfers to landing pad LP_NR
1671 = 0 : The insn cannot throw
1672 < 0 : The insn is within MUST_NOT_THROW region -LP_NR
1673 = INT_MIN : The insn cannot throw or execute a nonlocal-goto.
1674 missing note: The insn is outside any EH region.
1676 ??? This difference probably ought to be avoided. We could stand
1677 to record nothrow for arbitrary gimple statements, and so avoid
1678 some moderately complex lookups in stmt_could_throw_p. Perhaps
1679 NOTHROW should be mapped on both sides to INT_MIN. Perhaps the
1680 no-nonlocal-goto property should be recorded elsewhere as a bit
1681 on the call_insn directly. Perhaps we should make more use of
1682 attaching the trees to call_insns (reachable via symbol_ref in
1683 direct call cases) and just pull the data out of the trees. */
1685 void
1686 make_reg_eh_region_note (rtx insn, int ecf_flags, int lp_nr)
1688 rtx value;
1689 if (ecf_flags & ECF_NOTHROW)
1690 value = const0_rtx;
1691 else if (lp_nr != 0)
1692 value = GEN_INT (lp_nr);
1693 else
1694 return;
1695 add_reg_note (insn, REG_EH_REGION, value);
1698 /* Create a REG_EH_REGION note for a CALL_INSN that cannot throw
1699 nor perform a non-local goto. Replace the region note if it
1700 already exists. */
1702 void
1703 make_reg_eh_region_note_nothrow_nononlocal (rtx insn)
1705 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1706 rtx intmin = GEN_INT (INT_MIN);
1708 if (note != 0)
1709 XEXP (note, 0) = intmin;
1710 else
1711 add_reg_note (insn, REG_EH_REGION, intmin);
1714 /* Return true if INSN could throw, assuming no REG_EH_REGION note
1715 to the contrary. */
1717 bool
1718 insn_could_throw_p (const_rtx insn)
1720 if (!flag_exceptions)
1721 return false;
1722 if (CALL_P (insn))
1723 return true;
1724 if (INSN_P (insn) && cfun->can_throw_non_call_exceptions)
1725 return may_trap_p (PATTERN (insn));
1726 return false;
1729 /* Copy an REG_EH_REGION note to each insn that might throw beginning
1730 at FIRST and ending at LAST. NOTE_OR_INSN is either the source insn
1731 to look for a note, or the note itself. */
1733 void
1734 copy_reg_eh_region_note_forward (rtx note_or_insn, rtx_insn *first, rtx last)
1736 rtx_insn *insn;
1737 rtx note = note_or_insn;
1739 if (INSN_P (note_or_insn))
1741 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
1742 if (note == NULL)
1743 return;
1745 note = XEXP (note, 0);
1747 for (insn = first; insn != last ; insn = NEXT_INSN (insn))
1748 if (!find_reg_note (insn, REG_EH_REGION, NULL_RTX)
1749 && insn_could_throw_p (insn))
1750 add_reg_note (insn, REG_EH_REGION, note);
1753 /* Likewise, but iterate backward. */
1755 void
1756 copy_reg_eh_region_note_backward (rtx note_or_insn, rtx_insn *last, rtx first)
1758 rtx_insn *insn;
1759 rtx note = note_or_insn;
1761 if (INSN_P (note_or_insn))
1763 note = find_reg_note (note_or_insn, REG_EH_REGION, NULL_RTX);
1764 if (note == NULL)
1765 return;
1767 note = XEXP (note, 0);
1769 for (insn = last; insn != first; insn = PREV_INSN (insn))
1770 if (insn_could_throw_p (insn))
1771 add_reg_note (insn, REG_EH_REGION, note);
1775 /* Extract all EH information from INSN. Return true if the insn
1776 was marked NOTHROW. */
1778 static bool
1779 get_eh_region_and_lp_from_rtx (const_rtx insn, eh_region *pr,
1780 eh_landing_pad *plp)
1782 eh_landing_pad lp = NULL;
1783 eh_region r = NULL;
1784 bool ret = false;
1785 rtx note;
1786 int lp_nr;
1788 if (! INSN_P (insn))
1789 goto egress;
1791 if (NONJUMP_INSN_P (insn)
1792 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1793 insn = XVECEXP (PATTERN (insn), 0, 0);
1795 note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1796 if (!note)
1798 ret = !insn_could_throw_p (insn);
1799 goto egress;
1802 lp_nr = INTVAL (XEXP (note, 0));
1803 if (lp_nr == 0 || lp_nr == INT_MIN)
1805 ret = true;
1806 goto egress;
1809 if (lp_nr < 0)
1810 r = (*cfun->eh->region_array)[-lp_nr];
1811 else
1813 lp = (*cfun->eh->lp_array)[lp_nr];
1814 r = lp->region;
1817 egress:
1818 *plp = lp;
1819 *pr = r;
1820 return ret;
1823 /* Return the landing pad to which INSN may go, or NULL if it does not
1824 have a reachable landing pad within this function. */
1826 eh_landing_pad
1827 get_eh_landing_pad_from_rtx (const_rtx insn)
1829 eh_landing_pad lp;
1830 eh_region r;
1832 get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1833 return lp;
1836 /* Return the region to which INSN may go, or NULL if it does not
1837 have a reachable region within this function. */
1839 eh_region
1840 get_eh_region_from_rtx (const_rtx insn)
1842 eh_landing_pad lp;
1843 eh_region r;
1845 get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1846 return r;
1849 /* Return true if INSN throws and is caught by something in this function. */
1851 bool
1852 can_throw_internal (const_rtx insn)
1854 return get_eh_landing_pad_from_rtx (insn) != NULL;
1857 /* Return true if INSN throws and escapes from the current function. */
1859 bool
1860 can_throw_external (const_rtx insn)
1862 eh_landing_pad lp;
1863 eh_region r;
1864 bool nothrow;
1866 if (! INSN_P (insn))
1867 return false;
1869 if (NONJUMP_INSN_P (insn)
1870 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1872 rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (insn));
1873 int i, n = seq->len ();
1875 for (i = 0; i < n; i++)
1876 if (can_throw_external (seq->element (i)))
1877 return true;
1879 return false;
1882 nothrow = get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1884 /* If we can't throw, we obviously can't throw external. */
1885 if (nothrow)
1886 return false;
1888 /* If we have an internal landing pad, then we're not external. */
1889 if (lp != NULL)
1890 return false;
1892 /* If we're not within an EH region, then we are external. */
1893 if (r == NULL)
1894 return true;
1896 /* The only thing that ought to be left is MUST_NOT_THROW regions,
1897 which don't always have landing pads. */
1898 gcc_assert (r->type == ERT_MUST_NOT_THROW);
1899 return false;
1902 /* Return true if INSN cannot throw at all. */
1904 bool
1905 insn_nothrow_p (const_rtx insn)
1907 eh_landing_pad lp;
1908 eh_region r;
1910 if (! INSN_P (insn))
1911 return true;
1913 if (NONJUMP_INSN_P (insn)
1914 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1916 rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (insn));
1917 int i, n = seq->len ();
1919 for (i = 0; i < n; i++)
1920 if (!insn_nothrow_p (seq->element (i)))
1921 return false;
1923 return true;
1926 return get_eh_region_and_lp_from_rtx (insn, &r, &lp);
1929 /* Return true if INSN can perform a non-local goto. */
1930 /* ??? This test is here in this file because it (ab)uses REG_EH_REGION. */
1932 bool
1933 can_nonlocal_goto (const_rtx insn)
1935 if (nonlocal_goto_handler_labels && CALL_P (insn))
1937 rtx note = find_reg_note (insn, REG_EH_REGION, NULL_RTX);
1938 if (!note || INTVAL (XEXP (note, 0)) != INT_MIN)
1939 return true;
1941 return false;
1944 /* Set TREE_NOTHROW and crtl->all_throwers_are_sibcalls. */
1946 static unsigned int
1947 set_nothrow_function_flags (void)
1949 rtx_insn *insn;
1951 crtl->nothrow = 1;
1953 /* Assume crtl->all_throwers_are_sibcalls until we encounter
1954 something that can throw an exception. We specifically exempt
1955 CALL_INSNs that are SIBLING_CALL_P, as these are really jumps,
1956 and can't throw. Most CALL_INSNs are not SIBLING_CALL_P, so this
1957 is optimistic. */
1959 crtl->all_throwers_are_sibcalls = 1;
1961 /* If we don't know that this implementation of the function will
1962 actually be used, then we must not set TREE_NOTHROW, since
1963 callers must not assume that this function does not throw. */
1964 if (TREE_NOTHROW (current_function_decl))
1965 return 0;
1967 if (! flag_exceptions)
1968 return 0;
1970 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1971 if (can_throw_external (insn))
1973 crtl->nothrow = 0;
1975 if (!CALL_P (insn) || !SIBLING_CALL_P (insn))
1977 crtl->all_throwers_are_sibcalls = 0;
1978 return 0;
1982 if (crtl->nothrow
1983 && (cgraph_node::get (current_function_decl)->get_availability ()
1984 >= AVAIL_AVAILABLE))
1986 struct cgraph_node *node = cgraph_node::get (current_function_decl);
1987 struct cgraph_edge *e;
1988 for (e = node->callers; e; e = e->next_caller)
1989 e->can_throw_external = false;
1990 node->set_nothrow_flag (true);
1992 if (dump_file)
1993 fprintf (dump_file, "Marking function nothrow: %s\n\n",
1994 current_function_name ());
1996 return 0;
1999 namespace {
2001 const pass_data pass_data_set_nothrow_function_flags =
2003 RTL_PASS, /* type */
2004 "nothrow", /* name */
2005 OPTGROUP_NONE, /* optinfo_flags */
2006 TV_NONE, /* tv_id */
2007 0, /* properties_required */
2008 0, /* properties_provided */
2009 0, /* properties_destroyed */
2010 0, /* todo_flags_start */
2011 0, /* todo_flags_finish */
2014 class pass_set_nothrow_function_flags : public rtl_opt_pass
2016 public:
2017 pass_set_nothrow_function_flags (gcc::context *ctxt)
2018 : rtl_opt_pass (pass_data_set_nothrow_function_flags, ctxt)
2021 /* opt_pass methods: */
2022 virtual unsigned int execute (function *)
2024 return set_nothrow_function_flags ();
2027 }; // class pass_set_nothrow_function_flags
2029 } // anon namespace
2031 rtl_opt_pass *
2032 make_pass_set_nothrow_function_flags (gcc::context *ctxt)
2034 return new pass_set_nothrow_function_flags (ctxt);
2038 /* Various hooks for unwind library. */
2040 /* Expand the EH support builtin functions:
2041 __builtin_eh_pointer and __builtin_eh_filter. */
2043 static eh_region
2044 expand_builtin_eh_common (tree region_nr_t)
2046 HOST_WIDE_INT region_nr;
2047 eh_region region;
2049 gcc_assert (tree_fits_shwi_p (region_nr_t));
2050 region_nr = tree_to_shwi (region_nr_t);
2052 region = (*cfun->eh->region_array)[region_nr];
2054 /* ??? We shouldn't have been able to delete a eh region without
2055 deleting all the code that depended on it. */
2056 gcc_assert (region != NULL);
2058 return region;
2061 /* Expand to the exc_ptr value from the given eh region. */
2064 expand_builtin_eh_pointer (tree exp)
2066 eh_region region
2067 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
2068 if (region->exc_ptr_reg == NULL)
2069 region->exc_ptr_reg = gen_reg_rtx (ptr_mode);
2070 return region->exc_ptr_reg;
2073 /* Expand to the filter value from the given eh region. */
2076 expand_builtin_eh_filter (tree exp)
2078 eh_region region
2079 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
2080 if (region->filter_reg == NULL)
2081 region->filter_reg = gen_reg_rtx (targetm.eh_return_filter_mode ());
2082 return region->filter_reg;
2085 /* Copy the exc_ptr and filter values from one landing pad's registers
2086 to another. This is used to inline the resx statement. */
2089 expand_builtin_eh_copy_values (tree exp)
2091 eh_region dst
2092 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 0));
2093 eh_region src
2094 = expand_builtin_eh_common (CALL_EXPR_ARG (exp, 1));
2095 machine_mode fmode = targetm.eh_return_filter_mode ();
2097 if (dst->exc_ptr_reg == NULL)
2098 dst->exc_ptr_reg = gen_reg_rtx (ptr_mode);
2099 if (src->exc_ptr_reg == NULL)
2100 src->exc_ptr_reg = gen_reg_rtx (ptr_mode);
2102 if (dst->filter_reg == NULL)
2103 dst->filter_reg = gen_reg_rtx (fmode);
2104 if (src->filter_reg == NULL)
2105 src->filter_reg = gen_reg_rtx (fmode);
2107 emit_move_insn (dst->exc_ptr_reg, src->exc_ptr_reg);
2108 emit_move_insn (dst->filter_reg, src->filter_reg);
2110 return const0_rtx;
2113 /* Do any necessary initialization to access arbitrary stack frames.
2114 On the SPARC, this means flushing the register windows. */
2116 void
2117 expand_builtin_unwind_init (void)
2119 /* Set this so all the registers get saved in our frame; we need to be
2120 able to copy the saved values for any registers from frames we unwind. */
2121 crtl->saves_all_registers = 1;
2123 #ifdef SETUP_FRAME_ADDRESSES
2124 SETUP_FRAME_ADDRESSES ();
2125 #endif
2128 /* Map a non-negative number to an eh return data register number; expands
2129 to -1 if no return data register is associated with the input number.
2130 At least the inputs 0 and 1 must be mapped; the target may provide more. */
2133 expand_builtin_eh_return_data_regno (tree exp)
2135 tree which = CALL_EXPR_ARG (exp, 0);
2136 unsigned HOST_WIDE_INT iwhich;
2138 if (TREE_CODE (which) != INTEGER_CST)
2140 error ("argument of %<__builtin_eh_return_regno%> must be constant");
2141 return constm1_rtx;
2144 iwhich = tree_to_uhwi (which);
2145 iwhich = EH_RETURN_DATA_REGNO (iwhich);
2146 if (iwhich == INVALID_REGNUM)
2147 return constm1_rtx;
2149 #ifdef DWARF_FRAME_REGNUM
2150 iwhich = DWARF_FRAME_REGNUM (iwhich);
2151 #else
2152 iwhich = DBX_REGISTER_NUMBER (iwhich);
2153 #endif
2155 return GEN_INT (iwhich);
2158 /* Given a value extracted from the return address register or stack slot,
2159 return the actual address encoded in that value. */
2162 expand_builtin_extract_return_addr (tree addr_tree)
2164 rtx addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
2166 if (GET_MODE (addr) != Pmode
2167 && GET_MODE (addr) != VOIDmode)
2169 #ifdef POINTERS_EXTEND_UNSIGNED
2170 addr = convert_memory_address (Pmode, addr);
2171 #else
2172 addr = convert_to_mode (Pmode, addr, 0);
2173 #endif
2176 /* First mask out any unwanted bits. */
2177 #ifdef MASK_RETURN_ADDR
2178 expand_and (Pmode, addr, MASK_RETURN_ADDR, addr);
2179 #endif
2181 /* Then adjust to find the real return address. */
2182 #if defined (RETURN_ADDR_OFFSET)
2183 addr = plus_constant (Pmode, addr, RETURN_ADDR_OFFSET);
2184 #endif
2186 return addr;
2189 /* Given an actual address in addr_tree, do any necessary encoding
2190 and return the value to be stored in the return address register or
2191 stack slot so the epilogue will return to that address. */
2194 expand_builtin_frob_return_addr (tree addr_tree)
2196 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
2198 addr = convert_memory_address (Pmode, addr);
2200 #ifdef RETURN_ADDR_OFFSET
2201 addr = force_reg (Pmode, addr);
2202 addr = plus_constant (Pmode, addr, -RETURN_ADDR_OFFSET);
2203 #endif
2205 return addr;
2208 /* Set up the epilogue with the magic bits we'll need to return to the
2209 exception handler. */
2211 void
2212 expand_builtin_eh_return (tree stackadj_tree ATTRIBUTE_UNUSED,
2213 tree handler_tree)
2215 rtx tmp;
2217 #ifdef EH_RETURN_STACKADJ_RTX
2218 tmp = expand_expr (stackadj_tree, crtl->eh.ehr_stackadj,
2219 VOIDmode, EXPAND_NORMAL);
2220 tmp = convert_memory_address (Pmode, tmp);
2221 if (!crtl->eh.ehr_stackadj)
2222 crtl->eh.ehr_stackadj = copy_to_reg (tmp);
2223 else if (tmp != crtl->eh.ehr_stackadj)
2224 emit_move_insn (crtl->eh.ehr_stackadj, tmp);
2225 #endif
2227 tmp = expand_expr (handler_tree, crtl->eh.ehr_handler,
2228 VOIDmode, EXPAND_NORMAL);
2229 tmp = convert_memory_address (Pmode, tmp);
2230 if (!crtl->eh.ehr_handler)
2231 crtl->eh.ehr_handler = copy_to_reg (tmp);
2232 else if (tmp != crtl->eh.ehr_handler)
2233 emit_move_insn (crtl->eh.ehr_handler, tmp);
2235 if (!crtl->eh.ehr_label)
2236 crtl->eh.ehr_label = gen_label_rtx ();
2237 emit_jump (crtl->eh.ehr_label);
2240 /* Expand __builtin_eh_return. This exit path from the function loads up
2241 the eh return data registers, adjusts the stack, and branches to a
2242 given PC other than the normal return address. */
2244 void
2245 expand_eh_return (void)
2247 rtx_code_label *around_label;
2249 if (! crtl->eh.ehr_label)
2250 return;
2252 crtl->calls_eh_return = 1;
2254 #ifdef EH_RETURN_STACKADJ_RTX
2255 emit_move_insn (EH_RETURN_STACKADJ_RTX, const0_rtx);
2256 #endif
2258 around_label = gen_label_rtx ();
2259 emit_jump (around_label);
2261 emit_label (crtl->eh.ehr_label);
2262 clobber_return_register ();
2264 #ifdef EH_RETURN_STACKADJ_RTX
2265 emit_move_insn (EH_RETURN_STACKADJ_RTX, crtl->eh.ehr_stackadj);
2266 #endif
2268 #ifdef HAVE_eh_return
2269 if (HAVE_eh_return)
2270 emit_insn (gen_eh_return (crtl->eh.ehr_handler));
2271 else
2272 #endif
2274 #ifdef EH_RETURN_HANDLER_RTX
2275 emit_move_insn (EH_RETURN_HANDLER_RTX, crtl->eh.ehr_handler);
2276 #else
2277 error ("__builtin_eh_return not supported on this target");
2278 #endif
2281 emit_label (around_label);
2284 /* Convert a ptr_mode address ADDR_TREE to a Pmode address controlled by
2285 POINTERS_EXTEND_UNSIGNED and return it. */
2288 expand_builtin_extend_pointer (tree addr_tree)
2290 rtx addr = expand_expr (addr_tree, NULL_RTX, ptr_mode, EXPAND_NORMAL);
2291 int extend;
2293 #ifdef POINTERS_EXTEND_UNSIGNED
2294 extend = POINTERS_EXTEND_UNSIGNED;
2295 #else
2296 /* The previous EH code did an unsigned extend by default, so we do this also
2297 for consistency. */
2298 extend = 1;
2299 #endif
2301 return convert_modes (targetm.unwind_word_mode (), ptr_mode, addr, extend);
2304 static int
2305 add_action_record (action_hash_type *ar_hash, int filter, int next)
2307 struct action_record **slot, *new_ar, tmp;
2309 tmp.filter = filter;
2310 tmp.next = next;
2311 slot = ar_hash->find_slot (&tmp, INSERT);
2313 if ((new_ar = *slot) == NULL)
2315 new_ar = XNEW (struct action_record);
2316 new_ar->offset = crtl->eh.action_record_data->length () + 1;
2317 new_ar->filter = filter;
2318 new_ar->next = next;
2319 *slot = new_ar;
2321 /* The filter value goes in untouched. The link to the next
2322 record is a "self-relative" byte offset, or zero to indicate
2323 that there is no next record. So convert the absolute 1 based
2324 indices we've been carrying around into a displacement. */
2326 push_sleb128 (&crtl->eh.action_record_data, filter);
2327 if (next)
2328 next -= crtl->eh.action_record_data->length () + 1;
2329 push_sleb128 (&crtl->eh.action_record_data, next);
2332 return new_ar->offset;
2335 static int
2336 collect_one_action_chain (action_hash_type *ar_hash, eh_region region)
2338 int next;
2340 /* If we've reached the top of the region chain, then we have
2341 no actions, and require no landing pad. */
2342 if (region == NULL)
2343 return -1;
2345 switch (region->type)
2347 case ERT_CLEANUP:
2349 eh_region r;
2350 /* A cleanup adds a zero filter to the beginning of the chain, but
2351 there are special cases to look out for. If there are *only*
2352 cleanups along a path, then it compresses to a zero action.
2353 Further, if there are multiple cleanups along a path, we only
2354 need to represent one of them, as that is enough to trigger
2355 entry to the landing pad at runtime. */
2356 next = collect_one_action_chain (ar_hash, region->outer);
2357 if (next <= 0)
2358 return 0;
2359 for (r = region->outer; r ; r = r->outer)
2360 if (r->type == ERT_CLEANUP)
2361 return next;
2362 return add_action_record (ar_hash, 0, next);
2365 case ERT_TRY:
2367 eh_catch c;
2369 /* Process the associated catch regions in reverse order.
2370 If there's a catch-all handler, then we don't need to
2371 search outer regions. Use a magic -3 value to record
2372 that we haven't done the outer search. */
2373 next = -3;
2374 for (c = region->u.eh_try.last_catch; c ; c = c->prev_catch)
2376 if (c->type_list == NULL)
2378 /* Retrieve the filter from the head of the filter list
2379 where we have stored it (see assign_filter_values). */
2380 int filter = TREE_INT_CST_LOW (TREE_VALUE (c->filter_list));
2381 next = add_action_record (ar_hash, filter, 0);
2383 else
2385 /* Once the outer search is done, trigger an action record for
2386 each filter we have. */
2387 tree flt_node;
2389 if (next == -3)
2391 next = collect_one_action_chain (ar_hash, region->outer);
2393 /* If there is no next action, terminate the chain. */
2394 if (next == -1)
2395 next = 0;
2396 /* If all outer actions are cleanups or must_not_throw,
2397 we'll have no action record for it, since we had wanted
2398 to encode these states in the call-site record directly.
2399 Add a cleanup action to the chain to catch these. */
2400 else if (next <= 0)
2401 next = add_action_record (ar_hash, 0, 0);
2404 flt_node = c->filter_list;
2405 for (; flt_node; flt_node = TREE_CHAIN (flt_node))
2407 int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node));
2408 next = add_action_record (ar_hash, filter, next);
2412 return next;
2415 case ERT_ALLOWED_EXCEPTIONS:
2416 /* An exception specification adds its filter to the
2417 beginning of the chain. */
2418 next = collect_one_action_chain (ar_hash, region->outer);
2420 /* If there is no next action, terminate the chain. */
2421 if (next == -1)
2422 next = 0;
2423 /* If all outer actions are cleanups or must_not_throw,
2424 we'll have no action record for it, since we had wanted
2425 to encode these states in the call-site record directly.
2426 Add a cleanup action to the chain to catch these. */
2427 else if (next <= 0)
2428 next = add_action_record (ar_hash, 0, 0);
2430 return add_action_record (ar_hash, region->u.allowed.filter, next);
2432 case ERT_MUST_NOT_THROW:
2433 /* A must-not-throw region with no inner handlers or cleanups
2434 requires no call-site entry. Note that this differs from
2435 the no handler or cleanup case in that we do require an lsda
2436 to be generated. Return a magic -2 value to record this. */
2437 return -2;
2440 gcc_unreachable ();
2443 static int
2444 add_call_site (rtx landing_pad, int action, int section)
2446 call_site_record record;
2448 record = ggc_alloc<call_site_record_d> ();
2449 record->landing_pad = landing_pad;
2450 record->action = action;
2452 vec_safe_push (crtl->eh.call_site_record_v[section], record);
2454 return call_site_base + crtl->eh.call_site_record_v[section]->length () - 1;
2457 static rtx_note *
2458 emit_note_eh_region_end (rtx_insn *insn)
2460 rtx_insn *next = NEXT_INSN (insn);
2462 /* Make sure we do not split a call and its corresponding
2463 CALL_ARG_LOCATION note. */
2464 if (next && NOTE_P (next)
2465 && NOTE_KIND (next) == NOTE_INSN_CALL_ARG_LOCATION)
2466 insn = next;
2468 return emit_note_after (NOTE_INSN_EH_REGION_END, insn);
2471 /* Turn REG_EH_REGION notes back into NOTE_INSN_EH_REGION notes.
2472 The new note numbers will not refer to region numbers, but
2473 instead to call site entries. */
2475 static unsigned int
2476 convert_to_eh_region_ranges (void)
2478 rtx insn;
2479 rtx_insn *iter;
2480 rtx_note *note;
2481 action_hash_type ar_hash (31);
2482 int last_action = -3;
2483 rtx_insn *last_action_insn = NULL;
2484 rtx last_landing_pad = NULL_RTX;
2485 rtx_insn *first_no_action_insn = NULL;
2486 int call_site = 0;
2487 int cur_sec = 0;
2488 rtx section_switch_note = NULL_RTX;
2489 rtx_insn *first_no_action_insn_before_switch = NULL;
2490 rtx_insn *last_no_action_insn_before_switch = NULL;
2491 int saved_call_site_base = call_site_base;
2493 vec_alloc (crtl->eh.action_record_data, 64);
2495 for (iter = get_insns (); iter ; iter = NEXT_INSN (iter))
2496 if (INSN_P (iter))
2498 eh_landing_pad lp;
2499 eh_region region;
2500 bool nothrow;
2501 int this_action;
2502 rtx this_landing_pad;
2504 insn = iter;
2505 if (NONJUMP_INSN_P (insn)
2506 && GET_CODE (PATTERN (insn)) == SEQUENCE)
2507 insn = XVECEXP (PATTERN (insn), 0, 0);
2509 nothrow = get_eh_region_and_lp_from_rtx (insn, &region, &lp);
2510 if (nothrow)
2511 continue;
2512 if (region)
2513 this_action = collect_one_action_chain (&ar_hash, region);
2514 else
2515 this_action = -1;
2517 /* Existence of catch handlers, or must-not-throw regions
2518 implies that an lsda is needed (even if empty). */
2519 if (this_action != -1)
2520 crtl->uses_eh_lsda = 1;
2522 /* Delay creation of region notes for no-action regions
2523 until we're sure that an lsda will be required. */
2524 else if (last_action == -3)
2526 first_no_action_insn = iter;
2527 last_action = -1;
2530 if (this_action >= 0)
2531 this_landing_pad = lp->landing_pad;
2532 else
2533 this_landing_pad = NULL_RTX;
2535 /* Differing actions or landing pads implies a change in call-site
2536 info, which implies some EH_REGION note should be emitted. */
2537 if (last_action != this_action
2538 || last_landing_pad != this_landing_pad)
2540 /* If there is a queued no-action region in the other section
2541 with hot/cold partitioning, emit it now. */
2542 if (first_no_action_insn_before_switch)
2544 gcc_assert (this_action != -1
2545 && last_action == (first_no_action_insn
2546 ? -1 : -3));
2547 call_site = add_call_site (NULL_RTX, 0, 0);
2548 note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
2549 first_no_action_insn_before_switch);
2550 NOTE_EH_HANDLER (note) = call_site;
2551 note
2552 = emit_note_eh_region_end (last_no_action_insn_before_switch);
2553 NOTE_EH_HANDLER (note) = call_site;
2554 gcc_assert (last_action != -3
2555 || (last_action_insn
2556 == last_no_action_insn_before_switch));
2557 first_no_action_insn_before_switch = NULL;
2558 last_no_action_insn_before_switch = NULL;
2559 call_site_base++;
2561 /* If we'd not seen a previous action (-3) or the previous
2562 action was must-not-throw (-2), then we do not need an
2563 end note. */
2564 if (last_action >= -1)
2566 /* If we delayed the creation of the begin, do it now. */
2567 if (first_no_action_insn)
2569 call_site = add_call_site (NULL_RTX, 0, cur_sec);
2570 note = emit_note_before (NOTE_INSN_EH_REGION_BEG,
2571 first_no_action_insn);
2572 NOTE_EH_HANDLER (note) = call_site;
2573 first_no_action_insn = NULL;
2576 note = emit_note_eh_region_end (last_action_insn);
2577 NOTE_EH_HANDLER (note) = call_site;
2580 /* If the new action is must-not-throw, then no region notes
2581 are created. */
2582 if (this_action >= -1)
2584 call_site = add_call_site (this_landing_pad,
2585 this_action < 0 ? 0 : this_action,
2586 cur_sec);
2587 note = emit_note_before (NOTE_INSN_EH_REGION_BEG, iter);
2588 NOTE_EH_HANDLER (note) = call_site;
2591 last_action = this_action;
2592 last_landing_pad = this_landing_pad;
2594 last_action_insn = iter;
2596 else if (NOTE_P (iter)
2597 && NOTE_KIND (iter) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
2599 gcc_assert (section_switch_note == NULL_RTX);
2600 gcc_assert (flag_reorder_blocks_and_partition);
2601 section_switch_note = iter;
2602 if (first_no_action_insn)
2604 first_no_action_insn_before_switch = first_no_action_insn;
2605 last_no_action_insn_before_switch = last_action_insn;
2606 first_no_action_insn = NULL;
2607 gcc_assert (last_action == -1);
2608 last_action = -3;
2610 /* Force closing of current EH region before section switch and
2611 opening a new one afterwards. */
2612 else if (last_action != -3)
2613 last_landing_pad = pc_rtx;
2614 if (crtl->eh.call_site_record_v[cur_sec])
2615 call_site_base += crtl->eh.call_site_record_v[cur_sec]->length ();
2616 cur_sec++;
2617 gcc_assert (crtl->eh.call_site_record_v[cur_sec] == NULL);
2618 vec_alloc (crtl->eh.call_site_record_v[cur_sec], 10);
2621 if (last_action >= -1 && ! first_no_action_insn)
2623 note = emit_note_eh_region_end (last_action_insn);
2624 NOTE_EH_HANDLER (note) = call_site;
2627 call_site_base = saved_call_site_base;
2629 return 0;
2632 namespace {
2634 const pass_data pass_data_convert_to_eh_region_ranges =
2636 RTL_PASS, /* type */
2637 "eh_ranges", /* name */
2638 OPTGROUP_NONE, /* optinfo_flags */
2639 TV_NONE, /* tv_id */
2640 0, /* properties_required */
2641 0, /* properties_provided */
2642 0, /* properties_destroyed */
2643 0, /* todo_flags_start */
2644 0, /* todo_flags_finish */
2647 class pass_convert_to_eh_region_ranges : public rtl_opt_pass
2649 public:
2650 pass_convert_to_eh_region_ranges (gcc::context *ctxt)
2651 : rtl_opt_pass (pass_data_convert_to_eh_region_ranges, ctxt)
2654 /* opt_pass methods: */
2655 virtual bool gate (function *);
2656 virtual unsigned int execute (function *)
2658 return convert_to_eh_region_ranges ();
2661 }; // class pass_convert_to_eh_region_ranges
2663 bool
2664 pass_convert_to_eh_region_ranges::gate (function *)
2666 /* Nothing to do for SJLJ exceptions or if no regions created. */
2667 if (cfun->eh->region_tree == NULL)
2668 return false;
2669 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
2670 return false;
2671 return true;
2674 } // anon namespace
2676 rtl_opt_pass *
2677 make_pass_convert_to_eh_region_ranges (gcc::context *ctxt)
2679 return new pass_convert_to_eh_region_ranges (ctxt);
2682 static void
2683 push_uleb128 (vec<uchar, va_gc> **data_area, unsigned int value)
2687 unsigned char byte = value & 0x7f;
2688 value >>= 7;
2689 if (value)
2690 byte |= 0x80;
2691 vec_safe_push (*data_area, byte);
2693 while (value);
2696 static void
2697 push_sleb128 (vec<uchar, va_gc> **data_area, int value)
2699 unsigned char byte;
2700 int more;
2704 byte = value & 0x7f;
2705 value >>= 7;
2706 more = ! ((value == 0 && (byte & 0x40) == 0)
2707 || (value == -1 && (byte & 0x40) != 0));
2708 if (more)
2709 byte |= 0x80;
2710 vec_safe_push (*data_area, byte);
2712 while (more);
2716 #ifndef HAVE_AS_LEB128
2717 static int
2718 dw2_size_of_call_site_table (int section)
2720 int n = vec_safe_length (crtl->eh.call_site_record_v[section]);
2721 int size = n * (4 + 4 + 4);
2722 int i;
2724 for (i = 0; i < n; ++i)
2726 struct call_site_record_d *cs =
2727 (*crtl->eh.call_site_record_v[section])[i];
2728 size += size_of_uleb128 (cs->action);
2731 return size;
2734 static int
2735 sjlj_size_of_call_site_table (void)
2737 int n = vec_safe_length (crtl->eh.call_site_record_v[0]);
2738 int size = 0;
2739 int i;
2741 for (i = 0; i < n; ++i)
2743 struct call_site_record_d *cs =
2744 (*crtl->eh.call_site_record_v[0])[i];
2745 size += size_of_uleb128 (INTVAL (cs->landing_pad));
2746 size += size_of_uleb128 (cs->action);
2749 return size;
2751 #endif
2753 static void
2754 dw2_output_call_site_table (int cs_format, int section)
2756 int n = vec_safe_length (crtl->eh.call_site_record_v[section]);
2757 int i;
2758 const char *begin;
2760 if (section == 0)
2761 begin = current_function_func_begin_label;
2762 else if (first_function_block_is_cold)
2763 begin = crtl->subsections.hot_section_label;
2764 else
2765 begin = crtl->subsections.cold_section_label;
2767 for (i = 0; i < n; ++i)
2769 struct call_site_record_d *cs = (*crtl->eh.call_site_record_v[section])[i];
2770 char reg_start_lab[32];
2771 char reg_end_lab[32];
2772 char landing_pad_lab[32];
2774 ASM_GENERATE_INTERNAL_LABEL (reg_start_lab, "LEHB", call_site_base + i);
2775 ASM_GENERATE_INTERNAL_LABEL (reg_end_lab, "LEHE", call_site_base + i);
2777 if (cs->landing_pad)
2778 ASM_GENERATE_INTERNAL_LABEL (landing_pad_lab, "L",
2779 CODE_LABEL_NUMBER (cs->landing_pad));
2781 /* ??? Perhaps use insn length scaling if the assembler supports
2782 generic arithmetic. */
2783 /* ??? Perhaps use attr_length to choose data1 or data2 instead of
2784 data4 if the function is small enough. */
2785 if (cs_format == DW_EH_PE_uleb128)
2787 dw2_asm_output_delta_uleb128 (reg_start_lab, begin,
2788 "region %d start", i);
2789 dw2_asm_output_delta_uleb128 (reg_end_lab, reg_start_lab,
2790 "length");
2791 if (cs->landing_pad)
2792 dw2_asm_output_delta_uleb128 (landing_pad_lab, begin,
2793 "landing pad");
2794 else
2795 dw2_asm_output_data_uleb128 (0, "landing pad");
2797 else
2799 dw2_asm_output_delta (4, reg_start_lab, begin,
2800 "region %d start", i);
2801 dw2_asm_output_delta (4, reg_end_lab, reg_start_lab, "length");
2802 if (cs->landing_pad)
2803 dw2_asm_output_delta (4, landing_pad_lab, begin,
2804 "landing pad");
2805 else
2806 dw2_asm_output_data (4, 0, "landing pad");
2808 dw2_asm_output_data_uleb128 (cs->action, "action");
2811 call_site_base += n;
2814 static void
2815 sjlj_output_call_site_table (void)
2817 int n = vec_safe_length (crtl->eh.call_site_record_v[0]);
2818 int i;
2820 for (i = 0; i < n; ++i)
2822 struct call_site_record_d *cs = (*crtl->eh.call_site_record_v[0])[i];
2824 dw2_asm_output_data_uleb128 (INTVAL (cs->landing_pad),
2825 "region %d landing pad", i);
2826 dw2_asm_output_data_uleb128 (cs->action, "action");
2829 call_site_base += n;
2832 /* Switch to the section that should be used for exception tables. */
2834 static void
2835 switch_to_exception_section (const char * ARG_UNUSED (fnname))
2837 section *s;
2839 if (exception_section)
2840 s = exception_section;
2841 else
2843 /* Compute the section and cache it into exception_section,
2844 unless it depends on the function name. */
2845 if (targetm_common.have_named_sections)
2847 int flags;
2849 if (EH_TABLES_CAN_BE_READ_ONLY)
2851 int tt_format =
2852 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2853 flags = ((! flag_pic
2854 || ((tt_format & 0x70) != DW_EH_PE_absptr
2855 && (tt_format & 0x70) != DW_EH_PE_aligned))
2856 ? 0 : SECTION_WRITE);
2858 else
2859 flags = SECTION_WRITE;
2861 #ifdef HAVE_LD_EH_GC_SECTIONS
2862 if (flag_function_sections
2863 || (DECL_COMDAT_GROUP (current_function_decl) && HAVE_COMDAT_GROUP))
2865 char *section_name = XNEWVEC (char, strlen (fnname) + 32);
2866 /* The EH table must match the code section, so only mark
2867 it linkonce if we have COMDAT groups to tie them together. */
2868 if (DECL_COMDAT_GROUP (current_function_decl) && HAVE_COMDAT_GROUP)
2869 flags |= SECTION_LINKONCE;
2870 sprintf (section_name, ".gcc_except_table.%s", fnname);
2871 s = get_section (section_name, flags, current_function_decl);
2872 free (section_name);
2874 else
2875 #endif
2876 exception_section
2877 = s = get_section (".gcc_except_table", flags, NULL);
2879 else
2880 exception_section
2881 = s = flag_pic ? data_section : readonly_data_section;
2884 switch_to_section (s);
2888 /* Output a reference from an exception table to the type_info object TYPE.
2889 TT_FORMAT and TT_FORMAT_SIZE describe the DWARF encoding method used for
2890 the value. */
2892 static void
2893 output_ttype (tree type, int tt_format, int tt_format_size)
2895 rtx value;
2896 bool is_public = true;
2898 if (type == NULL_TREE)
2899 value = const0_rtx;
2900 else
2902 /* FIXME lto. pass_ipa_free_lang_data changes all types to
2903 runtime types so TYPE should already be a runtime type
2904 reference. When pass_ipa_free_lang data is made a default
2905 pass, we can then remove the call to lookup_type_for_runtime
2906 below. */
2907 if (TYPE_P (type))
2908 type = lookup_type_for_runtime (type);
2910 value = expand_expr (type, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2912 /* Let cgraph know that the rtti decl is used. Not all of the
2913 paths below go through assemble_integer, which would take
2914 care of this for us. */
2915 STRIP_NOPS (type);
2916 if (TREE_CODE (type) == ADDR_EXPR)
2918 type = TREE_OPERAND (type, 0);
2919 if (TREE_CODE (type) == VAR_DECL)
2920 is_public = TREE_PUBLIC (type);
2922 else
2923 gcc_assert (TREE_CODE (type) == INTEGER_CST);
2926 /* Allow the target to override the type table entry format. */
2927 if (targetm.asm_out.ttype (value))
2928 return;
2930 if (tt_format == DW_EH_PE_absptr || tt_format == DW_EH_PE_aligned)
2931 assemble_integer (value, tt_format_size,
2932 tt_format_size * BITS_PER_UNIT, 1);
2933 else
2934 dw2_asm_output_encoded_addr_rtx (tt_format, value, is_public, NULL);
2937 static void
2938 output_one_function_exception_table (int section)
2940 int tt_format, cs_format, lp_format, i;
2941 #ifdef HAVE_AS_LEB128
2942 char ttype_label[32];
2943 char cs_after_size_label[32];
2944 char cs_end_label[32];
2945 #else
2946 int call_site_len;
2947 #endif
2948 int have_tt_data;
2949 int tt_format_size = 0;
2951 have_tt_data = (vec_safe_length (cfun->eh->ttype_data)
2952 || (targetm.arm_eabi_unwinder
2953 ? vec_safe_length (cfun->eh->ehspec_data.arm_eabi)
2954 : vec_safe_length (cfun->eh->ehspec_data.other)));
2956 /* Indicate the format of the @TType entries. */
2957 if (! have_tt_data)
2958 tt_format = DW_EH_PE_omit;
2959 else
2961 tt_format = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/1);
2962 #ifdef HAVE_AS_LEB128
2963 ASM_GENERATE_INTERNAL_LABEL (ttype_label,
2964 section ? "LLSDATTC" : "LLSDATT",
2965 current_function_funcdef_no);
2966 #endif
2967 tt_format_size = size_of_encoded_value (tt_format);
2969 assemble_align (tt_format_size * BITS_PER_UNIT);
2972 targetm.asm_out.internal_label (asm_out_file, section ? "LLSDAC" : "LLSDA",
2973 current_function_funcdef_no);
2975 /* The LSDA header. */
2977 /* Indicate the format of the landing pad start pointer. An omitted
2978 field implies @LPStart == @Start. */
2979 /* Currently we always put @LPStart == @Start. This field would
2980 be most useful in moving the landing pads completely out of
2981 line to another section, but it could also be used to minimize
2982 the size of uleb128 landing pad offsets. */
2983 lp_format = DW_EH_PE_omit;
2984 dw2_asm_output_data (1, lp_format, "@LPStart format (%s)",
2985 eh_data_format_name (lp_format));
2987 /* @LPStart pointer would go here. */
2989 dw2_asm_output_data (1, tt_format, "@TType format (%s)",
2990 eh_data_format_name (tt_format));
2992 #ifndef HAVE_AS_LEB128
2993 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
2994 call_site_len = sjlj_size_of_call_site_table ();
2995 else
2996 call_site_len = dw2_size_of_call_site_table (section);
2997 #endif
2999 /* A pc-relative 4-byte displacement to the @TType data. */
3000 if (have_tt_data)
3002 #ifdef HAVE_AS_LEB128
3003 char ttype_after_disp_label[32];
3004 ASM_GENERATE_INTERNAL_LABEL (ttype_after_disp_label,
3005 section ? "LLSDATTDC" : "LLSDATTD",
3006 current_function_funcdef_no);
3007 dw2_asm_output_delta_uleb128 (ttype_label, ttype_after_disp_label,
3008 "@TType base offset");
3009 ASM_OUTPUT_LABEL (asm_out_file, ttype_after_disp_label);
3010 #else
3011 /* Ug. Alignment queers things. */
3012 unsigned int before_disp, after_disp, last_disp, disp;
3014 before_disp = 1 + 1;
3015 after_disp = (1 + size_of_uleb128 (call_site_len)
3016 + call_site_len
3017 + vec_safe_length (crtl->eh.action_record_data)
3018 + (vec_safe_length (cfun->eh->ttype_data)
3019 * tt_format_size));
3021 disp = after_disp;
3024 unsigned int disp_size, pad;
3026 last_disp = disp;
3027 disp_size = size_of_uleb128 (disp);
3028 pad = before_disp + disp_size + after_disp;
3029 if (pad % tt_format_size)
3030 pad = tt_format_size - (pad % tt_format_size);
3031 else
3032 pad = 0;
3033 disp = after_disp + pad;
3035 while (disp != last_disp);
3037 dw2_asm_output_data_uleb128 (disp, "@TType base offset");
3038 #endif
3041 /* Indicate the format of the call-site offsets. */
3042 #ifdef HAVE_AS_LEB128
3043 cs_format = DW_EH_PE_uleb128;
3044 #else
3045 cs_format = DW_EH_PE_udata4;
3046 #endif
3047 dw2_asm_output_data (1, cs_format, "call-site format (%s)",
3048 eh_data_format_name (cs_format));
3050 #ifdef HAVE_AS_LEB128
3051 ASM_GENERATE_INTERNAL_LABEL (cs_after_size_label,
3052 section ? "LLSDACSBC" : "LLSDACSB",
3053 current_function_funcdef_no);
3054 ASM_GENERATE_INTERNAL_LABEL (cs_end_label,
3055 section ? "LLSDACSEC" : "LLSDACSE",
3056 current_function_funcdef_no);
3057 dw2_asm_output_delta_uleb128 (cs_end_label, cs_after_size_label,
3058 "Call-site table length");
3059 ASM_OUTPUT_LABEL (asm_out_file, cs_after_size_label);
3060 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
3061 sjlj_output_call_site_table ();
3062 else
3063 dw2_output_call_site_table (cs_format, section);
3064 ASM_OUTPUT_LABEL (asm_out_file, cs_end_label);
3065 #else
3066 dw2_asm_output_data_uleb128 (call_site_len, "Call-site table length");
3067 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
3068 sjlj_output_call_site_table ();
3069 else
3070 dw2_output_call_site_table (cs_format, section);
3071 #endif
3073 /* ??? Decode and interpret the data for flag_debug_asm. */
3075 uchar uc;
3076 FOR_EACH_VEC_ELT (*crtl->eh.action_record_data, i, uc)
3077 dw2_asm_output_data (1, uc, i ? NULL : "Action record table");
3080 if (have_tt_data)
3081 assemble_align (tt_format_size * BITS_PER_UNIT);
3083 i = vec_safe_length (cfun->eh->ttype_data);
3084 while (i-- > 0)
3086 tree type = (*cfun->eh->ttype_data)[i];
3087 output_ttype (type, tt_format, tt_format_size);
3090 #ifdef HAVE_AS_LEB128
3091 if (have_tt_data)
3092 ASM_OUTPUT_LABEL (asm_out_file, ttype_label);
3093 #endif
3095 /* ??? Decode and interpret the data for flag_debug_asm. */
3096 if (targetm.arm_eabi_unwinder)
3098 tree type;
3099 for (i = 0;
3100 vec_safe_iterate (cfun->eh->ehspec_data.arm_eabi, i, &type); ++i)
3101 output_ttype (type, tt_format, tt_format_size);
3103 else
3105 uchar uc;
3106 for (i = 0;
3107 vec_safe_iterate (cfun->eh->ehspec_data.other, i, &uc); ++i)
3108 dw2_asm_output_data (1, uc,
3109 i ? NULL : "Exception specification table");
3113 void
3114 output_function_exception_table (const char *fnname)
3116 rtx personality = get_personality_function (current_function_decl);
3118 /* Not all functions need anything. */
3119 if (! crtl->uses_eh_lsda)
3120 return;
3122 if (personality)
3124 assemble_external_libcall (personality);
3126 if (targetm.asm_out.emit_except_personality)
3127 targetm.asm_out.emit_except_personality (personality);
3130 switch_to_exception_section (fnname);
3132 /* If the target wants a label to begin the table, emit it here. */
3133 targetm.asm_out.emit_except_table_label (asm_out_file);
3135 output_one_function_exception_table (0);
3136 if (crtl->eh.call_site_record_v[1])
3137 output_one_function_exception_table (1);
3139 switch_to_section (current_function_section ());
3142 void
3143 set_eh_throw_stmt_table (function *fun, hash_map<gimple, int> *table)
3145 fun->eh->throw_stmt_table = table;
3148 hash_map<gimple, int> *
3149 get_eh_throw_stmt_table (struct function *fun)
3151 return fun->eh->throw_stmt_table;
3154 /* Determine if the function needs an EH personality function. */
3156 enum eh_personality_kind
3157 function_needs_eh_personality (struct function *fn)
3159 enum eh_personality_kind kind = eh_personality_none;
3160 eh_region i;
3162 FOR_ALL_EH_REGION_FN (i, fn)
3164 switch (i->type)
3166 case ERT_CLEANUP:
3167 /* Can do with any personality including the generic C one. */
3168 kind = eh_personality_any;
3169 break;
3171 case ERT_TRY:
3172 case ERT_ALLOWED_EXCEPTIONS:
3173 /* Always needs a EH personality function. The generic C
3174 personality doesn't handle these even for empty type lists. */
3175 return eh_personality_lang;
3177 case ERT_MUST_NOT_THROW:
3178 /* Always needs a EH personality function. The language may specify
3179 what abort routine that must be used, e.g. std::terminate. */
3180 return eh_personality_lang;
3184 return kind;
3187 /* Dump EH information to OUT. */
3189 void
3190 dump_eh_tree (FILE * out, struct function *fun)
3192 eh_region i;
3193 int depth = 0;
3194 static const char *const type_name[] = {
3195 "cleanup", "try", "allowed_exceptions", "must_not_throw"
3198 i = fun->eh->region_tree;
3199 if (!i)
3200 return;
3202 fprintf (out, "Eh tree:\n");
3203 while (1)
3205 fprintf (out, " %*s %i %s", depth * 2, "",
3206 i->index, type_name[(int) i->type]);
3208 if (i->landing_pads)
3210 eh_landing_pad lp;
3212 fprintf (out, " land:");
3213 if (current_ir_type () == IR_GIMPLE)
3215 for (lp = i->landing_pads; lp ; lp = lp->next_lp)
3217 fprintf (out, "{%i,", lp->index);
3218 print_generic_expr (out, lp->post_landing_pad, 0);
3219 fputc ('}', out);
3220 if (lp->next_lp)
3221 fputc (',', out);
3224 else
3226 for (lp = i->landing_pads; lp ; lp = lp->next_lp)
3228 fprintf (out, "{%i,", lp->index);
3229 if (lp->landing_pad)
3230 fprintf (out, "%i%s,", INSN_UID (lp->landing_pad),
3231 NOTE_P (lp->landing_pad) ? "(del)" : "");
3232 else
3233 fprintf (out, "(nil),");
3234 if (lp->post_landing_pad)
3236 rtx lab = label_rtx (lp->post_landing_pad);
3237 fprintf (out, "%i%s}", INSN_UID (lab),
3238 NOTE_P (lab) ? "(del)" : "");
3240 else
3241 fprintf (out, "(nil)}");
3242 if (lp->next_lp)
3243 fputc (',', out);
3248 switch (i->type)
3250 case ERT_CLEANUP:
3251 case ERT_MUST_NOT_THROW:
3252 break;
3254 case ERT_TRY:
3256 eh_catch c;
3257 fprintf (out, " catch:");
3258 for (c = i->u.eh_try.first_catch; c; c = c->next_catch)
3260 fputc ('{', out);
3261 if (c->label)
3263 fprintf (out, "lab:");
3264 print_generic_expr (out, c->label, 0);
3265 fputc (';', out);
3267 print_generic_expr (out, c->type_list, 0);
3268 fputc ('}', out);
3269 if (c->next_catch)
3270 fputc (',', out);
3273 break;
3275 case ERT_ALLOWED_EXCEPTIONS:
3276 fprintf (out, " filter :%i types:", i->u.allowed.filter);
3277 print_generic_expr (out, i->u.allowed.type_list, 0);
3278 break;
3280 fputc ('\n', out);
3282 /* If there are sub-regions, process them. */
3283 if (i->inner)
3284 i = i->inner, depth++;
3285 /* If there are peers, process them. */
3286 else if (i->next_peer)
3287 i = i->next_peer;
3288 /* Otherwise, step back up the tree to the next peer. */
3289 else
3293 i = i->outer;
3294 depth--;
3295 if (i == NULL)
3296 return;
3298 while (i->next_peer == NULL);
3299 i = i->next_peer;
3304 /* Dump the EH tree for FN on stderr. */
3306 DEBUG_FUNCTION void
3307 debug_eh_tree (struct function *fn)
3309 dump_eh_tree (stderr, fn);
3312 /* Verify invariants on EH datastructures. */
3314 DEBUG_FUNCTION void
3315 verify_eh_tree (struct function *fun)
3317 eh_region r, outer;
3318 int nvisited_lp, nvisited_r;
3319 int count_lp, count_r, depth, i;
3320 eh_landing_pad lp;
3321 bool err = false;
3323 if (!fun->eh->region_tree)
3324 return;
3326 count_r = 0;
3327 for (i = 1; vec_safe_iterate (fun->eh->region_array, i, &r); ++i)
3328 if (r)
3330 if (r->index == i)
3331 count_r++;
3332 else
3334 error ("region_array is corrupted for region %i", r->index);
3335 err = true;
3339 count_lp = 0;
3340 for (i = 1; vec_safe_iterate (fun->eh->lp_array, i, &lp); ++i)
3341 if (lp)
3343 if (lp->index == i)
3344 count_lp++;
3345 else
3347 error ("lp_array is corrupted for lp %i", lp->index);
3348 err = true;
3352 depth = nvisited_lp = nvisited_r = 0;
3353 outer = NULL;
3354 r = fun->eh->region_tree;
3355 while (1)
3357 if ((*fun->eh->region_array)[r->index] != r)
3359 error ("region_array is corrupted for region %i", r->index);
3360 err = true;
3362 if (r->outer != outer)
3364 error ("outer block of region %i is wrong", r->index);
3365 err = true;
3367 if (depth < 0)
3369 error ("negative nesting depth of region %i", r->index);
3370 err = true;
3372 nvisited_r++;
3374 for (lp = r->landing_pads; lp ; lp = lp->next_lp)
3376 if ((*fun->eh->lp_array)[lp->index] != lp)
3378 error ("lp_array is corrupted for lp %i", lp->index);
3379 err = true;
3381 if (lp->region != r)
3383 error ("region of lp %i is wrong", lp->index);
3384 err = true;
3386 nvisited_lp++;
3389 if (r->inner)
3390 outer = r, r = r->inner, depth++;
3391 else if (r->next_peer)
3392 r = r->next_peer;
3393 else
3397 r = r->outer;
3398 if (r == NULL)
3399 goto region_done;
3400 depth--;
3401 outer = r->outer;
3403 while (r->next_peer == NULL);
3404 r = r->next_peer;
3407 region_done:
3408 if (depth != 0)
3410 error ("tree list ends on depth %i", depth);
3411 err = true;
3413 if (count_r != nvisited_r)
3415 error ("region_array does not match region_tree");
3416 err = true;
3418 if (count_lp != nvisited_lp)
3420 error ("lp_array does not match region_tree");
3421 err = true;
3424 if (err)
3426 dump_eh_tree (stderr, fun);
3427 internal_error ("verify_eh_tree failed");
3431 #include "gt-except.h"