Daily bump.
[official-gcc.git] / gcc / tree-eh.c
blobf189b9b6a96c0a805b55a7b580e65c6ea456aa2f
1 /* Exception handling semantics and decomposition for trees.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License 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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "flags.h"
27 #include "function.h"
28 #include "except.h"
29 #include "pointer-set.h"
30 #include "tree-flow.h"
31 #include "tree-dump.h"
32 #include "tree-inline.h"
33 #include "tree-iterator.h"
34 #include "tree-pass.h"
35 #include "timevar.h"
36 #include "langhooks.h"
37 #include "ggc.h"
38 #include "diagnostic-core.h"
39 #include "gimple.h"
40 #include "target.h"
42 /* In some instances a tree and a gimple need to be stored in a same table,
43 i.e. in hash tables. This is a structure to do this. */
44 typedef union {tree *tp; tree t; gimple g;} treemple;
46 /* Nonzero if we are using EH to handle cleanups. */
47 static int using_eh_for_cleanups_p = 0;
49 void
50 using_eh_for_cleanups (void)
52 using_eh_for_cleanups_p = 1;
55 /* Misc functions used in this file. */
57 /* Compare and hash for any structure which begins with a canonical
58 pointer. Assumes all pointers are interchangeable, which is sort
59 of already assumed by gcc elsewhere IIRC. */
61 static int
62 struct_ptr_eq (const void *a, const void *b)
64 const void * const * x = (const void * const *) a;
65 const void * const * y = (const void * const *) b;
66 return *x == *y;
69 static hashval_t
70 struct_ptr_hash (const void *a)
72 const void * const * x = (const void * const *) a;
73 return (size_t)*x >> 4;
77 /* Remember and lookup EH landing pad data for arbitrary statements.
78 Really this means any statement that could_throw_p. We could
79 stuff this information into the stmt_ann data structure, but:
81 (1) We absolutely rely on this information being kept until
82 we get to rtl. Once we're done with lowering here, if we lose
83 the information there's no way to recover it!
85 (2) There are many more statements that *cannot* throw as
86 compared to those that can. We should be saving some amount
87 of space by only allocating memory for those that can throw. */
89 /* Add statement T in function IFUN to landing pad NUM. */
91 void
92 add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num)
94 struct throw_stmt_node *n;
95 void **slot;
97 gcc_assert (num != 0);
99 n = ggc_alloc_throw_stmt_node ();
100 n->stmt = t;
101 n->lp_nr = num;
103 if (!get_eh_throw_stmt_table (ifun))
104 set_eh_throw_stmt_table (ifun, htab_create_ggc (31, struct_ptr_hash,
105 struct_ptr_eq,
106 ggc_free));
108 slot = htab_find_slot (get_eh_throw_stmt_table (ifun), n, INSERT);
109 gcc_assert (!*slot);
110 *slot = n;
113 /* Add statement T in the current function (cfun) to EH landing pad NUM. */
115 void
116 add_stmt_to_eh_lp (gimple t, int num)
118 add_stmt_to_eh_lp_fn (cfun, t, num);
121 /* Add statement T to the single EH landing pad in REGION. */
123 static void
124 record_stmt_eh_region (eh_region region, gimple t)
126 if (region == NULL)
127 return;
128 if (region->type == ERT_MUST_NOT_THROW)
129 add_stmt_to_eh_lp_fn (cfun, t, -region->index);
130 else
132 eh_landing_pad lp = region->landing_pads;
133 if (lp == NULL)
134 lp = gen_eh_landing_pad (region);
135 else
136 gcc_assert (lp->next_lp == NULL);
137 add_stmt_to_eh_lp_fn (cfun, t, lp->index);
142 /* Remove statement T in function IFUN from its EH landing pad. */
144 bool
145 remove_stmt_from_eh_lp_fn (struct function *ifun, gimple t)
147 struct throw_stmt_node dummy;
148 void **slot;
150 if (!get_eh_throw_stmt_table (ifun))
151 return false;
153 dummy.stmt = t;
154 slot = htab_find_slot (get_eh_throw_stmt_table (ifun), &dummy,
155 NO_INSERT);
156 if (slot)
158 htab_clear_slot (get_eh_throw_stmt_table (ifun), slot);
159 return true;
161 else
162 return false;
166 /* Remove statement T in the current function (cfun) from its
167 EH landing pad. */
169 bool
170 remove_stmt_from_eh_lp (gimple t)
172 return remove_stmt_from_eh_lp_fn (cfun, t);
175 /* Determine if statement T is inside an EH region in function IFUN.
176 Positive numbers indicate a landing pad index; negative numbers
177 indicate a MUST_NOT_THROW region index; zero indicates that the
178 statement is not recorded in the region table. */
181 lookup_stmt_eh_lp_fn (struct function *ifun, gimple t)
183 struct throw_stmt_node *p, n;
185 if (ifun->eh->throw_stmt_table == NULL)
186 return 0;
188 n.stmt = t;
189 p = (struct throw_stmt_node *) htab_find (ifun->eh->throw_stmt_table, &n);
190 return p ? p->lp_nr : 0;
193 /* Likewise, but always use the current function. */
196 lookup_stmt_eh_lp (gimple t)
198 /* We can get called from initialized data when -fnon-call-exceptions
199 is on; prevent crash. */
200 if (!cfun)
201 return 0;
202 return lookup_stmt_eh_lp_fn (cfun, t);
205 /* First pass of EH node decomposition. Build up a tree of GIMPLE_TRY_FINALLY
206 nodes and LABEL_DECL nodes. We will use this during the second phase to
207 determine if a goto leaves the body of a TRY_FINALLY_EXPR node. */
209 struct finally_tree_node
211 /* When storing a GIMPLE_TRY, we have to record a gimple. However
212 when deciding whether a GOTO to a certain LABEL_DECL (which is a
213 tree) leaves the TRY block, its necessary to record a tree in
214 this field. Thus a treemple is used. */
215 treemple child;
216 gimple parent;
219 /* Note that this table is *not* marked GTY. It is short-lived. */
220 static htab_t finally_tree;
222 static void
223 record_in_finally_tree (treemple child, gimple parent)
225 struct finally_tree_node *n;
226 void **slot;
228 n = XNEW (struct finally_tree_node);
229 n->child = child;
230 n->parent = parent;
232 slot = htab_find_slot (finally_tree, n, INSERT);
233 gcc_assert (!*slot);
234 *slot = n;
237 static void
238 collect_finally_tree (gimple stmt, gimple region);
240 /* Go through the gimple sequence. Works with collect_finally_tree to
241 record all GIMPLE_LABEL and GIMPLE_TRY statements. */
243 static void
244 collect_finally_tree_1 (gimple_seq seq, gimple region)
246 gimple_stmt_iterator gsi;
248 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
249 collect_finally_tree (gsi_stmt (gsi), region);
252 static void
253 collect_finally_tree (gimple stmt, gimple region)
255 treemple temp;
257 switch (gimple_code (stmt))
259 case GIMPLE_LABEL:
260 temp.t = gimple_label_label (stmt);
261 record_in_finally_tree (temp, region);
262 break;
264 case GIMPLE_TRY:
265 if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
267 temp.g = stmt;
268 record_in_finally_tree (temp, region);
269 collect_finally_tree_1 (gimple_try_eval (stmt), stmt);
270 collect_finally_tree_1 (gimple_try_cleanup (stmt), region);
272 else if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
274 collect_finally_tree_1 (gimple_try_eval (stmt), region);
275 collect_finally_tree_1 (gimple_try_cleanup (stmt), region);
277 break;
279 case GIMPLE_CATCH:
280 collect_finally_tree_1 (gimple_catch_handler (stmt), region);
281 break;
283 case GIMPLE_EH_FILTER:
284 collect_finally_tree_1 (gimple_eh_filter_failure (stmt), region);
285 break;
287 default:
288 /* A type, a decl, or some kind of statement that we're not
289 interested in. Don't walk them. */
290 break;
295 /* Use the finally tree to determine if a jump from START to TARGET
296 would leave the try_finally node that START lives in. */
298 static bool
299 outside_finally_tree (treemple start, gimple target)
301 struct finally_tree_node n, *p;
305 n.child = start;
306 p = (struct finally_tree_node *) htab_find (finally_tree, &n);
307 if (!p)
308 return true;
309 start.g = p->parent;
311 while (start.g != target);
313 return false;
316 /* Second pass of EH node decomposition. Actually transform the GIMPLE_TRY
317 nodes into a set of gotos, magic labels, and eh regions.
318 The eh region creation is straight-forward, but frobbing all the gotos
319 and such into shape isn't. */
321 /* The sequence into which we record all EH stuff. This will be
322 placed at the end of the function when we're all done. */
323 static gimple_seq eh_seq;
325 /* Record whether an EH region contains something that can throw,
326 indexed by EH region number. */
327 static bitmap eh_region_may_contain_throw_map;
329 /* The GOTO_QUEUE is is an array of GIMPLE_GOTO and GIMPLE_RETURN
330 statements that are seen to escape this GIMPLE_TRY_FINALLY node.
331 The idea is to record a gimple statement for everything except for
332 the conditionals, which get their labels recorded. Since labels are
333 of type 'tree', we need this node to store both gimple and tree
334 objects. REPL_STMT is the sequence used to replace the goto/return
335 statement. CONT_STMT is used to store the statement that allows
336 the return/goto to jump to the original destination. */
338 struct goto_queue_node
340 treemple stmt;
341 gimple_seq repl_stmt;
342 gimple cont_stmt;
343 int index;
344 /* This is used when index >= 0 to indicate that stmt is a label (as
345 opposed to a goto stmt). */
346 int is_label;
349 /* State of the world while lowering. */
351 struct leh_state
353 /* What's "current" while constructing the eh region tree. These
354 correspond to variables of the same name in cfun->eh, which we
355 don't have easy access to. */
356 eh_region cur_region;
358 /* What's "current" for the purposes of __builtin_eh_pointer. For
359 a CATCH, this is the associated TRY. For an EH_FILTER, this is
360 the associated ALLOWED_EXCEPTIONS, etc. */
361 eh_region ehp_region;
363 /* Processing of TRY_FINALLY requires a bit more state. This is
364 split out into a separate structure so that we don't have to
365 copy so much when processing other nodes. */
366 struct leh_tf_state *tf;
369 struct leh_tf_state
371 /* Pointer to the GIMPLE_TRY_FINALLY node under discussion. The
372 try_finally_expr is the original GIMPLE_TRY_FINALLY. We need to retain
373 this so that outside_finally_tree can reliably reference the tree used
374 in the collect_finally_tree data structures. */
375 gimple try_finally_expr;
376 gimple top_p;
378 /* While lowering a top_p usually it is expanded into multiple statements,
379 thus we need the following field to store them. */
380 gimple_seq top_p_seq;
382 /* The state outside this try_finally node. */
383 struct leh_state *outer;
385 /* The exception region created for it. */
386 eh_region region;
388 /* The goto queue. */
389 struct goto_queue_node *goto_queue;
390 size_t goto_queue_size;
391 size_t goto_queue_active;
393 /* Pointer map to help in searching goto_queue when it is large. */
394 struct pointer_map_t *goto_queue_map;
396 /* The set of unique labels seen as entries in the goto queue. */
397 VEC(tree,heap) *dest_array;
399 /* A label to be added at the end of the completed transformed
400 sequence. It will be set if may_fallthru was true *at one time*,
401 though subsequent transformations may have cleared that flag. */
402 tree fallthru_label;
404 /* True if it is possible to fall out the bottom of the try block.
405 Cleared if the fallthru is converted to a goto. */
406 bool may_fallthru;
408 /* True if any entry in goto_queue is a GIMPLE_RETURN. */
409 bool may_return;
411 /* True if the finally block can receive an exception edge.
412 Cleared if the exception case is handled by code duplication. */
413 bool may_throw;
416 static gimple_seq lower_eh_must_not_throw (struct leh_state *, gimple);
418 /* Search for STMT in the goto queue. Return the replacement,
419 or null if the statement isn't in the queue. */
421 #define LARGE_GOTO_QUEUE 20
423 static void lower_eh_constructs_1 (struct leh_state *state, gimple_seq seq);
425 static gimple_seq
426 find_goto_replacement (struct leh_tf_state *tf, treemple stmt)
428 unsigned int i;
429 void **slot;
431 if (tf->goto_queue_active < LARGE_GOTO_QUEUE)
433 for (i = 0; i < tf->goto_queue_active; i++)
434 if ( tf->goto_queue[i].stmt.g == stmt.g)
435 return tf->goto_queue[i].repl_stmt;
436 return NULL;
439 /* If we have a large number of entries in the goto_queue, create a
440 pointer map and use that for searching. */
442 if (!tf->goto_queue_map)
444 tf->goto_queue_map = pointer_map_create ();
445 for (i = 0; i < tf->goto_queue_active; i++)
447 slot = pointer_map_insert (tf->goto_queue_map,
448 tf->goto_queue[i].stmt.g);
449 gcc_assert (*slot == NULL);
450 *slot = &tf->goto_queue[i];
454 slot = pointer_map_contains (tf->goto_queue_map, stmt.g);
455 if (slot != NULL)
456 return (((struct goto_queue_node *) *slot)->repl_stmt);
458 return NULL;
461 /* A subroutine of replace_goto_queue_1. Handles the sub-clauses of a
462 lowered GIMPLE_COND. If, by chance, the replacement is a simple goto,
463 then we can just splat it in, otherwise we add the new stmts immediately
464 after the GIMPLE_COND and redirect. */
466 static void
467 replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf,
468 gimple_stmt_iterator *gsi)
470 tree label;
471 gimple_seq new_seq;
472 treemple temp;
473 location_t loc = gimple_location (gsi_stmt (*gsi));
475 temp.tp = tp;
476 new_seq = find_goto_replacement (tf, temp);
477 if (!new_seq)
478 return;
480 if (gimple_seq_singleton_p (new_seq)
481 && gimple_code (gimple_seq_first_stmt (new_seq)) == GIMPLE_GOTO)
483 *tp = gimple_goto_dest (gimple_seq_first_stmt (new_seq));
484 return;
487 label = create_artificial_label (loc);
488 /* Set the new label for the GIMPLE_COND */
489 *tp = label;
491 gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING);
492 gsi_insert_seq_after (gsi, gimple_seq_copy (new_seq), GSI_CONTINUE_LINKING);
495 /* The real work of replace_goto_queue. Returns with TSI updated to
496 point to the next statement. */
498 static void replace_goto_queue_stmt_list (gimple_seq, struct leh_tf_state *);
500 static void
501 replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
502 gimple_stmt_iterator *gsi)
504 gimple_seq seq;
505 treemple temp;
506 temp.g = NULL;
508 switch (gimple_code (stmt))
510 case GIMPLE_GOTO:
511 case GIMPLE_RETURN:
512 temp.g = stmt;
513 seq = find_goto_replacement (tf, temp);
514 if (seq)
516 gsi_insert_seq_before (gsi, gimple_seq_copy (seq), GSI_SAME_STMT);
517 gsi_remove (gsi, false);
518 return;
520 break;
522 case GIMPLE_COND:
523 replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 2), tf, gsi);
524 replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 3), tf, gsi);
525 break;
527 case GIMPLE_TRY:
528 replace_goto_queue_stmt_list (gimple_try_eval (stmt), tf);
529 replace_goto_queue_stmt_list (gimple_try_cleanup (stmt), tf);
530 break;
531 case GIMPLE_CATCH:
532 replace_goto_queue_stmt_list (gimple_catch_handler (stmt), tf);
533 break;
534 case GIMPLE_EH_FILTER:
535 replace_goto_queue_stmt_list (gimple_eh_filter_failure (stmt), tf);
536 break;
538 default:
539 /* These won't have gotos in them. */
540 break;
543 gsi_next (gsi);
546 /* A subroutine of replace_goto_queue. Handles GIMPLE_SEQ. */
548 static void
549 replace_goto_queue_stmt_list (gimple_seq seq, struct leh_tf_state *tf)
551 gimple_stmt_iterator gsi = gsi_start (seq);
553 while (!gsi_end_p (gsi))
554 replace_goto_queue_1 (gsi_stmt (gsi), tf, &gsi);
557 /* Replace all goto queue members. */
559 static void
560 replace_goto_queue (struct leh_tf_state *tf)
562 if (tf->goto_queue_active == 0)
563 return;
564 replace_goto_queue_stmt_list (tf->top_p_seq, tf);
565 replace_goto_queue_stmt_list (eh_seq, tf);
568 /* Add a new record to the goto queue contained in TF. NEW_STMT is the
569 data to be added, IS_LABEL indicates whether NEW_STMT is a label or
570 a gimple return. */
572 static void
573 record_in_goto_queue (struct leh_tf_state *tf,
574 treemple new_stmt,
575 int index,
576 bool is_label)
578 size_t active, size;
579 struct goto_queue_node *q;
581 gcc_assert (!tf->goto_queue_map);
583 active = tf->goto_queue_active;
584 size = tf->goto_queue_size;
585 if (active >= size)
587 size = (size ? size * 2 : 32);
588 tf->goto_queue_size = size;
589 tf->goto_queue
590 = XRESIZEVEC (struct goto_queue_node, tf->goto_queue, size);
593 q = &tf->goto_queue[active];
594 tf->goto_queue_active = active + 1;
596 memset (q, 0, sizeof (*q));
597 q->stmt = new_stmt;
598 q->index = index;
599 q->is_label = is_label;
602 /* Record the LABEL label in the goto queue contained in TF.
603 TF is not null. */
605 static void
606 record_in_goto_queue_label (struct leh_tf_state *tf, treemple stmt, tree label)
608 int index;
609 treemple temp, new_stmt;
611 if (!label)
612 return;
614 /* Computed and non-local gotos do not get processed. Given
615 their nature we can neither tell whether we've escaped the
616 finally block nor redirect them if we knew. */
617 if (TREE_CODE (label) != LABEL_DECL)
618 return;
620 /* No need to record gotos that don't leave the try block. */
621 temp.t = label;
622 if (!outside_finally_tree (temp, tf->try_finally_expr))
623 return;
625 if (! tf->dest_array)
627 tf->dest_array = VEC_alloc (tree, heap, 10);
628 VEC_quick_push (tree, tf->dest_array, label);
629 index = 0;
631 else
633 int n = VEC_length (tree, tf->dest_array);
634 for (index = 0; index < n; ++index)
635 if (VEC_index (tree, tf->dest_array, index) == label)
636 break;
637 if (index == n)
638 VEC_safe_push (tree, heap, tf->dest_array, label);
641 /* In the case of a GOTO we want to record the destination label,
642 since with a GIMPLE_COND we have an easy access to the then/else
643 labels. */
644 new_stmt = stmt;
645 record_in_goto_queue (tf, new_stmt, index, true);
648 /* For any GIMPLE_GOTO or GIMPLE_RETURN, decide whether it leaves a try_finally
649 node, and if so record that fact in the goto queue associated with that
650 try_finally node. */
652 static void
653 maybe_record_in_goto_queue (struct leh_state *state, gimple stmt)
655 struct leh_tf_state *tf = state->tf;
656 treemple new_stmt;
658 if (!tf)
659 return;
661 switch (gimple_code (stmt))
663 case GIMPLE_COND:
664 new_stmt.tp = gimple_op_ptr (stmt, 2);
665 record_in_goto_queue_label (tf, new_stmt, gimple_cond_true_label (stmt));
666 new_stmt.tp = gimple_op_ptr (stmt, 3);
667 record_in_goto_queue_label (tf, new_stmt, gimple_cond_false_label (stmt));
668 break;
669 case GIMPLE_GOTO:
670 new_stmt.g = stmt;
671 record_in_goto_queue_label (tf, new_stmt, gimple_goto_dest (stmt));
672 break;
674 case GIMPLE_RETURN:
675 tf->may_return = true;
676 new_stmt.g = stmt;
677 record_in_goto_queue (tf, new_stmt, -1, false);
678 break;
680 default:
681 gcc_unreachable ();
686 #ifdef ENABLE_CHECKING
687 /* We do not process GIMPLE_SWITCHes for now. As long as the original source
688 was in fact structured, and we've not yet done jump threading, then none
689 of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */
691 static void
692 verify_norecord_switch_expr (struct leh_state *state, gimple switch_expr)
694 struct leh_tf_state *tf = state->tf;
695 size_t i, n;
697 if (!tf)
698 return;
700 n = gimple_switch_num_labels (switch_expr);
702 for (i = 0; i < n; ++i)
704 treemple temp;
705 tree lab = CASE_LABEL (gimple_switch_label (switch_expr, i));
706 temp.t = lab;
707 gcc_assert (!outside_finally_tree (temp, tf->try_finally_expr));
710 #else
711 #define verify_norecord_switch_expr(state, switch_expr)
712 #endif
714 /* Redirect a RETURN_EXPR pointed to by STMT_P to FINLAB. Place in CONT_P
715 whatever is needed to finish the return. If MOD is non-null, insert it
716 before the new branch. RETURN_VALUE_P is a cache containing a temporary
717 variable to be used in manipulating the value returned from the function. */
719 static void
720 do_return_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod,
721 tree *return_value_p)
723 tree ret_expr;
724 gimple x;
726 /* In the case of a return, the queue node must be a gimple statement. */
727 gcc_assert (!q->is_label);
729 ret_expr = gimple_return_retval (q->stmt.g);
731 if (ret_expr)
733 if (!*return_value_p)
734 *return_value_p = ret_expr;
735 else
736 gcc_assert (*return_value_p == ret_expr);
737 q->cont_stmt = q->stmt.g;
738 /* The nasty part about redirecting the return value is that the
739 return value itself is to be computed before the FINALLY block
740 is executed. e.g.
742 int x;
743 int foo (void)
745 x = 0;
746 try {
747 return x;
748 } finally {
749 x++;
753 should return 0, not 1. Arrange for this to happen by copying
754 computed the return value into a local temporary. This also
755 allows us to redirect multiple return statements through the
756 same destination block; whether this is a net win or not really
757 depends, I guess, but it does make generation of the switch in
758 lower_try_finally_switch easier. */
760 if (TREE_CODE (ret_expr) == RESULT_DECL)
762 if (!*return_value_p)
763 *return_value_p = ret_expr;
764 else
765 gcc_assert (*return_value_p == ret_expr);
766 q->cont_stmt = q->stmt.g;
768 else
769 gcc_unreachable ();
771 else
772 /* If we don't return a value, all return statements are the same. */
773 q->cont_stmt = q->stmt.g;
775 if (!q->repl_stmt)
776 q->repl_stmt = gimple_seq_alloc ();
778 if (mod)
779 gimple_seq_add_seq (&q->repl_stmt, mod);
781 x = gimple_build_goto (finlab);
782 gimple_seq_add_stmt (&q->repl_stmt, x);
785 /* Similar, but easier, for GIMPLE_GOTO. */
787 static void
788 do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod,
789 struct leh_tf_state *tf)
791 gimple x;
793 gcc_assert (q->is_label);
794 if (!q->repl_stmt)
795 q->repl_stmt = gimple_seq_alloc ();
797 q->cont_stmt = gimple_build_goto (VEC_index (tree, tf->dest_array, q->index));
799 if (mod)
800 gimple_seq_add_seq (&q->repl_stmt, mod);
802 x = gimple_build_goto (finlab);
803 gimple_seq_add_stmt (&q->repl_stmt, x);
806 /* Emit a standard landing pad sequence into SEQ for REGION. */
808 static void
809 emit_post_landing_pad (gimple_seq *seq, eh_region region)
811 eh_landing_pad lp = region->landing_pads;
812 gimple x;
814 if (lp == NULL)
815 lp = gen_eh_landing_pad (region);
817 lp->post_landing_pad = create_artificial_label (UNKNOWN_LOCATION);
818 EH_LANDING_PAD_NR (lp->post_landing_pad) = lp->index;
820 x = gimple_build_label (lp->post_landing_pad);
821 gimple_seq_add_stmt (seq, x);
824 /* Emit a RESX statement into SEQ for REGION. */
826 static void
827 emit_resx (gimple_seq *seq, eh_region region)
829 gimple x = gimple_build_resx (region->index);
830 gimple_seq_add_stmt (seq, x);
831 if (region->outer)
832 record_stmt_eh_region (region->outer, x);
835 /* Emit an EH_DISPATCH statement into SEQ for REGION. */
837 static void
838 emit_eh_dispatch (gimple_seq *seq, eh_region region)
840 gimple x = gimple_build_eh_dispatch (region->index);
841 gimple_seq_add_stmt (seq, x);
844 /* Note that the current EH region may contain a throw, or a
845 call to a function which itself may contain a throw. */
847 static void
848 note_eh_region_may_contain_throw (eh_region region)
850 while (bitmap_set_bit (eh_region_may_contain_throw_map, region->index))
852 region = region->outer;
853 if (region == NULL)
854 break;
858 /* Check if REGION has been marked as containing a throw. If REGION is
859 NULL, this predicate is false. */
861 static inline bool
862 eh_region_may_contain_throw (eh_region r)
864 return r && bitmap_bit_p (eh_region_may_contain_throw_map, r->index);
867 /* We want to transform
868 try { body; } catch { stuff; }
870 normal_seqence:
871 body;
872 over:
873 eh_seqence:
874 landing_pad:
875 stuff;
876 goto over;
878 TP is a GIMPLE_TRY node. REGION is the region whose post_landing_pad
879 should be placed before the second operand, or NULL. OVER is
880 an existing label that should be put at the exit, or NULL. */
882 static gimple_seq
883 frob_into_branch_around (gimple tp, eh_region region, tree over)
885 gimple x;
886 gimple_seq cleanup, result;
887 location_t loc = gimple_location (tp);
889 cleanup = gimple_try_cleanup (tp);
890 result = gimple_try_eval (tp);
892 if (region)
893 emit_post_landing_pad (&eh_seq, region);
895 if (gimple_seq_may_fallthru (cleanup))
897 if (!over)
898 over = create_artificial_label (loc);
899 x = gimple_build_goto (over);
900 gimple_seq_add_stmt (&cleanup, x);
902 gimple_seq_add_seq (&eh_seq, cleanup);
904 if (over)
906 x = gimple_build_label (over);
907 gimple_seq_add_stmt (&result, x);
909 return result;
912 /* A subroutine of lower_try_finally. Duplicate the tree rooted at T.
913 Make sure to record all new labels found. */
915 static gimple_seq
916 lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state)
918 gimple region = NULL;
919 gimple_seq new_seq;
921 new_seq = copy_gimple_seq_and_replace_locals (seq);
923 if (outer_state->tf)
924 region = outer_state->tf->try_finally_expr;
925 collect_finally_tree_1 (new_seq, region);
927 return new_seq;
930 /* A subroutine of lower_try_finally. Create a fallthru label for
931 the given try_finally state. The only tricky bit here is that
932 we have to make sure to record the label in our outer context. */
934 static tree
935 lower_try_finally_fallthru_label (struct leh_tf_state *tf)
937 tree label = tf->fallthru_label;
938 treemple temp;
940 if (!label)
942 label = create_artificial_label (gimple_location (tf->try_finally_expr));
943 tf->fallthru_label = label;
944 if (tf->outer->tf)
946 temp.t = label;
947 record_in_finally_tree (temp, tf->outer->tf->try_finally_expr);
950 return label;
953 /* A subroutine of lower_try_finally. If the eh_protect_cleanup_actions
954 langhook returns non-null, then the language requires that the exception
955 path out of a try_finally be treated specially. To wit: the code within
956 the finally block may not itself throw an exception. We have two choices
957 here. First we can duplicate the finally block and wrap it in a
958 must_not_throw region. Second, we can generate code like
960 try {
961 finally_block;
962 } catch {
963 if (fintmp == eh_edge)
964 protect_cleanup_actions;
967 where "fintmp" is the temporary used in the switch statement generation
968 alternative considered below. For the nonce, we always choose the first
969 option.
971 THIS_STATE may be null if this is a try-cleanup, not a try-finally. */
973 static void
974 honor_protect_cleanup_actions (struct leh_state *outer_state,
975 struct leh_state *this_state,
976 struct leh_tf_state *tf)
978 tree protect_cleanup_actions;
979 gimple_stmt_iterator gsi;
980 bool finally_may_fallthru;
981 gimple_seq finally;
982 gimple x;
984 /* First check for nothing to do. */
985 if (lang_hooks.eh_protect_cleanup_actions == NULL)
986 return;
987 protect_cleanup_actions = lang_hooks.eh_protect_cleanup_actions ();
988 if (protect_cleanup_actions == NULL)
989 return;
991 finally = gimple_try_cleanup (tf->top_p);
992 finally_may_fallthru = gimple_seq_may_fallthru (finally);
994 /* Duplicate the FINALLY block. Only need to do this for try-finally,
995 and not for cleanups. */
996 if (this_state)
997 finally = lower_try_finally_dup_block (finally, outer_state);
999 /* If this cleanup consists of a TRY_CATCH_EXPR with TRY_CATCH_IS_CLEANUP
1000 set, the handler of the TRY_CATCH_EXPR is another cleanup which ought
1001 to be in an enclosing scope, but needs to be implemented at this level
1002 to avoid a nesting violation (see wrap_temporary_cleanups in
1003 cp/decl.c). Since it's logically at an outer level, we should call
1004 terminate before we get to it, so strip it away before adding the
1005 MUST_NOT_THROW filter. */
1006 gsi = gsi_start (finally);
1007 x = gsi_stmt (gsi);
1008 if (gimple_code (x) == GIMPLE_TRY
1009 && gimple_try_kind (x) == GIMPLE_TRY_CATCH
1010 && gimple_try_catch_is_cleanup (x))
1012 gsi_insert_seq_before (&gsi, gimple_try_eval (x), GSI_SAME_STMT);
1013 gsi_remove (&gsi, false);
1016 /* Wrap the block with protect_cleanup_actions as the action. */
1017 x = gimple_build_eh_must_not_throw (protect_cleanup_actions);
1018 x = gimple_build_try (finally, gimple_seq_alloc_with_stmt (x),
1019 GIMPLE_TRY_CATCH);
1020 finally = lower_eh_must_not_throw (outer_state, x);
1022 /* Drop all of this into the exception sequence. */
1023 emit_post_landing_pad (&eh_seq, tf->region);
1024 gimple_seq_add_seq (&eh_seq, finally);
1025 if (finally_may_fallthru)
1026 emit_resx (&eh_seq, tf->region);
1028 /* Having now been handled, EH isn't to be considered with
1029 the rest of the outgoing edges. */
1030 tf->may_throw = false;
1033 /* A subroutine of lower_try_finally. We have determined that there is
1034 no fallthru edge out of the finally block. This means that there is
1035 no outgoing edge corresponding to any incoming edge. Restructure the
1036 try_finally node for this special case. */
1038 static void
1039 lower_try_finally_nofallthru (struct leh_state *state,
1040 struct leh_tf_state *tf)
1042 tree lab, return_val;
1043 gimple x;
1044 gimple_seq finally;
1045 struct goto_queue_node *q, *qe;
1047 lab = create_artificial_label (gimple_location (tf->try_finally_expr));
1049 /* We expect that tf->top_p is a GIMPLE_TRY. */
1050 finally = gimple_try_cleanup (tf->top_p);
1051 tf->top_p_seq = gimple_try_eval (tf->top_p);
1053 x = gimple_build_label (lab);
1054 gimple_seq_add_stmt (&tf->top_p_seq, x);
1056 return_val = NULL;
1057 q = tf->goto_queue;
1058 qe = q + tf->goto_queue_active;
1059 for (; q < qe; ++q)
1060 if (q->index < 0)
1061 do_return_redirection (q, lab, NULL, &return_val);
1062 else
1063 do_goto_redirection (q, lab, NULL, tf);
1065 replace_goto_queue (tf);
1067 lower_eh_constructs_1 (state, finally);
1068 gimple_seq_add_seq (&tf->top_p_seq, finally);
1070 if (tf->may_throw)
1072 emit_post_landing_pad (&eh_seq, tf->region);
1074 x = gimple_build_goto (lab);
1075 gimple_seq_add_stmt (&eh_seq, x);
1079 /* A subroutine of lower_try_finally. We have determined that there is
1080 exactly one destination of the finally block. Restructure the
1081 try_finally node for this special case. */
1083 static void
1084 lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
1086 struct goto_queue_node *q, *qe;
1087 gimple x;
1088 gimple_seq finally;
1089 tree finally_label;
1090 location_t loc = gimple_location (tf->try_finally_expr);
1092 finally = gimple_try_cleanup (tf->top_p);
1093 tf->top_p_seq = gimple_try_eval (tf->top_p);
1095 lower_eh_constructs_1 (state, finally);
1097 if (tf->may_throw)
1099 /* Only reachable via the exception edge. Add the given label to
1100 the head of the FINALLY block. Append a RESX at the end. */
1101 emit_post_landing_pad (&eh_seq, tf->region);
1102 gimple_seq_add_seq (&eh_seq, finally);
1103 emit_resx (&eh_seq, tf->region);
1104 return;
1107 if (tf->may_fallthru)
1109 /* Only reachable via the fallthru edge. Do nothing but let
1110 the two blocks run together; we'll fall out the bottom. */
1111 gimple_seq_add_seq (&tf->top_p_seq, finally);
1112 return;
1115 finally_label = create_artificial_label (loc);
1116 x = gimple_build_label (finally_label);
1117 gimple_seq_add_stmt (&tf->top_p_seq, x);
1119 gimple_seq_add_seq (&tf->top_p_seq, finally);
1121 q = tf->goto_queue;
1122 qe = q + tf->goto_queue_active;
1124 if (tf->may_return)
1126 /* Reachable by return expressions only. Redirect them. */
1127 tree return_val = NULL;
1128 for (; q < qe; ++q)
1129 do_return_redirection (q, finally_label, NULL, &return_val);
1130 replace_goto_queue (tf);
1132 else
1134 /* Reachable by goto expressions only. Redirect them. */
1135 for (; q < qe; ++q)
1136 do_goto_redirection (q, finally_label, NULL, tf);
1137 replace_goto_queue (tf);
1139 if (VEC_index (tree, tf->dest_array, 0) == tf->fallthru_label)
1141 /* Reachable by goto to fallthru label only. Redirect it
1142 to the new label (already created, sadly), and do not
1143 emit the final branch out, or the fallthru label. */
1144 tf->fallthru_label = NULL;
1145 return;
1149 /* Place the original return/goto to the original destination
1150 immediately after the finally block. */
1151 x = tf->goto_queue[0].cont_stmt;
1152 gimple_seq_add_stmt (&tf->top_p_seq, x);
1153 maybe_record_in_goto_queue (state, x);
1156 /* A subroutine of lower_try_finally. There are multiple edges incoming
1157 and outgoing from the finally block. Implement this by duplicating the
1158 finally block for every destination. */
1160 static void
1161 lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
1163 gimple_seq finally;
1164 gimple_seq new_stmt;
1165 gimple_seq seq;
1166 gimple x;
1167 tree tmp;
1168 location_t tf_loc = gimple_location (tf->try_finally_expr);
1170 finally = gimple_try_cleanup (tf->top_p);
1171 tf->top_p_seq = gimple_try_eval (tf->top_p);
1172 new_stmt = NULL;
1174 if (tf->may_fallthru)
1176 seq = lower_try_finally_dup_block (finally, state);
1177 lower_eh_constructs_1 (state, seq);
1178 gimple_seq_add_seq (&new_stmt, seq);
1180 tmp = lower_try_finally_fallthru_label (tf);
1181 x = gimple_build_goto (tmp);
1182 gimple_seq_add_stmt (&new_stmt, x);
1185 if (tf->may_throw)
1187 seq = lower_try_finally_dup_block (finally, state);
1188 lower_eh_constructs_1 (state, seq);
1190 emit_post_landing_pad (&eh_seq, tf->region);
1191 gimple_seq_add_seq (&eh_seq, seq);
1192 emit_resx (&eh_seq, tf->region);
1195 if (tf->goto_queue)
1197 struct goto_queue_node *q, *qe;
1198 tree return_val = NULL;
1199 int return_index, index;
1200 struct labels_s
1202 struct goto_queue_node *q;
1203 tree label;
1204 } *labels;
1206 return_index = VEC_length (tree, tf->dest_array);
1207 labels = XCNEWVEC (struct labels_s, return_index + 1);
1209 q = tf->goto_queue;
1210 qe = q + tf->goto_queue_active;
1211 for (; q < qe; q++)
1213 index = q->index < 0 ? return_index : q->index;
1215 if (!labels[index].q)
1216 labels[index].q = q;
1219 for (index = 0; index < return_index + 1; index++)
1221 tree lab;
1223 q = labels[index].q;
1224 if (! q)
1225 continue;
1227 lab = labels[index].label
1228 = create_artificial_label (tf_loc);
1230 if (index == return_index)
1231 do_return_redirection (q, lab, NULL, &return_val);
1232 else
1233 do_goto_redirection (q, lab, NULL, tf);
1235 x = gimple_build_label (lab);
1236 gimple_seq_add_stmt (&new_stmt, x);
1238 seq = lower_try_finally_dup_block (finally, state);
1239 lower_eh_constructs_1 (state, seq);
1240 gimple_seq_add_seq (&new_stmt, seq);
1242 gimple_seq_add_stmt (&new_stmt, q->cont_stmt);
1243 maybe_record_in_goto_queue (state, q->cont_stmt);
1246 for (q = tf->goto_queue; q < qe; q++)
1248 tree lab;
1250 index = q->index < 0 ? return_index : q->index;
1252 if (labels[index].q == q)
1253 continue;
1255 lab = labels[index].label;
1257 if (index == return_index)
1258 do_return_redirection (q, lab, NULL, &return_val);
1259 else
1260 do_goto_redirection (q, lab, NULL, tf);
1263 replace_goto_queue (tf);
1264 free (labels);
1267 /* Need to link new stmts after running replace_goto_queue due
1268 to not wanting to process the same goto stmts twice. */
1269 gimple_seq_add_seq (&tf->top_p_seq, new_stmt);
1272 /* A subroutine of lower_try_finally. There are multiple edges incoming
1273 and outgoing from the finally block. Implement this by instrumenting
1274 each incoming edge and creating a switch statement at the end of the
1275 finally block that branches to the appropriate destination. */
1277 static void
1278 lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
1280 struct goto_queue_node *q, *qe;
1281 tree return_val = NULL;
1282 tree finally_tmp, finally_label;
1283 int return_index, eh_index, fallthru_index;
1284 int nlabels, ndests, j, last_case_index;
1285 tree last_case;
1286 VEC (tree,heap) *case_label_vec;
1287 gimple_seq switch_body;
1288 gimple x;
1289 tree tmp;
1290 gimple switch_stmt;
1291 gimple_seq finally;
1292 struct pointer_map_t *cont_map = NULL;
1293 /* The location of the TRY_FINALLY stmt. */
1294 location_t tf_loc = gimple_location (tf->try_finally_expr);
1295 /* The location of the finally block. */
1296 location_t finally_loc;
1298 switch_body = gimple_seq_alloc ();
1300 /* Mash the TRY block to the head of the chain. */
1301 finally = gimple_try_cleanup (tf->top_p);
1302 tf->top_p_seq = gimple_try_eval (tf->top_p);
1304 /* The location of the finally is either the last stmt in the finally
1305 block or the location of the TRY_FINALLY itself. */
1306 finally_loc = gimple_seq_last_stmt (tf->top_p_seq) != NULL ?
1307 gimple_location (gimple_seq_last_stmt (tf->top_p_seq))
1308 : tf_loc;
1310 /* Lower the finally block itself. */
1311 lower_eh_constructs_1 (state, finally);
1313 /* Prepare for switch statement generation. */
1314 nlabels = VEC_length (tree, tf->dest_array);
1315 return_index = nlabels;
1316 eh_index = return_index + tf->may_return;
1317 fallthru_index = eh_index + tf->may_throw;
1318 ndests = fallthru_index + tf->may_fallthru;
1320 finally_tmp = create_tmp_var (integer_type_node, "finally_tmp");
1321 finally_label = create_artificial_label (finally_loc);
1323 /* We use VEC_quick_push on case_label_vec throughout this function,
1324 since we know the size in advance and allocate precisely as muce
1325 space as needed. */
1326 case_label_vec = VEC_alloc (tree, heap, ndests);
1327 last_case = NULL;
1328 last_case_index = 0;
1330 /* Begin inserting code for getting to the finally block. Things
1331 are done in this order to correspond to the sequence the code is
1332 layed out. */
1334 if (tf->may_fallthru)
1336 x = gimple_build_assign (finally_tmp,
1337 build_int_cst (NULL, fallthru_index));
1338 gimple_seq_add_stmt (&tf->top_p_seq, x);
1340 last_case = build3 (CASE_LABEL_EXPR, void_type_node,
1341 build_int_cst (NULL, fallthru_index),
1342 NULL, create_artificial_label (tf_loc));
1343 VEC_quick_push (tree, case_label_vec, last_case);
1344 last_case_index++;
1346 x = gimple_build_label (CASE_LABEL (last_case));
1347 gimple_seq_add_stmt (&switch_body, x);
1349 tmp = lower_try_finally_fallthru_label (tf);
1350 x = gimple_build_goto (tmp);
1351 gimple_seq_add_stmt (&switch_body, x);
1354 if (tf->may_throw)
1356 emit_post_landing_pad (&eh_seq, tf->region);
1358 x = gimple_build_assign (finally_tmp,
1359 build_int_cst (NULL, eh_index));
1360 gimple_seq_add_stmt (&eh_seq, x);
1362 x = gimple_build_goto (finally_label);
1363 gimple_seq_add_stmt (&eh_seq, x);
1365 last_case = build3 (CASE_LABEL_EXPR, void_type_node,
1366 build_int_cst (NULL, eh_index),
1367 NULL, create_artificial_label (tf_loc));
1368 VEC_quick_push (tree, case_label_vec, last_case);
1369 last_case_index++;
1371 x = gimple_build_label (CASE_LABEL (last_case));
1372 gimple_seq_add_stmt (&eh_seq, x);
1373 emit_resx (&eh_seq, tf->region);
1376 x = gimple_build_label (finally_label);
1377 gimple_seq_add_stmt (&tf->top_p_seq, x);
1379 gimple_seq_add_seq (&tf->top_p_seq, finally);
1381 /* Redirect each incoming goto edge. */
1382 q = tf->goto_queue;
1383 qe = q + tf->goto_queue_active;
1384 j = last_case_index + tf->may_return;
1385 /* Prepare the assignments to finally_tmp that are executed upon the
1386 entrance through a particular edge. */
1387 for (; q < qe; ++q)
1389 gimple_seq mod;
1390 int switch_id;
1391 unsigned int case_index;
1393 mod = gimple_seq_alloc ();
1395 if (q->index < 0)
1397 x = gimple_build_assign (finally_tmp,
1398 build_int_cst (NULL, return_index));
1399 gimple_seq_add_stmt (&mod, x);
1400 do_return_redirection (q, finally_label, mod, &return_val);
1401 switch_id = return_index;
1403 else
1405 x = gimple_build_assign (finally_tmp,
1406 build_int_cst (NULL, q->index));
1407 gimple_seq_add_stmt (&mod, x);
1408 do_goto_redirection (q, finally_label, mod, tf);
1409 switch_id = q->index;
1412 case_index = j + q->index;
1413 if (VEC_length (tree, case_label_vec) <= case_index
1414 || !VEC_index (tree, case_label_vec, case_index))
1416 tree case_lab;
1417 void **slot;
1418 case_lab = build3 (CASE_LABEL_EXPR, void_type_node,
1419 build_int_cst (NULL, switch_id),
1420 NULL, NULL);
1421 /* We store the cont_stmt in the pointer map, so that we can recover
1422 it in the loop below. We don't create the new label while
1423 walking the goto_queue because pointers don't offer a stable
1424 order. */
1425 if (!cont_map)
1426 cont_map = pointer_map_create ();
1427 slot = pointer_map_insert (cont_map, case_lab);
1428 *slot = q->cont_stmt;
1429 VEC_quick_push (tree, case_label_vec, case_lab);
1432 for (j = last_case_index; j < last_case_index + nlabels; j++)
1434 tree label;
1435 gimple cont_stmt;
1436 void **slot;
1438 last_case = VEC_index (tree, case_label_vec, j);
1440 gcc_assert (last_case);
1441 gcc_assert (cont_map);
1443 slot = pointer_map_contains (cont_map, last_case);
1444 /* As the comment above suggests, CASE_LABEL (last_case) was just a
1445 placeholder, it does not store an actual label, yet. */
1446 gcc_assert (slot);
1447 cont_stmt = *(gimple *) slot;
1449 label = create_artificial_label (tf_loc);
1450 CASE_LABEL (last_case) = label;
1452 x = gimple_build_label (label);
1453 gimple_seq_add_stmt (&switch_body, x);
1454 gimple_seq_add_stmt (&switch_body, cont_stmt);
1455 maybe_record_in_goto_queue (state, cont_stmt);
1457 if (cont_map)
1458 pointer_map_destroy (cont_map);
1460 replace_goto_queue (tf);
1462 /* Make sure that the last case is the default label, as one is required.
1463 Then sort the labels, which is also required in GIMPLE. */
1464 CASE_LOW (last_case) = NULL;
1465 sort_case_labels (case_label_vec);
1467 /* Build the switch statement, setting last_case to be the default
1468 label. */
1469 switch_stmt = gimple_build_switch_vec (finally_tmp, last_case,
1470 case_label_vec);
1471 gimple_set_location (switch_stmt, finally_loc);
1473 /* Need to link SWITCH_STMT after running replace_goto_queue
1474 due to not wanting to process the same goto stmts twice. */
1475 gimple_seq_add_stmt (&tf->top_p_seq, switch_stmt);
1476 gimple_seq_add_seq (&tf->top_p_seq, switch_body);
1479 /* Decide whether or not we are going to duplicate the finally block.
1480 There are several considerations.
1482 First, if this is Java, then the finally block contains code
1483 written by the user. It has line numbers associated with it,
1484 so duplicating the block means it's difficult to set a breakpoint.
1485 Since controlling code generation via -g is verboten, we simply
1486 never duplicate code without optimization.
1488 Second, we'd like to prevent egregious code growth. One way to
1489 do this is to estimate the size of the finally block, multiply
1490 that by the number of copies we'd need to make, and compare against
1491 the estimate of the size of the switch machinery we'd have to add. */
1493 static bool
1494 decide_copy_try_finally (int ndests, gimple_seq finally)
1496 int f_estimate, sw_estimate;
1498 if (!optimize)
1499 return false;
1501 /* Finally estimate N times, plus N gotos. */
1502 f_estimate = count_insns_seq (finally, &eni_size_weights);
1503 f_estimate = (f_estimate + 1) * ndests;
1505 /* Switch statement (cost 10), N variable assignments, N gotos. */
1506 sw_estimate = 10 + 2 * ndests;
1508 /* Optimize for size clearly wants our best guess. */
1509 if (optimize_function_for_size_p (cfun))
1510 return f_estimate < sw_estimate;
1512 /* ??? These numbers are completely made up so far. */
1513 if (optimize > 1)
1514 return f_estimate < 100 || f_estimate < sw_estimate * 2;
1515 else
1516 return f_estimate < 40 || f_estimate * 2 < sw_estimate * 3;
1519 /* REG is the enclosing region for a possible cleanup region, or the region
1520 itself. Returns TRUE if such a region would be unreachable.
1522 Cleanup regions within a must-not-throw region aren't actually reachable
1523 even if there are throwing stmts within them, because the personality
1524 routine will call terminate before unwinding. */
1526 static bool
1527 cleanup_is_dead_in (eh_region reg)
1529 while (reg && reg->type == ERT_CLEANUP)
1530 reg = reg->outer;
1531 return (reg && reg->type == ERT_MUST_NOT_THROW);
1534 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_FINALLY nodes
1535 to a sequence of labels and blocks, plus the exception region trees
1536 that record all the magic. This is complicated by the need to
1537 arrange for the FINALLY block to be executed on all exits. */
1539 static gimple_seq
1540 lower_try_finally (struct leh_state *state, gimple tp)
1542 struct leh_tf_state this_tf;
1543 struct leh_state this_state;
1544 int ndests;
1545 gimple_seq old_eh_seq;
1547 /* Process the try block. */
1549 memset (&this_tf, 0, sizeof (this_tf));
1550 this_tf.try_finally_expr = tp;
1551 this_tf.top_p = tp;
1552 this_tf.outer = state;
1553 if (using_eh_for_cleanups_p && !cleanup_is_dead_in (state->cur_region))
1555 this_tf.region = gen_eh_region_cleanup (state->cur_region);
1556 this_state.cur_region = this_tf.region;
1558 else
1560 this_tf.region = NULL;
1561 this_state.cur_region = state->cur_region;
1564 this_state.ehp_region = state->ehp_region;
1565 this_state.tf = &this_tf;
1567 old_eh_seq = eh_seq;
1568 eh_seq = NULL;
1570 lower_eh_constructs_1 (&this_state, gimple_try_eval(tp));
1572 /* Determine if the try block is escaped through the bottom. */
1573 this_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp));
1575 /* Determine if any exceptions are possible within the try block. */
1576 if (this_tf.region)
1577 this_tf.may_throw = eh_region_may_contain_throw (this_tf.region);
1578 if (this_tf.may_throw)
1579 honor_protect_cleanup_actions (state, &this_state, &this_tf);
1581 /* Determine how many edges (still) reach the finally block. Or rather,
1582 how many destinations are reached by the finally block. Use this to
1583 determine how we process the finally block itself. */
1585 ndests = VEC_length (tree, this_tf.dest_array);
1586 ndests += this_tf.may_fallthru;
1587 ndests += this_tf.may_return;
1588 ndests += this_tf.may_throw;
1590 /* If the FINALLY block is not reachable, dike it out. */
1591 if (ndests == 0)
1593 gimple_seq_add_seq (&this_tf.top_p_seq, gimple_try_eval (tp));
1594 gimple_try_set_cleanup (tp, NULL);
1596 /* If the finally block doesn't fall through, then any destination
1597 we might try to impose there isn't reached either. There may be
1598 some minor amount of cleanup and redirection still needed. */
1599 else if (!gimple_seq_may_fallthru (gimple_try_cleanup (tp)))
1600 lower_try_finally_nofallthru (state, &this_tf);
1602 /* We can easily special-case redirection to a single destination. */
1603 else if (ndests == 1)
1604 lower_try_finally_onedest (state, &this_tf);
1605 else if (decide_copy_try_finally (ndests, gimple_try_cleanup (tp)))
1606 lower_try_finally_copy (state, &this_tf);
1607 else
1608 lower_try_finally_switch (state, &this_tf);
1610 /* If someone requested we add a label at the end of the transformed
1611 block, do so. */
1612 if (this_tf.fallthru_label)
1614 /* This must be reached only if ndests == 0. */
1615 gimple x = gimple_build_label (this_tf.fallthru_label);
1616 gimple_seq_add_stmt (&this_tf.top_p_seq, x);
1619 VEC_free (tree, heap, this_tf.dest_array);
1620 if (this_tf.goto_queue)
1621 free (this_tf.goto_queue);
1622 if (this_tf.goto_queue_map)
1623 pointer_map_destroy (this_tf.goto_queue_map);
1625 /* If there was an old (aka outer) eh_seq, append the current eh_seq.
1626 If there was no old eh_seq, then the append is trivially already done. */
1627 if (old_eh_seq)
1629 if (eh_seq == NULL)
1630 eh_seq = old_eh_seq;
1631 else
1633 gimple_seq new_eh_seq = eh_seq;
1634 eh_seq = old_eh_seq;
1635 gimple_seq_add_seq(&eh_seq, new_eh_seq);
1639 return this_tf.top_p_seq;
1642 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_CATCH with a
1643 list of GIMPLE_CATCH to a sequence of labels and blocks, plus the
1644 exception region trees that records all the magic. */
1646 static gimple_seq
1647 lower_catch (struct leh_state *state, gimple tp)
1649 eh_region try_region = NULL;
1650 struct leh_state this_state = *state;
1651 gimple_stmt_iterator gsi;
1652 tree out_label;
1653 gimple_seq new_seq;
1654 gimple x;
1655 location_t try_catch_loc = gimple_location (tp);
1657 if (flag_exceptions)
1659 try_region = gen_eh_region_try (state->cur_region);
1660 this_state.cur_region = try_region;
1663 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
1665 if (!eh_region_may_contain_throw (try_region))
1666 return gimple_try_eval (tp);
1668 new_seq = NULL;
1669 emit_eh_dispatch (&new_seq, try_region);
1670 emit_resx (&new_seq, try_region);
1672 this_state.cur_region = state->cur_region;
1673 this_state.ehp_region = try_region;
1675 out_label = NULL;
1676 for (gsi = gsi_start (gimple_try_cleanup (tp));
1677 !gsi_end_p (gsi);
1678 gsi_next (&gsi))
1680 eh_catch c;
1681 gimple gcatch;
1682 gimple_seq handler;
1684 gcatch = gsi_stmt (gsi);
1685 c = gen_eh_region_catch (try_region, gimple_catch_types (gcatch));
1687 handler = gimple_catch_handler (gcatch);
1688 lower_eh_constructs_1 (&this_state, handler);
1690 c->label = create_artificial_label (UNKNOWN_LOCATION);
1691 x = gimple_build_label (c->label);
1692 gimple_seq_add_stmt (&new_seq, x);
1694 gimple_seq_add_seq (&new_seq, handler);
1696 if (gimple_seq_may_fallthru (new_seq))
1698 if (!out_label)
1699 out_label = create_artificial_label (try_catch_loc);
1701 x = gimple_build_goto (out_label);
1702 gimple_seq_add_stmt (&new_seq, x);
1704 if (!c->type_list)
1705 break;
1708 gimple_try_set_cleanup (tp, new_seq);
1710 return frob_into_branch_around (tp, try_region, out_label);
1713 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with a
1714 GIMPLE_EH_FILTER to a sequence of labels and blocks, plus the exception
1715 region trees that record all the magic. */
1717 static gimple_seq
1718 lower_eh_filter (struct leh_state *state, gimple tp)
1720 struct leh_state this_state = *state;
1721 eh_region this_region = NULL;
1722 gimple inner, x;
1723 gimple_seq new_seq;
1725 inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
1727 if (flag_exceptions)
1729 this_region = gen_eh_region_allowed (state->cur_region,
1730 gimple_eh_filter_types (inner));
1731 this_state.cur_region = this_region;
1734 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
1736 if (!eh_region_may_contain_throw (this_region))
1737 return gimple_try_eval (tp);
1739 new_seq = NULL;
1740 this_state.cur_region = state->cur_region;
1741 this_state.ehp_region = this_region;
1743 emit_eh_dispatch (&new_seq, this_region);
1744 emit_resx (&new_seq, this_region);
1746 this_region->u.allowed.label = create_artificial_label (UNKNOWN_LOCATION);
1747 x = gimple_build_label (this_region->u.allowed.label);
1748 gimple_seq_add_stmt (&new_seq, x);
1750 lower_eh_constructs_1 (&this_state, gimple_eh_filter_failure (inner));
1751 gimple_seq_add_seq (&new_seq, gimple_eh_filter_failure (inner));
1753 gimple_try_set_cleanup (tp, new_seq);
1755 return frob_into_branch_around (tp, this_region, NULL);
1758 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with
1759 an GIMPLE_EH_MUST_NOT_THROW to a sequence of labels and blocks,
1760 plus the exception region trees that record all the magic. */
1762 static gimple_seq
1763 lower_eh_must_not_throw (struct leh_state *state, gimple tp)
1765 struct leh_state this_state = *state;
1767 if (flag_exceptions)
1769 gimple inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
1770 eh_region this_region;
1772 this_region = gen_eh_region_must_not_throw (state->cur_region);
1773 this_region->u.must_not_throw.failure_decl
1774 = gimple_eh_must_not_throw_fndecl (inner);
1775 this_region->u.must_not_throw.failure_loc = gimple_location (tp);
1777 /* In order to get mangling applied to this decl, we must mark it
1778 used now. Otherwise, pass_ipa_free_lang_data won't think it
1779 needs to happen. */
1780 TREE_USED (this_region->u.must_not_throw.failure_decl) = 1;
1782 this_state.cur_region = this_region;
1785 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
1787 return gimple_try_eval (tp);
1790 /* Implement a cleanup expression. This is similar to try-finally,
1791 except that we only execute the cleanup block for exception edges. */
1793 static gimple_seq
1794 lower_cleanup (struct leh_state *state, gimple tp)
1796 struct leh_state this_state = *state;
1797 eh_region this_region = NULL;
1798 struct leh_tf_state fake_tf;
1799 gimple_seq result;
1800 bool cleanup_dead = cleanup_is_dead_in (state->cur_region);
1802 if (flag_exceptions && !cleanup_dead)
1804 this_region = gen_eh_region_cleanup (state->cur_region);
1805 this_state.cur_region = this_region;
1808 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
1810 if (cleanup_dead || !eh_region_may_contain_throw (this_region))
1811 return gimple_try_eval (tp);
1813 /* Build enough of a try-finally state so that we can reuse
1814 honor_protect_cleanup_actions. */
1815 memset (&fake_tf, 0, sizeof (fake_tf));
1816 fake_tf.top_p = fake_tf.try_finally_expr = tp;
1817 fake_tf.outer = state;
1818 fake_tf.region = this_region;
1819 fake_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp));
1820 fake_tf.may_throw = true;
1822 honor_protect_cleanup_actions (state, NULL, &fake_tf);
1824 if (fake_tf.may_throw)
1826 /* In this case honor_protect_cleanup_actions had nothing to do,
1827 and we should process this normally. */
1828 lower_eh_constructs_1 (state, gimple_try_cleanup (tp));
1829 result = frob_into_branch_around (tp, this_region,
1830 fake_tf.fallthru_label);
1832 else
1834 /* In this case honor_protect_cleanup_actions did nearly all of
1835 the work. All we have left is to append the fallthru_label. */
1837 result = gimple_try_eval (tp);
1838 if (fake_tf.fallthru_label)
1840 gimple x = gimple_build_label (fake_tf.fallthru_label);
1841 gimple_seq_add_stmt (&result, x);
1844 return result;
1847 /* Main loop for lowering eh constructs. Also moves gsi to the next
1848 statement. */
1850 static void
1851 lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
1853 gimple_seq replace;
1854 gimple x;
1855 gimple stmt = gsi_stmt (*gsi);
1857 switch (gimple_code (stmt))
1859 case GIMPLE_CALL:
1861 tree fndecl = gimple_call_fndecl (stmt);
1862 tree rhs, lhs;
1864 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
1865 switch (DECL_FUNCTION_CODE (fndecl))
1867 case BUILT_IN_EH_POINTER:
1868 /* The front end may have generated a call to
1869 __builtin_eh_pointer (0) within a catch region. Replace
1870 this zero argument with the current catch region number. */
1871 if (state->ehp_region)
1873 tree nr = build_int_cst (NULL, state->ehp_region->index);
1874 gimple_call_set_arg (stmt, 0, nr);
1876 else
1878 /* The user has dome something silly. Remove it. */
1879 rhs = null_pointer_node;
1880 goto do_replace;
1882 break;
1884 case BUILT_IN_EH_FILTER:
1885 /* ??? This should never appear, but since it's a builtin it
1886 is accessible to abuse by users. Just remove it and
1887 replace the use with the arbitrary value zero. */
1888 rhs = build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
1889 do_replace:
1890 lhs = gimple_call_lhs (stmt);
1891 x = gimple_build_assign (lhs, rhs);
1892 gsi_insert_before (gsi, x, GSI_SAME_STMT);
1893 /* FALLTHRU */
1895 case BUILT_IN_EH_COPY_VALUES:
1896 /* Likewise this should not appear. Remove it. */
1897 gsi_remove (gsi, true);
1898 return;
1900 default:
1901 break;
1904 /* FALLTHRU */
1906 case GIMPLE_ASSIGN:
1907 /* If the stmt can throw use a new temporary for the assignment
1908 to a LHS. This makes sure the old value of the LHS is
1909 available on the EH edge. Only do so for statements that
1910 potentially fall thru (no noreturn calls e.g.), otherwise
1911 this new assignment might create fake fallthru regions. */
1912 if (stmt_could_throw_p (stmt)
1913 && gimple_has_lhs (stmt)
1914 && gimple_stmt_may_fallthru (stmt)
1915 && !tree_could_throw_p (gimple_get_lhs (stmt))
1916 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
1918 tree lhs = gimple_get_lhs (stmt);
1919 tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
1920 gimple s = gimple_build_assign (lhs, tmp);
1921 gimple_set_location (s, gimple_location (stmt));
1922 gimple_set_block (s, gimple_block (stmt));
1923 gimple_set_lhs (stmt, tmp);
1924 if (TREE_CODE (TREE_TYPE (tmp)) == COMPLEX_TYPE
1925 || TREE_CODE (TREE_TYPE (tmp)) == VECTOR_TYPE)
1926 DECL_GIMPLE_REG_P (tmp) = 1;
1927 gsi_insert_after (gsi, s, GSI_SAME_STMT);
1929 /* Look for things that can throw exceptions, and record them. */
1930 if (state->cur_region && stmt_could_throw_p (stmt))
1932 record_stmt_eh_region (state->cur_region, stmt);
1933 note_eh_region_may_contain_throw (state->cur_region);
1935 break;
1937 case GIMPLE_COND:
1938 case GIMPLE_GOTO:
1939 case GIMPLE_RETURN:
1940 maybe_record_in_goto_queue (state, stmt);
1941 break;
1943 case GIMPLE_SWITCH:
1944 verify_norecord_switch_expr (state, stmt);
1945 break;
1947 case GIMPLE_TRY:
1948 if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
1949 replace = lower_try_finally (state, stmt);
1950 else
1952 x = gimple_seq_first_stmt (gimple_try_cleanup (stmt));
1953 if (!x)
1955 replace = gimple_try_eval (stmt);
1956 lower_eh_constructs_1 (state, replace);
1958 else
1959 switch (gimple_code (x))
1961 case GIMPLE_CATCH:
1962 replace = lower_catch (state, stmt);
1963 break;
1964 case GIMPLE_EH_FILTER:
1965 replace = lower_eh_filter (state, stmt);
1966 break;
1967 case GIMPLE_EH_MUST_NOT_THROW:
1968 replace = lower_eh_must_not_throw (state, stmt);
1969 break;
1970 default:
1971 replace = lower_cleanup (state, stmt);
1972 break;
1976 /* Remove the old stmt and insert the transformed sequence
1977 instead. */
1978 gsi_insert_seq_before (gsi, replace, GSI_SAME_STMT);
1979 gsi_remove (gsi, true);
1981 /* Return since we don't want gsi_next () */
1982 return;
1984 default:
1985 /* A type, a decl, or some kind of statement that we're not
1986 interested in. Don't walk them. */
1987 break;
1990 gsi_next (gsi);
1993 /* A helper to unwrap a gimple_seq and feed stmts to lower_eh_constructs_2. */
1995 static void
1996 lower_eh_constructs_1 (struct leh_state *state, gimple_seq seq)
1998 gimple_stmt_iterator gsi;
1999 for (gsi = gsi_start (seq); !gsi_end_p (gsi);)
2000 lower_eh_constructs_2 (state, &gsi);
2003 static unsigned int
2004 lower_eh_constructs (void)
2006 struct leh_state null_state;
2007 gimple_seq bodyp;
2009 bodyp = gimple_body (current_function_decl);
2010 if (bodyp == NULL)
2011 return 0;
2013 finally_tree = htab_create (31, struct_ptr_hash, struct_ptr_eq, free);
2014 eh_region_may_contain_throw_map = BITMAP_ALLOC (NULL);
2015 memset (&null_state, 0, sizeof (null_state));
2017 collect_finally_tree_1 (bodyp, NULL);
2018 lower_eh_constructs_1 (&null_state, bodyp);
2020 /* We assume there's a return statement, or something, at the end of
2021 the function, and thus ploping the EH sequence afterward won't
2022 change anything. */
2023 gcc_assert (!gimple_seq_may_fallthru (bodyp));
2024 gimple_seq_add_seq (&bodyp, eh_seq);
2026 /* We assume that since BODYP already existed, adding EH_SEQ to it
2027 didn't change its value, and we don't have to re-set the function. */
2028 gcc_assert (bodyp == gimple_body (current_function_decl));
2030 htab_delete (finally_tree);
2031 BITMAP_FREE (eh_region_may_contain_throw_map);
2032 eh_seq = NULL;
2034 /* If this function needs a language specific EH personality routine
2035 and the frontend didn't already set one do so now. */
2036 if (function_needs_eh_personality (cfun) == eh_personality_lang
2037 && !DECL_FUNCTION_PERSONALITY (current_function_decl))
2038 DECL_FUNCTION_PERSONALITY (current_function_decl)
2039 = lang_hooks.eh_personality ();
2041 return 0;
2044 struct gimple_opt_pass pass_lower_eh =
2047 GIMPLE_PASS,
2048 "eh", /* name */
2049 NULL, /* gate */
2050 lower_eh_constructs, /* execute */
2051 NULL, /* sub */
2052 NULL, /* next */
2053 0, /* static_pass_number */
2054 TV_TREE_EH, /* tv_id */
2055 PROP_gimple_lcf, /* properties_required */
2056 PROP_gimple_leh, /* properties_provided */
2057 0, /* properties_destroyed */
2058 0, /* todo_flags_start */
2059 TODO_dump_func /* todo_flags_finish */
2063 /* Create the multiple edges from an EH_DISPATCH statement to all of
2064 the possible handlers for its EH region. Return true if there's
2065 no fallthru edge; false if there is. */
2067 bool
2068 make_eh_dispatch_edges (gimple stmt)
2070 eh_region r;
2071 eh_catch c;
2072 basic_block src, dst;
2074 r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt));
2075 src = gimple_bb (stmt);
2077 switch (r->type)
2079 case ERT_TRY:
2080 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
2082 dst = label_to_block (c->label);
2083 make_edge (src, dst, 0);
2085 /* A catch-all handler doesn't have a fallthru. */
2086 if (c->type_list == NULL)
2087 return false;
2089 break;
2091 case ERT_ALLOWED_EXCEPTIONS:
2092 dst = label_to_block (r->u.allowed.label);
2093 make_edge (src, dst, 0);
2094 break;
2096 default:
2097 gcc_unreachable ();
2100 return true;
2103 /* Create the single EH edge from STMT to its nearest landing pad,
2104 if there is such a landing pad within the current function. */
2106 void
2107 make_eh_edges (gimple stmt)
2109 basic_block src, dst;
2110 eh_landing_pad lp;
2111 int lp_nr;
2113 lp_nr = lookup_stmt_eh_lp (stmt);
2114 if (lp_nr <= 0)
2115 return;
2117 lp = get_eh_landing_pad_from_number (lp_nr);
2118 gcc_assert (lp != NULL);
2120 src = gimple_bb (stmt);
2121 dst = label_to_block (lp->post_landing_pad);
2122 make_edge (src, dst, EDGE_EH);
2125 /* Do the work in redirecting EDGE_IN to NEW_BB within the EH region tree;
2126 do not actually perform the final edge redirection.
2128 CHANGE_REGION is true when we're being called from cleanup_empty_eh and
2129 we intend to change the destination EH region as well; this means
2130 EH_LANDING_PAD_NR must already be set on the destination block label.
2131 If false, we're being called from generic cfg manipulation code and we
2132 should preserve our place within the region tree. */
2134 static void
2135 redirect_eh_edge_1 (edge edge_in, basic_block new_bb, bool change_region)
2137 eh_landing_pad old_lp, new_lp;
2138 basic_block old_bb;
2139 gimple throw_stmt;
2140 int old_lp_nr, new_lp_nr;
2141 tree old_label, new_label;
2142 edge_iterator ei;
2143 edge e;
2145 old_bb = edge_in->dest;
2146 old_label = gimple_block_label (old_bb);
2147 old_lp_nr = EH_LANDING_PAD_NR (old_label);
2148 gcc_assert (old_lp_nr > 0);
2149 old_lp = get_eh_landing_pad_from_number (old_lp_nr);
2151 throw_stmt = last_stmt (edge_in->src);
2152 gcc_assert (lookup_stmt_eh_lp (throw_stmt) == old_lp_nr);
2154 new_label = gimple_block_label (new_bb);
2156 /* Look for an existing region that might be using NEW_BB already. */
2157 new_lp_nr = EH_LANDING_PAD_NR (new_label);
2158 if (new_lp_nr)
2160 new_lp = get_eh_landing_pad_from_number (new_lp_nr);
2161 gcc_assert (new_lp);
2163 /* Unless CHANGE_REGION is true, the new and old landing pad
2164 had better be associated with the same EH region. */
2165 gcc_assert (change_region || new_lp->region == old_lp->region);
2167 else
2169 new_lp = NULL;
2170 gcc_assert (!change_region);
2173 /* Notice when we redirect the last EH edge away from OLD_BB. */
2174 FOR_EACH_EDGE (e, ei, old_bb->preds)
2175 if (e != edge_in && (e->flags & EDGE_EH))
2176 break;
2178 if (new_lp)
2180 /* NEW_LP already exists. If there are still edges into OLD_LP,
2181 there's nothing to do with the EH tree. If there are no more
2182 edges into OLD_LP, then we want to remove OLD_LP as it is unused.
2183 If CHANGE_REGION is true, then our caller is expecting to remove
2184 the landing pad. */
2185 if (e == NULL && !change_region)
2186 remove_eh_landing_pad (old_lp);
2188 else
2190 /* No correct landing pad exists. If there are no more edges
2191 into OLD_LP, then we can simply re-use the existing landing pad.
2192 Otherwise, we have to create a new landing pad. */
2193 if (e == NULL)
2195 EH_LANDING_PAD_NR (old_lp->post_landing_pad) = 0;
2196 new_lp = old_lp;
2198 else
2199 new_lp = gen_eh_landing_pad (old_lp->region);
2200 new_lp->post_landing_pad = new_label;
2201 EH_LANDING_PAD_NR (new_label) = new_lp->index;
2204 /* Maybe move the throwing statement to the new region. */
2205 if (old_lp != new_lp)
2207 remove_stmt_from_eh_lp (throw_stmt);
2208 add_stmt_to_eh_lp (throw_stmt, new_lp->index);
2212 /* Redirect EH edge E to NEW_BB. */
2214 edge
2215 redirect_eh_edge (edge edge_in, basic_block new_bb)
2217 redirect_eh_edge_1 (edge_in, new_bb, false);
2218 return ssa_redirect_edge (edge_in, new_bb);
2221 /* This is a subroutine of gimple_redirect_edge_and_branch. Update the
2222 labels for redirecting a non-fallthru EH_DISPATCH edge E to NEW_BB.
2223 The actual edge update will happen in the caller. */
2225 void
2226 redirect_eh_dispatch_edge (gimple stmt, edge e, basic_block new_bb)
2228 tree new_lab = gimple_block_label (new_bb);
2229 bool any_changed = false;
2230 basic_block old_bb;
2231 eh_region r;
2232 eh_catch c;
2234 r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt));
2235 switch (r->type)
2237 case ERT_TRY:
2238 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
2240 old_bb = label_to_block (c->label);
2241 if (old_bb == e->dest)
2243 c->label = new_lab;
2244 any_changed = true;
2247 break;
2249 case ERT_ALLOWED_EXCEPTIONS:
2250 old_bb = label_to_block (r->u.allowed.label);
2251 gcc_assert (old_bb == e->dest);
2252 r->u.allowed.label = new_lab;
2253 any_changed = true;
2254 break;
2256 default:
2257 gcc_unreachable ();
2260 gcc_assert (any_changed);
2263 /* Helper function for operation_could_trap_p and stmt_could_throw_p. */
2265 bool
2266 operation_could_trap_helper_p (enum tree_code op,
2267 bool fp_operation,
2268 bool honor_trapv,
2269 bool honor_nans,
2270 bool honor_snans,
2271 tree divisor,
2272 bool *handled)
2274 *handled = true;
2275 switch (op)
2277 case TRUNC_DIV_EXPR:
2278 case CEIL_DIV_EXPR:
2279 case FLOOR_DIV_EXPR:
2280 case ROUND_DIV_EXPR:
2281 case EXACT_DIV_EXPR:
2282 case CEIL_MOD_EXPR:
2283 case FLOOR_MOD_EXPR:
2284 case ROUND_MOD_EXPR:
2285 case TRUNC_MOD_EXPR:
2286 case RDIV_EXPR:
2287 if (honor_snans || honor_trapv)
2288 return true;
2289 if (fp_operation)
2290 return flag_trapping_math;
2291 if (!TREE_CONSTANT (divisor) || integer_zerop (divisor))
2292 return true;
2293 return false;
2295 case LT_EXPR:
2296 case LE_EXPR:
2297 case GT_EXPR:
2298 case GE_EXPR:
2299 case LTGT_EXPR:
2300 /* Some floating point comparisons may trap. */
2301 return honor_nans;
2303 case EQ_EXPR:
2304 case NE_EXPR:
2305 case UNORDERED_EXPR:
2306 case ORDERED_EXPR:
2307 case UNLT_EXPR:
2308 case UNLE_EXPR:
2309 case UNGT_EXPR:
2310 case UNGE_EXPR:
2311 case UNEQ_EXPR:
2312 return honor_snans;
2314 case CONVERT_EXPR:
2315 case FIX_TRUNC_EXPR:
2316 /* Conversion of floating point might trap. */
2317 return honor_nans;
2319 case NEGATE_EXPR:
2320 case ABS_EXPR:
2321 case CONJ_EXPR:
2322 /* These operations don't trap with floating point. */
2323 if (honor_trapv)
2324 return true;
2325 return false;
2327 case PLUS_EXPR:
2328 case MINUS_EXPR:
2329 case MULT_EXPR:
2330 /* Any floating arithmetic may trap. */
2331 if (fp_operation && flag_trapping_math)
2332 return true;
2333 if (honor_trapv)
2334 return true;
2335 return false;
2337 case COMPLEX_EXPR:
2338 case CONSTRUCTOR:
2339 /* Constructing an object cannot trap. */
2340 return false;
2342 default:
2343 /* Any floating arithmetic may trap. */
2344 if (fp_operation && flag_trapping_math)
2345 return true;
2347 *handled = false;
2348 return false;
2352 /* Return true if operation OP may trap. FP_OPERATION is true if OP is applied
2353 on floating-point values. HONOR_TRAPV is true if OP is applied on integer
2354 type operands that may trap. If OP is a division operator, DIVISOR contains
2355 the value of the divisor. */
2357 bool
2358 operation_could_trap_p (enum tree_code op, bool fp_operation, bool honor_trapv,
2359 tree divisor)
2361 bool honor_nans = (fp_operation && flag_trapping_math
2362 && !flag_finite_math_only);
2363 bool honor_snans = fp_operation && flag_signaling_nans != 0;
2364 bool handled;
2366 if (TREE_CODE_CLASS (op) != tcc_comparison
2367 && TREE_CODE_CLASS (op) != tcc_unary
2368 && TREE_CODE_CLASS (op) != tcc_binary)
2369 return false;
2371 return operation_could_trap_helper_p (op, fp_operation, honor_trapv,
2372 honor_nans, honor_snans, divisor,
2373 &handled);
2376 /* Return true if EXPR can trap, as in dereferencing an invalid pointer
2377 location or floating point arithmetic. C.f. the rtl version, may_trap_p.
2378 This routine expects only GIMPLE lhs or rhs input. */
2380 bool
2381 tree_could_trap_p (tree expr)
2383 enum tree_code code;
2384 bool fp_operation = false;
2385 bool honor_trapv = false;
2386 tree t, base, div = NULL_TREE;
2388 if (!expr)
2389 return false;
2391 code = TREE_CODE (expr);
2392 t = TREE_TYPE (expr);
2394 if (t)
2396 if (COMPARISON_CLASS_P (expr))
2397 fp_operation = FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0)));
2398 else
2399 fp_operation = FLOAT_TYPE_P (t);
2400 honor_trapv = INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t);
2403 if (TREE_CODE_CLASS (code) == tcc_binary)
2404 div = TREE_OPERAND (expr, 1);
2405 if (operation_could_trap_p (code, fp_operation, honor_trapv, div))
2406 return true;
2408 restart:
2409 switch (code)
2411 case TARGET_MEM_REF:
2412 if (TREE_CODE (TMR_BASE (expr)) == ADDR_EXPR
2413 && !TMR_INDEX (expr) && !TMR_INDEX2 (expr))
2414 return false;
2415 return !TREE_THIS_NOTRAP (expr);
2417 case COMPONENT_REF:
2418 case REALPART_EXPR:
2419 case IMAGPART_EXPR:
2420 case BIT_FIELD_REF:
2421 case VIEW_CONVERT_EXPR:
2422 case WITH_SIZE_EXPR:
2423 expr = TREE_OPERAND (expr, 0);
2424 code = TREE_CODE (expr);
2425 goto restart;
2427 case ARRAY_RANGE_REF:
2428 base = TREE_OPERAND (expr, 0);
2429 if (tree_could_trap_p (base))
2430 return true;
2431 if (TREE_THIS_NOTRAP (expr))
2432 return false;
2433 return !range_in_array_bounds_p (expr);
2435 case ARRAY_REF:
2436 base = TREE_OPERAND (expr, 0);
2437 if (tree_could_trap_p (base))
2438 return true;
2439 if (TREE_THIS_NOTRAP (expr))
2440 return false;
2441 return !in_array_bounds_p (expr);
2443 case MEM_REF:
2444 if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR)
2445 return false;
2446 /* Fallthru. */
2447 case INDIRECT_REF:
2448 return !TREE_THIS_NOTRAP (expr);
2450 case ASM_EXPR:
2451 return TREE_THIS_VOLATILE (expr);
2453 case CALL_EXPR:
2454 t = get_callee_fndecl (expr);
2455 /* Assume that calls to weak functions may trap. */
2456 if (!t || !DECL_P (t) || DECL_WEAK (t))
2457 return true;
2458 return false;
2460 default:
2461 return false;
2466 /* Helper for stmt_could_throw_p. Return true if STMT (assumed to be a
2467 an assignment or a conditional) may throw. */
2469 static bool
2470 stmt_could_throw_1_p (gimple stmt)
2472 enum tree_code code = gimple_expr_code (stmt);
2473 bool honor_nans = false;
2474 bool honor_snans = false;
2475 bool fp_operation = false;
2476 bool honor_trapv = false;
2477 tree t;
2478 size_t i;
2479 bool handled, ret;
2481 if (TREE_CODE_CLASS (code) == tcc_comparison
2482 || TREE_CODE_CLASS (code) == tcc_unary
2483 || TREE_CODE_CLASS (code) == tcc_binary)
2485 t = gimple_expr_type (stmt);
2486 fp_operation = FLOAT_TYPE_P (t);
2487 if (fp_operation)
2489 honor_nans = flag_trapping_math && !flag_finite_math_only;
2490 honor_snans = flag_signaling_nans != 0;
2492 else if (INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t))
2493 honor_trapv = true;
2496 /* Check if the main expression may trap. */
2497 t = is_gimple_assign (stmt) ? gimple_assign_rhs2 (stmt) : NULL;
2498 ret = operation_could_trap_helper_p (code, fp_operation, honor_trapv,
2499 honor_nans, honor_snans, t,
2500 &handled);
2501 if (handled)
2502 return ret;
2504 /* If the expression does not trap, see if any of the individual operands may
2505 trap. */
2506 for (i = 0; i < gimple_num_ops (stmt); i++)
2507 if (tree_could_trap_p (gimple_op (stmt, i)))
2508 return true;
2510 return false;
2514 /* Return true if statement STMT could throw an exception. */
2516 bool
2517 stmt_could_throw_p (gimple stmt)
2519 if (!flag_exceptions)
2520 return false;
2522 /* The only statements that can throw an exception are assignments,
2523 conditionals, calls, resx, and asms. */
2524 switch (gimple_code (stmt))
2526 case GIMPLE_RESX:
2527 return true;
2529 case GIMPLE_CALL:
2530 return !gimple_call_nothrow_p (stmt);
2532 case GIMPLE_ASSIGN:
2533 case GIMPLE_COND:
2534 if (!cfun->can_throw_non_call_exceptions)
2535 return false;
2536 return stmt_could_throw_1_p (stmt);
2538 case GIMPLE_ASM:
2539 if (!cfun->can_throw_non_call_exceptions)
2540 return false;
2541 return gimple_asm_volatile_p (stmt);
2543 default:
2544 return false;
2549 /* Return true if expression T could throw an exception. */
2551 bool
2552 tree_could_throw_p (tree t)
2554 if (!flag_exceptions)
2555 return false;
2556 if (TREE_CODE (t) == MODIFY_EXPR)
2558 if (cfun->can_throw_non_call_exceptions
2559 && tree_could_trap_p (TREE_OPERAND (t, 0)))
2560 return true;
2561 t = TREE_OPERAND (t, 1);
2564 if (TREE_CODE (t) == WITH_SIZE_EXPR)
2565 t = TREE_OPERAND (t, 0);
2566 if (TREE_CODE (t) == CALL_EXPR)
2567 return (call_expr_flags (t) & ECF_NOTHROW) == 0;
2568 if (cfun->can_throw_non_call_exceptions)
2569 return tree_could_trap_p (t);
2570 return false;
2573 /* Return true if STMT can throw an exception that is not caught within
2574 the current function (CFUN). */
2576 bool
2577 stmt_can_throw_external (gimple stmt)
2579 int lp_nr;
2581 if (!stmt_could_throw_p (stmt))
2582 return false;
2584 lp_nr = lookup_stmt_eh_lp (stmt);
2585 return lp_nr == 0;
2588 /* Return true if STMT can throw an exception that is caught within
2589 the current function (CFUN). */
2591 bool
2592 stmt_can_throw_internal (gimple stmt)
2594 int lp_nr;
2596 if (!stmt_could_throw_p (stmt))
2597 return false;
2599 lp_nr = lookup_stmt_eh_lp (stmt);
2600 return lp_nr > 0;
2603 /* Given a statement STMT in IFUN, if STMT can no longer throw, then
2604 remove any entry it might have from the EH table. Return true if
2605 any change was made. */
2607 bool
2608 maybe_clean_eh_stmt_fn (struct function *ifun, gimple stmt)
2610 if (stmt_could_throw_p (stmt))
2611 return false;
2612 return remove_stmt_from_eh_lp_fn (ifun, stmt);
2615 /* Likewise, but always use the current function. */
2617 bool
2618 maybe_clean_eh_stmt (gimple stmt)
2620 return maybe_clean_eh_stmt_fn (cfun, stmt);
2623 /* Given a statement OLD_STMT and a new statement NEW_STMT that has replaced
2624 OLD_STMT in the function, remove OLD_STMT from the EH table and put NEW_STMT
2625 in the table if it should be in there. Return TRUE if a replacement was
2626 done that my require an EH edge purge. */
2628 bool
2629 maybe_clean_or_replace_eh_stmt (gimple old_stmt, gimple new_stmt)
2631 int lp_nr = lookup_stmt_eh_lp (old_stmt);
2633 if (lp_nr != 0)
2635 bool new_stmt_could_throw = stmt_could_throw_p (new_stmt);
2637 if (new_stmt == old_stmt && new_stmt_could_throw)
2638 return false;
2640 remove_stmt_from_eh_lp (old_stmt);
2641 if (new_stmt_could_throw)
2643 add_stmt_to_eh_lp (new_stmt, lp_nr);
2644 return false;
2646 else
2647 return true;
2650 return false;
2653 /* Given a statement OLD_STMT in OLD_FUN and a duplicate statment NEW_STMT
2654 in NEW_FUN, copy the EH table data from OLD_STMT to NEW_STMT. The MAP
2655 operand is the return value of duplicate_eh_regions. */
2657 bool
2658 maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple new_stmt,
2659 struct function *old_fun, gimple old_stmt,
2660 struct pointer_map_t *map, int default_lp_nr)
2662 int old_lp_nr, new_lp_nr;
2663 void **slot;
2665 if (!stmt_could_throw_p (new_stmt))
2666 return false;
2668 old_lp_nr = lookup_stmt_eh_lp_fn (old_fun, old_stmt);
2669 if (old_lp_nr == 0)
2671 if (default_lp_nr == 0)
2672 return false;
2673 new_lp_nr = default_lp_nr;
2675 else if (old_lp_nr > 0)
2677 eh_landing_pad old_lp, new_lp;
2679 old_lp = VEC_index (eh_landing_pad, old_fun->eh->lp_array, old_lp_nr);
2680 slot = pointer_map_contains (map, old_lp);
2681 new_lp = (eh_landing_pad) *slot;
2682 new_lp_nr = new_lp->index;
2684 else
2686 eh_region old_r, new_r;
2688 old_r = VEC_index (eh_region, old_fun->eh->region_array, -old_lp_nr);
2689 slot = pointer_map_contains (map, old_r);
2690 new_r = (eh_region) *slot;
2691 new_lp_nr = -new_r->index;
2694 add_stmt_to_eh_lp_fn (new_fun, new_stmt, new_lp_nr);
2695 return true;
2698 /* Similar, but both OLD_STMT and NEW_STMT are within the current function,
2699 and thus no remapping is required. */
2701 bool
2702 maybe_duplicate_eh_stmt (gimple new_stmt, gimple old_stmt)
2704 int lp_nr;
2706 if (!stmt_could_throw_p (new_stmt))
2707 return false;
2709 lp_nr = lookup_stmt_eh_lp (old_stmt);
2710 if (lp_nr == 0)
2711 return false;
2713 add_stmt_to_eh_lp (new_stmt, lp_nr);
2714 return true;
2717 /* Returns TRUE if oneh and twoh are exception handlers (gimple_try_cleanup of
2718 GIMPLE_TRY) that are similar enough to be considered the same. Currently
2719 this only handles handlers consisting of a single call, as that's the
2720 important case for C++: a destructor call for a particular object showing
2721 up in multiple handlers. */
2723 static bool
2724 same_handler_p (gimple_seq oneh, gimple_seq twoh)
2726 gimple_stmt_iterator gsi;
2727 gimple ones, twos;
2728 unsigned int ai;
2730 gsi = gsi_start (oneh);
2731 if (!gsi_one_before_end_p (gsi))
2732 return false;
2733 ones = gsi_stmt (gsi);
2735 gsi = gsi_start (twoh);
2736 if (!gsi_one_before_end_p (gsi))
2737 return false;
2738 twos = gsi_stmt (gsi);
2740 if (!is_gimple_call (ones)
2741 || !is_gimple_call (twos)
2742 || gimple_call_lhs (ones)
2743 || gimple_call_lhs (twos)
2744 || gimple_call_chain (ones)
2745 || gimple_call_chain (twos)
2746 || !operand_equal_p (gimple_call_fn (ones), gimple_call_fn (twos), 0)
2747 || gimple_call_num_args (ones) != gimple_call_num_args (twos))
2748 return false;
2750 for (ai = 0; ai < gimple_call_num_args (ones); ++ai)
2751 if (!operand_equal_p (gimple_call_arg (ones, ai),
2752 gimple_call_arg (twos, ai), 0))
2753 return false;
2755 return true;
2758 /* Optimize
2759 try { A() } finally { try { ~B() } catch { ~A() } }
2760 try { ... } finally { ~A() }
2761 into
2762 try { A() } catch { ~B() }
2763 try { ~B() ... } finally { ~A() }
2765 This occurs frequently in C++, where A is a local variable and B is a
2766 temporary used in the initializer for A. */
2768 static void
2769 optimize_double_finally (gimple one, gimple two)
2771 gimple oneh;
2772 gimple_stmt_iterator gsi;
2774 gsi = gsi_start (gimple_try_cleanup (one));
2775 if (!gsi_one_before_end_p (gsi))
2776 return;
2778 oneh = gsi_stmt (gsi);
2779 if (gimple_code (oneh) != GIMPLE_TRY
2780 || gimple_try_kind (oneh) != GIMPLE_TRY_CATCH)
2781 return;
2783 if (same_handler_p (gimple_try_cleanup (oneh), gimple_try_cleanup (two)))
2785 gimple_seq seq = gimple_try_eval (oneh);
2787 gimple_try_set_cleanup (one, seq);
2788 gimple_try_set_kind (one, GIMPLE_TRY_CATCH);
2789 seq = copy_gimple_seq_and_replace_locals (seq);
2790 gimple_seq_add_seq (&seq, gimple_try_eval (two));
2791 gimple_try_set_eval (two, seq);
2795 /* Perform EH refactoring optimizations that are simpler to do when code
2796 flow has been lowered but EH structures haven't. */
2798 static void
2799 refactor_eh_r (gimple_seq seq)
2801 gimple_stmt_iterator gsi;
2802 gimple one, two;
2804 one = NULL;
2805 two = NULL;
2806 gsi = gsi_start (seq);
2807 while (1)
2809 one = two;
2810 if (gsi_end_p (gsi))
2811 two = NULL;
2812 else
2813 two = gsi_stmt (gsi);
2814 if (one
2815 && two
2816 && gimple_code (one) == GIMPLE_TRY
2817 && gimple_code (two) == GIMPLE_TRY
2818 && gimple_try_kind (one) == GIMPLE_TRY_FINALLY
2819 && gimple_try_kind (two) == GIMPLE_TRY_FINALLY)
2820 optimize_double_finally (one, two);
2821 if (one)
2822 switch (gimple_code (one))
2824 case GIMPLE_TRY:
2825 refactor_eh_r (gimple_try_eval (one));
2826 refactor_eh_r (gimple_try_cleanup (one));
2827 break;
2828 case GIMPLE_CATCH:
2829 refactor_eh_r (gimple_catch_handler (one));
2830 break;
2831 case GIMPLE_EH_FILTER:
2832 refactor_eh_r (gimple_eh_filter_failure (one));
2833 break;
2834 default:
2835 break;
2837 if (two)
2838 gsi_next (&gsi);
2839 else
2840 break;
2844 static unsigned
2845 refactor_eh (void)
2847 refactor_eh_r (gimple_body (current_function_decl));
2848 return 0;
2851 static bool
2852 gate_refactor_eh (void)
2854 return flag_exceptions != 0;
2857 struct gimple_opt_pass pass_refactor_eh =
2860 GIMPLE_PASS,
2861 "ehopt", /* name */
2862 gate_refactor_eh, /* gate */
2863 refactor_eh, /* execute */
2864 NULL, /* sub */
2865 NULL, /* next */
2866 0, /* static_pass_number */
2867 TV_TREE_EH, /* tv_id */
2868 PROP_gimple_lcf, /* properties_required */
2869 0, /* properties_provided */
2870 0, /* properties_destroyed */
2871 0, /* todo_flags_start */
2872 TODO_dump_func /* todo_flags_finish */
2876 /* At the end of gimple optimization, we can lower RESX. */
2878 static bool
2879 lower_resx (basic_block bb, gimple stmt, struct pointer_map_t *mnt_map)
2881 int lp_nr;
2882 eh_region src_r, dst_r;
2883 gimple_stmt_iterator gsi;
2884 gimple x;
2885 tree fn, src_nr;
2886 bool ret = false;
2888 lp_nr = lookup_stmt_eh_lp (stmt);
2889 if (lp_nr != 0)
2890 dst_r = get_eh_region_from_lp_number (lp_nr);
2891 else
2892 dst_r = NULL;
2894 src_r = get_eh_region_from_number (gimple_resx_region (stmt));
2895 gsi = gsi_last_bb (bb);
2897 if (src_r == NULL)
2899 /* We can wind up with no source region when pass_cleanup_eh shows
2900 that there are no entries into an eh region and deletes it, but
2901 then the block that contains the resx isn't removed. This can
2902 happen without optimization when the switch statement created by
2903 lower_try_finally_switch isn't simplified to remove the eh case.
2905 Resolve this by expanding the resx node to an abort. */
2907 fn = implicit_built_in_decls[BUILT_IN_TRAP];
2908 x = gimple_build_call (fn, 0);
2909 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
2911 while (EDGE_COUNT (bb->succs) > 0)
2912 remove_edge (EDGE_SUCC (bb, 0));
2914 else if (dst_r)
2916 /* When we have a destination region, we resolve this by copying
2917 the excptr and filter values into place, and changing the edge
2918 to immediately after the landing pad. */
2919 edge e;
2921 if (lp_nr < 0)
2923 basic_block new_bb;
2924 void **slot;
2925 tree lab;
2927 /* We are resuming into a MUST_NOT_CALL region. Expand a call to
2928 the failure decl into a new block, if needed. */
2929 gcc_assert (dst_r->type == ERT_MUST_NOT_THROW);
2931 slot = pointer_map_contains (mnt_map, dst_r);
2932 if (slot == NULL)
2934 gimple_stmt_iterator gsi2;
2936 new_bb = create_empty_bb (bb);
2937 lab = gimple_block_label (new_bb);
2938 gsi2 = gsi_start_bb (new_bb);
2940 fn = dst_r->u.must_not_throw.failure_decl;
2941 x = gimple_build_call (fn, 0);
2942 gimple_set_location (x, dst_r->u.must_not_throw.failure_loc);
2943 gsi_insert_after (&gsi2, x, GSI_CONTINUE_LINKING);
2945 slot = pointer_map_insert (mnt_map, dst_r);
2946 *slot = lab;
2948 else
2950 lab = (tree) *slot;
2951 new_bb = label_to_block (lab);
2954 gcc_assert (EDGE_COUNT (bb->succs) == 0);
2955 e = make_edge (bb, new_bb, EDGE_FALLTHRU);
2956 e->count = bb->count;
2957 e->probability = REG_BR_PROB_BASE;
2959 else
2961 edge_iterator ei;
2962 tree dst_nr = build_int_cst (NULL, dst_r->index);
2964 fn = implicit_built_in_decls[BUILT_IN_EH_COPY_VALUES];
2965 src_nr = build_int_cst (NULL, src_r->index);
2966 x = gimple_build_call (fn, 2, dst_nr, src_nr);
2967 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
2969 /* Update the flags for the outgoing edge. */
2970 e = single_succ_edge (bb);
2971 gcc_assert (e->flags & EDGE_EH);
2972 e->flags = (e->flags & ~EDGE_EH) | EDGE_FALLTHRU;
2974 /* If there are no more EH users of the landing pad, delete it. */
2975 FOR_EACH_EDGE (e, ei, e->dest->preds)
2976 if (e->flags & EDGE_EH)
2977 break;
2978 if (e == NULL)
2980 eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
2981 remove_eh_landing_pad (lp);
2985 ret = true;
2987 else
2989 tree var;
2991 /* When we don't have a destination region, this exception escapes
2992 up the call chain. We resolve this by generating a call to the
2993 _Unwind_Resume library function. */
2995 /* The ARM EABI redefines _Unwind_Resume as __cxa_end_cleanup
2996 with no arguments for C++ and Java. Check for that. */
2997 if (src_r->use_cxa_end_cleanup)
2999 fn = implicit_built_in_decls[BUILT_IN_CXA_END_CLEANUP];
3000 x = gimple_build_call (fn, 0);
3001 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3003 else
3005 fn = implicit_built_in_decls[BUILT_IN_EH_POINTER];
3006 src_nr = build_int_cst (NULL, src_r->index);
3007 x = gimple_build_call (fn, 1, src_nr);
3008 var = create_tmp_var (ptr_type_node, NULL);
3009 var = make_ssa_name (var, x);
3010 gimple_call_set_lhs (x, var);
3011 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3013 fn = implicit_built_in_decls[BUILT_IN_UNWIND_RESUME];
3014 x = gimple_build_call (fn, 1, var);
3015 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3018 gcc_assert (EDGE_COUNT (bb->succs) == 0);
3021 gsi_remove (&gsi, true);
3023 return ret;
3026 static unsigned
3027 execute_lower_resx (void)
3029 basic_block bb;
3030 struct pointer_map_t *mnt_map;
3031 bool dominance_invalidated = false;
3032 bool any_rewritten = false;
3034 mnt_map = pointer_map_create ();
3036 FOR_EACH_BB (bb)
3038 gimple last = last_stmt (bb);
3039 if (last && is_gimple_resx (last))
3041 dominance_invalidated |= lower_resx (bb, last, mnt_map);
3042 any_rewritten = true;
3046 pointer_map_destroy (mnt_map);
3048 if (dominance_invalidated)
3050 free_dominance_info (CDI_DOMINATORS);
3051 free_dominance_info (CDI_POST_DOMINATORS);
3054 return any_rewritten ? TODO_update_ssa_only_virtuals : 0;
3057 static bool
3058 gate_lower_resx (void)
3060 return flag_exceptions != 0;
3063 struct gimple_opt_pass pass_lower_resx =
3066 GIMPLE_PASS,
3067 "resx", /* name */
3068 gate_lower_resx, /* gate */
3069 execute_lower_resx, /* execute */
3070 NULL, /* sub */
3071 NULL, /* next */
3072 0, /* static_pass_number */
3073 TV_TREE_EH, /* tv_id */
3074 PROP_gimple_lcf, /* properties_required */
3075 0, /* properties_provided */
3076 0, /* properties_destroyed */
3077 0, /* todo_flags_start */
3078 TODO_dump_func | TODO_verify_flow /* todo_flags_finish */
3083 /* At the end of inlining, we can lower EH_DISPATCH. Return true when
3084 we have found some duplicate labels and removed some edges. */
3086 static bool
3087 lower_eh_dispatch (basic_block src, gimple stmt)
3089 gimple_stmt_iterator gsi;
3090 int region_nr;
3091 eh_region r;
3092 tree filter, fn;
3093 gimple x;
3094 bool redirected = false;
3096 region_nr = gimple_eh_dispatch_region (stmt);
3097 r = get_eh_region_from_number (region_nr);
3099 gsi = gsi_last_bb (src);
3101 switch (r->type)
3103 case ERT_TRY:
3105 VEC (tree, heap) *labels = NULL;
3106 tree default_label = NULL;
3107 eh_catch c;
3108 edge_iterator ei;
3109 edge e;
3110 struct pointer_set_t *seen_values = pointer_set_create ();
3112 /* Collect the labels for a switch. Zero the post_landing_pad
3113 field becase we'll no longer have anything keeping these labels
3114 in existance and the optimizer will be free to merge these
3115 blocks at will. */
3116 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
3118 tree tp_node, flt_node, lab = c->label;
3119 bool have_label = false;
3121 c->label = NULL;
3122 tp_node = c->type_list;
3123 flt_node = c->filter_list;
3125 if (tp_node == NULL)
3127 default_label = lab;
3128 break;
3132 /* Filter out duplicate labels that arise when this handler
3133 is shadowed by an earlier one. When no labels are
3134 attached to the handler anymore, we remove
3135 the corresponding edge and then we delete unreachable
3136 blocks at the end of this pass. */
3137 if (! pointer_set_contains (seen_values, TREE_VALUE (flt_node)))
3139 tree t = build3 (CASE_LABEL_EXPR, void_type_node,
3140 TREE_VALUE (flt_node), NULL, lab);
3141 VEC_safe_push (tree, heap, labels, t);
3142 pointer_set_insert (seen_values, TREE_VALUE (flt_node));
3143 have_label = true;
3146 tp_node = TREE_CHAIN (tp_node);
3147 flt_node = TREE_CHAIN (flt_node);
3149 while (tp_node);
3150 if (! have_label)
3152 remove_edge (find_edge (src, label_to_block (lab)));
3153 redirected = true;
3157 /* Clean up the edge flags. */
3158 FOR_EACH_EDGE (e, ei, src->succs)
3160 if (e->flags & EDGE_FALLTHRU)
3162 /* If there was no catch-all, use the fallthru edge. */
3163 if (default_label == NULL)
3164 default_label = gimple_block_label (e->dest);
3165 e->flags &= ~EDGE_FALLTHRU;
3168 gcc_assert (default_label != NULL);
3170 /* Don't generate a switch if there's only a default case.
3171 This is common in the form of try { A; } catch (...) { B; }. */
3172 if (labels == NULL)
3174 e = single_succ_edge (src);
3175 e->flags |= EDGE_FALLTHRU;
3177 else
3179 fn = implicit_built_in_decls[BUILT_IN_EH_FILTER];
3180 x = gimple_build_call (fn, 1, build_int_cst (NULL, region_nr));
3181 filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL);
3182 filter = make_ssa_name (filter, x);
3183 gimple_call_set_lhs (x, filter);
3184 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3186 /* Turn the default label into a default case. */
3187 default_label = build3 (CASE_LABEL_EXPR, void_type_node,
3188 NULL, NULL, default_label);
3189 sort_case_labels (labels);
3191 x = gimple_build_switch_vec (filter, default_label, labels);
3192 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3194 VEC_free (tree, heap, labels);
3196 pointer_set_destroy (seen_values);
3198 break;
3200 case ERT_ALLOWED_EXCEPTIONS:
3202 edge b_e = BRANCH_EDGE (src);
3203 edge f_e = FALLTHRU_EDGE (src);
3205 fn = implicit_built_in_decls[BUILT_IN_EH_FILTER];
3206 x = gimple_build_call (fn, 1, build_int_cst (NULL, region_nr));
3207 filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL);
3208 filter = make_ssa_name (filter, x);
3209 gimple_call_set_lhs (x, filter);
3210 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3212 r->u.allowed.label = NULL;
3213 x = gimple_build_cond (EQ_EXPR, filter,
3214 build_int_cst (TREE_TYPE (filter),
3215 r->u.allowed.filter),
3216 NULL_TREE, NULL_TREE);
3217 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3219 b_e->flags = b_e->flags | EDGE_TRUE_VALUE;
3220 f_e->flags = (f_e->flags & ~EDGE_FALLTHRU) | EDGE_FALSE_VALUE;
3222 break;
3224 default:
3225 gcc_unreachable ();
3228 /* Replace the EH_DISPATCH with the SWITCH or COND generated above. */
3229 gsi_remove (&gsi, true);
3230 return redirected;
3233 static unsigned
3234 execute_lower_eh_dispatch (void)
3236 basic_block bb;
3237 bool any_rewritten = false;
3238 bool redirected = false;
3240 assign_filter_values ();
3242 FOR_EACH_BB (bb)
3244 gimple last = last_stmt (bb);
3245 if (last && gimple_code (last) == GIMPLE_EH_DISPATCH)
3247 redirected |= lower_eh_dispatch (bb, last);
3248 any_rewritten = true;
3252 if (redirected)
3253 delete_unreachable_blocks ();
3254 return any_rewritten ? TODO_update_ssa_only_virtuals : 0;
3257 static bool
3258 gate_lower_eh_dispatch (void)
3260 return cfun->eh->region_tree != NULL;
3263 struct gimple_opt_pass pass_lower_eh_dispatch =
3266 GIMPLE_PASS,
3267 "ehdisp", /* name */
3268 gate_lower_eh_dispatch, /* gate */
3269 execute_lower_eh_dispatch, /* execute */
3270 NULL, /* sub */
3271 NULL, /* next */
3272 0, /* static_pass_number */
3273 TV_TREE_EH, /* tv_id */
3274 PROP_gimple_lcf, /* properties_required */
3275 0, /* properties_provided */
3276 0, /* properties_destroyed */
3277 0, /* todo_flags_start */
3278 TODO_dump_func | TODO_verify_flow /* todo_flags_finish */
3282 /* Walk statements, see what regions are really referenced and remove
3283 those that are unused. */
3285 static void
3286 remove_unreachable_handlers (void)
3288 sbitmap r_reachable, lp_reachable;
3289 eh_region region;
3290 eh_landing_pad lp;
3291 basic_block bb;
3292 int lp_nr, r_nr;
3294 r_reachable = sbitmap_alloc (VEC_length (eh_region, cfun->eh->region_array));
3295 lp_reachable
3296 = sbitmap_alloc (VEC_length (eh_landing_pad, cfun->eh->lp_array));
3297 sbitmap_zero (r_reachable);
3298 sbitmap_zero (lp_reachable);
3300 FOR_EACH_BB (bb)
3302 gimple_stmt_iterator gsi = gsi_start_bb (bb);
3304 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3306 gimple stmt = gsi_stmt (gsi);
3307 lp_nr = lookup_stmt_eh_lp (stmt);
3309 /* Negative LP numbers are MUST_NOT_THROW regions which
3310 are not considered BB enders. */
3311 if (lp_nr < 0)
3312 SET_BIT (r_reachable, -lp_nr);
3314 /* Positive LP numbers are real landing pads, are are BB enders. */
3315 else if (lp_nr > 0)
3317 gcc_assert (gsi_one_before_end_p (gsi));
3318 region = get_eh_region_from_lp_number (lp_nr);
3319 SET_BIT (r_reachable, region->index);
3320 SET_BIT (lp_reachable, lp_nr);
3325 if (dump_file)
3327 fprintf (dump_file, "Before removal of unreachable regions:\n");
3328 dump_eh_tree (dump_file, cfun);
3329 fprintf (dump_file, "Reachable regions: ");
3330 dump_sbitmap_file (dump_file, r_reachable);
3331 fprintf (dump_file, "Reachable landing pads: ");
3332 dump_sbitmap_file (dump_file, lp_reachable);
3335 for (r_nr = 1;
3336 VEC_iterate (eh_region, cfun->eh->region_array, r_nr, region); ++r_nr)
3337 if (region && !TEST_BIT (r_reachable, r_nr))
3339 if (dump_file)
3340 fprintf (dump_file, "Removing unreachable region %d\n", r_nr);
3341 remove_eh_handler (region);
3344 for (lp_nr = 1;
3345 VEC_iterate (eh_landing_pad, cfun->eh->lp_array, lp_nr, lp); ++lp_nr)
3346 if (lp && !TEST_BIT (lp_reachable, lp_nr))
3348 if (dump_file)
3349 fprintf (dump_file, "Removing unreachable landing pad %d\n", lp_nr);
3350 remove_eh_landing_pad (lp);
3353 if (dump_file)
3355 fprintf (dump_file, "\n\nAfter removal of unreachable regions:\n");
3356 dump_eh_tree (dump_file, cfun);
3357 fprintf (dump_file, "\n\n");
3360 sbitmap_free (r_reachable);
3361 sbitmap_free (lp_reachable);
3363 #ifdef ENABLE_CHECKING
3364 verify_eh_tree (cfun);
3365 #endif
3368 /* Remove regions that do not have landing pads. This assumes
3369 that remove_unreachable_handlers has already been run, and
3370 that we've just manipulated the landing pads since then. */
3372 static void
3373 remove_unreachable_handlers_no_lp (void)
3375 eh_region r;
3376 int i;
3378 for (i = 1; VEC_iterate (eh_region, cfun->eh->region_array, i, r); ++i)
3379 if (r && r->landing_pads == NULL && r->type != ERT_MUST_NOT_THROW)
3381 if (dump_file)
3382 fprintf (dump_file, "Removing unreachable region %d\n", i);
3383 remove_eh_handler (r);
3387 /* Undo critical edge splitting on an EH landing pad. Earlier, we
3388 optimisticaly split all sorts of edges, including EH edges. The
3389 optimization passes in between may not have needed them; if not,
3390 we should undo the split.
3392 Recognize this case by having one EH edge incoming to the BB and
3393 one normal edge outgoing; BB should be empty apart from the
3394 post_landing_pad label.
3396 Note that this is slightly different from the empty handler case
3397 handled by cleanup_empty_eh, in that the actual handler may yet
3398 have actual code but the landing pad has been separated from the
3399 handler. As such, cleanup_empty_eh relies on this transformation
3400 having been done first. */
3402 static bool
3403 unsplit_eh (eh_landing_pad lp)
3405 basic_block bb = label_to_block (lp->post_landing_pad);
3406 gimple_stmt_iterator gsi;
3407 edge e_in, e_out;
3409 /* Quickly check the edge counts on BB for singularity. */
3410 if (EDGE_COUNT (bb->preds) != 1 || EDGE_COUNT (bb->succs) != 1)
3411 return false;
3412 e_in = EDGE_PRED (bb, 0);
3413 e_out = EDGE_SUCC (bb, 0);
3415 /* Input edge must be EH and output edge must be normal. */
3416 if ((e_in->flags & EDGE_EH) == 0 || (e_out->flags & EDGE_EH) != 0)
3417 return false;
3419 /* The block must be empty except for the labels and debug insns. */
3420 gsi = gsi_after_labels (bb);
3421 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
3422 gsi_next_nondebug (&gsi);
3423 if (!gsi_end_p (gsi))
3424 return false;
3426 /* The destination block must not already have a landing pad
3427 for a different region. */
3428 for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
3430 gimple stmt = gsi_stmt (gsi);
3431 tree lab;
3432 int lp_nr;
3434 if (gimple_code (stmt) != GIMPLE_LABEL)
3435 break;
3436 lab = gimple_label_label (stmt);
3437 lp_nr = EH_LANDING_PAD_NR (lab);
3438 if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region)
3439 return false;
3442 /* The new destination block must not already be a destination of
3443 the source block, lest we merge fallthru and eh edges and get
3444 all sorts of confused. */
3445 if (find_edge (e_in->src, e_out->dest))
3446 return false;
3448 /* ??? We can get degenerate phis due to cfg cleanups. I would have
3449 thought this should have been cleaned up by a phicprop pass, but
3450 that doesn't appear to handle virtuals. Propagate by hand. */
3451 if (!gimple_seq_empty_p (phi_nodes (bb)))
3453 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
3455 gimple use_stmt, phi = gsi_stmt (gsi);
3456 tree lhs = gimple_phi_result (phi);
3457 tree rhs = gimple_phi_arg_def (phi, 0);
3458 use_operand_p use_p;
3459 imm_use_iterator iter;
3461 FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
3463 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
3464 SET_USE (use_p, rhs);
3467 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
3468 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs) = 1;
3470 remove_phi_node (&gsi, true);
3474 if (dump_file && (dump_flags & TDF_DETAILS))
3475 fprintf (dump_file, "Unsplit EH landing pad %d to block %i.\n",
3476 lp->index, e_out->dest->index);
3478 /* Redirect the edge. Since redirect_eh_edge_1 expects to be moving
3479 a successor edge, humor it. But do the real CFG change with the
3480 predecessor of E_OUT in order to preserve the ordering of arguments
3481 to the PHI nodes in E_OUT->DEST. */
3482 redirect_eh_edge_1 (e_in, e_out->dest, false);
3483 redirect_edge_pred (e_out, e_in->src);
3484 e_out->flags = e_in->flags;
3485 e_out->probability = e_in->probability;
3486 e_out->count = e_in->count;
3487 remove_edge (e_in);
3489 return true;
3492 /* Examine each landing pad block and see if it matches unsplit_eh. */
3494 static bool
3495 unsplit_all_eh (void)
3497 bool changed = false;
3498 eh_landing_pad lp;
3499 int i;
3501 for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
3502 if (lp)
3503 changed |= unsplit_eh (lp);
3505 return changed;
3508 /* A subroutine of cleanup_empty_eh. Redirect all EH edges incoming
3509 to OLD_BB to NEW_BB; return true on success, false on failure.
3511 OLD_BB_OUT is the edge into NEW_BB from OLD_BB, so if we miss any
3512 PHI variables from OLD_BB we can pick them up from OLD_BB_OUT.
3513 Virtual PHIs may be deleted and marked for renaming. */
3515 static bool
3516 cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
3517 edge old_bb_out, bool change_region)
3519 gimple_stmt_iterator ngsi, ogsi;
3520 edge_iterator ei;
3521 edge e;
3522 bitmap rename_virts;
3523 bitmap ophi_handled;
3525 FOR_EACH_EDGE (e, ei, old_bb->preds)
3526 redirect_edge_var_map_clear (e);
3528 ophi_handled = BITMAP_ALLOC (NULL);
3529 rename_virts = BITMAP_ALLOC (NULL);
3531 /* First, iterate through the PHIs on NEW_BB and set up the edge_var_map
3532 for the edges we're going to move. */
3533 for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); gsi_next (&ngsi))
3535 gimple ophi, nphi = gsi_stmt (ngsi);
3536 tree nresult, nop;
3538 nresult = gimple_phi_result (nphi);
3539 nop = gimple_phi_arg_def (nphi, old_bb_out->dest_idx);
3541 /* Find the corresponding PHI in OLD_BB so we can forward-propagate
3542 the source ssa_name. */
3543 ophi = NULL;
3544 for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
3546 ophi = gsi_stmt (ogsi);
3547 if (gimple_phi_result (ophi) == nop)
3548 break;
3549 ophi = NULL;
3552 /* If we did find the corresponding PHI, copy those inputs. */
3553 if (ophi)
3555 /* If NOP is used somewhere else beyond phis in new_bb, give up. */
3556 if (!has_single_use (nop))
3558 imm_use_iterator imm_iter;
3559 use_operand_p use_p;
3561 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, nop)
3563 if (!gimple_debug_bind_p (USE_STMT (use_p))
3564 && (gimple_code (USE_STMT (use_p)) != GIMPLE_PHI
3565 || gimple_bb (USE_STMT (use_p)) != new_bb))
3566 goto fail;
3569 bitmap_set_bit (ophi_handled, SSA_NAME_VERSION (nop));
3570 FOR_EACH_EDGE (e, ei, old_bb->preds)
3572 location_t oloc;
3573 tree oop;
3575 if ((e->flags & EDGE_EH) == 0)
3576 continue;
3577 oop = gimple_phi_arg_def (ophi, e->dest_idx);
3578 oloc = gimple_phi_arg_location (ophi, e->dest_idx);
3579 redirect_edge_var_map_add (e, nresult, oop, oloc);
3582 /* If we didn't find the PHI, but it's a VOP, remember to rename
3583 it later, assuming all other tests succeed. */
3584 else if (!is_gimple_reg (nresult))
3585 bitmap_set_bit (rename_virts, SSA_NAME_VERSION (nresult));
3586 /* If we didn't find the PHI, and it's a real variable, we know
3587 from the fact that OLD_BB is tree_empty_eh_handler_p that the
3588 variable is unchanged from input to the block and we can simply
3589 re-use the input to NEW_BB from the OLD_BB_OUT edge. */
3590 else
3592 location_t nloc
3593 = gimple_phi_arg_location (nphi, old_bb_out->dest_idx);
3594 FOR_EACH_EDGE (e, ei, old_bb->preds)
3595 redirect_edge_var_map_add (e, nresult, nop, nloc);
3599 /* Second, verify that all PHIs from OLD_BB have been handled. If not,
3600 we don't know what values from the other edges into NEW_BB to use. */
3601 for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
3603 gimple ophi = gsi_stmt (ogsi);
3604 tree oresult = gimple_phi_result (ophi);
3605 if (!bitmap_bit_p (ophi_handled, SSA_NAME_VERSION (oresult)))
3606 goto fail;
3609 /* At this point we know that the merge will succeed. Remove the PHI
3610 nodes for the virtuals that we want to rename. */
3611 if (!bitmap_empty_p (rename_virts))
3613 for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); )
3615 gimple nphi = gsi_stmt (ngsi);
3616 tree nresult = gimple_phi_result (nphi);
3617 if (bitmap_bit_p (rename_virts, SSA_NAME_VERSION (nresult)))
3619 mark_virtual_phi_result_for_renaming (nphi);
3620 remove_phi_node (&ngsi, true);
3622 else
3623 gsi_next (&ngsi);
3627 /* Finally, move the edges and update the PHIs. */
3628 for (ei = ei_start (old_bb->preds); (e = ei_safe_edge (ei)); )
3629 if (e->flags & EDGE_EH)
3631 redirect_eh_edge_1 (e, new_bb, change_region);
3632 redirect_edge_succ (e, new_bb);
3633 flush_pending_stmts (e);
3635 else
3636 ei_next (&ei);
3638 BITMAP_FREE (ophi_handled);
3639 BITMAP_FREE (rename_virts);
3640 return true;
3642 fail:
3643 FOR_EACH_EDGE (e, ei, old_bb->preds)
3644 redirect_edge_var_map_clear (e);
3645 BITMAP_FREE (ophi_handled);
3646 BITMAP_FREE (rename_virts);
3647 return false;
3650 /* A subroutine of cleanup_empty_eh. Move a landing pad LP from its
3651 old region to NEW_REGION at BB. */
3653 static void
3654 cleanup_empty_eh_move_lp (basic_block bb, edge e_out,
3655 eh_landing_pad lp, eh_region new_region)
3657 gimple_stmt_iterator gsi;
3658 eh_landing_pad *pp;
3660 for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp)
3661 continue;
3662 *pp = lp->next_lp;
3664 lp->region = new_region;
3665 lp->next_lp = new_region->landing_pads;
3666 new_region->landing_pads = lp;
3668 /* Delete the RESX that was matched within the empty handler block. */
3669 gsi = gsi_last_bb (bb);
3670 mark_virtual_ops_for_renaming (gsi_stmt (gsi));
3671 gsi_remove (&gsi, true);
3673 /* Clean up E_OUT for the fallthru. */
3674 e_out->flags = (e_out->flags & ~EDGE_EH) | EDGE_FALLTHRU;
3675 e_out->probability = REG_BR_PROB_BASE;
3678 /* A subroutine of cleanup_empty_eh. Handle more complex cases of
3679 unsplitting than unsplit_eh was prepared to handle, e.g. when
3680 multiple incoming edges and phis are involved. */
3682 static bool
3683 cleanup_empty_eh_unsplit (basic_block bb, edge e_out, eh_landing_pad lp)
3685 gimple_stmt_iterator gsi;
3686 tree lab;
3687 edge_iterator ei;
3688 edge e;
3690 /* We really ought not have totally lost everything following
3691 a landing pad label. Given that BB is empty, there had better
3692 be a successor. */
3693 gcc_assert (e_out != NULL);
3695 /* The destination block must not already have a landing pad
3696 for a different region. */
3697 lab = NULL;
3698 for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
3700 gimple stmt = gsi_stmt (gsi);
3701 int lp_nr;
3703 if (gimple_code (stmt) != GIMPLE_LABEL)
3704 break;
3705 lab = gimple_label_label (stmt);
3706 lp_nr = EH_LANDING_PAD_NR (lab);
3707 if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region)
3708 return false;
3711 /* The destination block must not be a regular successor for any
3712 of the preds of the landing pad. Thus, avoid turning
3713 <..>
3714 | \ EH
3715 | <..>
3717 <..>
3718 into
3719 <..>
3720 | | EH
3721 <..>
3722 which CFG verification would choke on. See PR45172. */
3723 FOR_EACH_EDGE (e, ei, bb->preds)
3724 if (find_edge (e->src, e_out->dest))
3725 return false;
3727 /* Attempt to move the PHIs into the successor block. */
3728 if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, false))
3730 if (dump_file && (dump_flags & TDF_DETAILS))
3731 fprintf (dump_file,
3732 "Unsplit EH landing pad %d to block %i "
3733 "(via cleanup_empty_eh).\n",
3734 lp->index, e_out->dest->index);
3735 return true;
3738 return false;
3741 /* Return true if edge E_FIRST is part of an empty infinite loop
3742 or leads to such a loop through a series of single successor
3743 empty bbs. */
3745 static bool
3746 infinite_empty_loop_p (edge e_first)
3748 bool inf_loop = false;
3749 edge e;
3751 if (e_first->dest == e_first->src)
3752 return true;
3754 e_first->src->aux = (void *) 1;
3755 for (e = e_first; single_succ_p (e->dest); e = single_succ_edge (e->dest))
3757 gimple_stmt_iterator gsi;
3758 if (e->dest->aux)
3760 inf_loop = true;
3761 break;
3763 e->dest->aux = (void *) 1;
3764 gsi = gsi_after_labels (e->dest);
3765 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
3766 gsi_next_nondebug (&gsi);
3767 if (!gsi_end_p (gsi))
3768 break;
3770 e_first->src->aux = NULL;
3771 for (e = e_first; e->dest->aux; e = single_succ_edge (e->dest))
3772 e->dest->aux = NULL;
3774 return inf_loop;
3777 /* Examine the block associated with LP to determine if it's an empty
3778 handler for its EH region. If so, attempt to redirect EH edges to
3779 an outer region. Return true the CFG was updated in any way. This
3780 is similar to jump forwarding, just across EH edges. */
3782 static bool
3783 cleanup_empty_eh (eh_landing_pad lp)
3785 basic_block bb = label_to_block (lp->post_landing_pad);
3786 gimple_stmt_iterator gsi;
3787 gimple resx;
3788 eh_region new_region;
3789 edge_iterator ei;
3790 edge e, e_out;
3791 bool has_non_eh_pred;
3792 int new_lp_nr;
3794 /* There can be zero or one edges out of BB. This is the quickest test. */
3795 switch (EDGE_COUNT (bb->succs))
3797 case 0:
3798 e_out = NULL;
3799 break;
3800 case 1:
3801 e_out = EDGE_SUCC (bb, 0);
3802 break;
3803 default:
3804 return false;
3806 gsi = gsi_after_labels (bb);
3808 /* Make sure to skip debug statements. */
3809 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
3810 gsi_next_nondebug (&gsi);
3812 /* If the block is totally empty, look for more unsplitting cases. */
3813 if (gsi_end_p (gsi))
3815 /* For the degenerate case of an infinite loop bail out. */
3816 if (infinite_empty_loop_p (e_out))
3817 return false;
3819 return cleanup_empty_eh_unsplit (bb, e_out, lp);
3822 /* The block should consist only of a single RESX statement. */
3823 resx = gsi_stmt (gsi);
3824 if (!is_gimple_resx (resx))
3825 return false;
3826 gcc_assert (gsi_one_before_end_p (gsi));
3828 /* Determine if there are non-EH edges, or resx edges into the handler. */
3829 has_non_eh_pred = false;
3830 FOR_EACH_EDGE (e, ei, bb->preds)
3831 if (!(e->flags & EDGE_EH))
3832 has_non_eh_pred = true;
3834 /* Find the handler that's outer of the empty handler by looking at
3835 where the RESX instruction was vectored. */
3836 new_lp_nr = lookup_stmt_eh_lp (resx);
3837 new_region = get_eh_region_from_lp_number (new_lp_nr);
3839 /* If there's no destination region within the current function,
3840 redirection is trivial via removing the throwing statements from
3841 the EH region, removing the EH edges, and allowing the block
3842 to go unreachable. */
3843 if (new_region == NULL)
3845 gcc_assert (e_out == NULL);
3846 for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
3847 if (e->flags & EDGE_EH)
3849 gimple stmt = last_stmt (e->src);
3850 remove_stmt_from_eh_lp (stmt);
3851 remove_edge (e);
3853 else
3854 ei_next (&ei);
3855 goto succeed;
3858 /* If the destination region is a MUST_NOT_THROW, allow the runtime
3859 to handle the abort and allow the blocks to go unreachable. */
3860 if (new_region->type == ERT_MUST_NOT_THROW)
3862 for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
3863 if (e->flags & EDGE_EH)
3865 gimple stmt = last_stmt (e->src);
3866 remove_stmt_from_eh_lp (stmt);
3867 add_stmt_to_eh_lp (stmt, new_lp_nr);
3868 remove_edge (e);
3870 else
3871 ei_next (&ei);
3872 goto succeed;
3875 /* Try to redirect the EH edges and merge the PHIs into the destination
3876 landing pad block. If the merge succeeds, we'll already have redirected
3877 all the EH edges. The handler itself will go unreachable if there were
3878 no normal edges. */
3879 if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, true))
3880 goto succeed;
3882 /* Finally, if all input edges are EH edges, then we can (potentially)
3883 reduce the number of transfers from the runtime by moving the landing
3884 pad from the original region to the new region. This is a win when
3885 we remove the last CLEANUP region along a particular exception
3886 propagation path. Since nothing changes except for the region with
3887 which the landing pad is associated, the PHI nodes do not need to be
3888 adjusted at all. */
3889 if (!has_non_eh_pred)
3891 cleanup_empty_eh_move_lp (bb, e_out, lp, new_region);
3892 if (dump_file && (dump_flags & TDF_DETAILS))
3893 fprintf (dump_file, "Empty EH handler %i moved to EH region %i.\n",
3894 lp->index, new_region->index);
3896 /* ??? The CFG didn't change, but we may have rendered the
3897 old EH region unreachable. Trigger a cleanup there. */
3898 return true;
3901 return false;
3903 succeed:
3904 if (dump_file && (dump_flags & TDF_DETAILS))
3905 fprintf (dump_file, "Empty EH handler %i removed.\n", lp->index);
3906 remove_eh_landing_pad (lp);
3907 return true;
3910 /* Do a post-order traversal of the EH region tree. Examine each
3911 post_landing_pad block and see if we can eliminate it as empty. */
3913 static bool
3914 cleanup_all_empty_eh (void)
3916 bool changed = false;
3917 eh_landing_pad lp;
3918 int i;
3920 for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
3921 if (lp)
3922 changed |= cleanup_empty_eh (lp);
3924 return changed;
3927 /* Perform cleanups and lowering of exception handling
3928 1) cleanups regions with handlers doing nothing are optimized out
3929 2) MUST_NOT_THROW regions that became dead because of 1) are optimized out
3930 3) Info about regions that are containing instructions, and regions
3931 reachable via local EH edges is collected
3932 4) Eh tree is pruned for regions no longer neccesary.
3934 TODO: Push MUST_NOT_THROW regions to the root of the EH tree.
3935 Unify those that have the same failure decl and locus.
3938 static unsigned int
3939 execute_cleanup_eh_1 (void)
3941 /* Do this first: unsplit_all_eh and cleanup_all_empty_eh can die
3942 looking up unreachable landing pads. */
3943 remove_unreachable_handlers ();
3945 /* Watch out for the region tree vanishing due to all unreachable. */
3946 if (cfun->eh->region_tree && optimize)
3948 bool changed = false;
3950 changed |= unsplit_all_eh ();
3951 changed |= cleanup_all_empty_eh ();
3953 if (changed)
3955 free_dominance_info (CDI_DOMINATORS);
3956 free_dominance_info (CDI_POST_DOMINATORS);
3958 /* We delayed all basic block deletion, as we may have performed
3959 cleanups on EH edges while non-EH edges were still present. */
3960 delete_unreachable_blocks ();
3962 /* We manipulated the landing pads. Remove any region that no
3963 longer has a landing pad. */
3964 remove_unreachable_handlers_no_lp ();
3966 return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals;
3970 return 0;
3973 static unsigned int
3974 execute_cleanup_eh (void)
3976 int ret = execute_cleanup_eh_1 ();
3978 /* If the function no longer needs an EH personality routine
3979 clear it. This exposes cross-language inlining opportunities
3980 and avoids references to a never defined personality routine. */
3981 if (DECL_FUNCTION_PERSONALITY (current_function_decl)
3982 && function_needs_eh_personality (cfun) != eh_personality_lang)
3983 DECL_FUNCTION_PERSONALITY (current_function_decl) = NULL_TREE;
3985 return ret;
3988 static bool
3989 gate_cleanup_eh (void)
3991 return cfun->eh != NULL && cfun->eh->region_tree != NULL;
3994 struct gimple_opt_pass pass_cleanup_eh = {
3996 GIMPLE_PASS,
3997 "ehcleanup", /* name */
3998 gate_cleanup_eh, /* gate */
3999 execute_cleanup_eh, /* execute */
4000 NULL, /* sub */
4001 NULL, /* next */
4002 0, /* static_pass_number */
4003 TV_TREE_EH, /* tv_id */
4004 PROP_gimple_lcf, /* properties_required */
4005 0, /* properties_provided */
4006 0, /* properties_destroyed */
4007 0, /* todo_flags_start */
4008 TODO_dump_func /* todo_flags_finish */
4012 /* Verify that BB containing STMT as the last statement, has precisely the
4013 edge that make_eh_edges would create. */
4015 DEBUG_FUNCTION bool
4016 verify_eh_edges (gimple stmt)
4018 basic_block bb = gimple_bb (stmt);
4019 eh_landing_pad lp = NULL;
4020 int lp_nr;
4021 edge_iterator ei;
4022 edge e, eh_edge;
4024 lp_nr = lookup_stmt_eh_lp (stmt);
4025 if (lp_nr > 0)
4026 lp = get_eh_landing_pad_from_number (lp_nr);
4028 eh_edge = NULL;
4029 FOR_EACH_EDGE (e, ei, bb->succs)
4031 if (e->flags & EDGE_EH)
4033 if (eh_edge)
4035 error ("BB %i has multiple EH edges", bb->index);
4036 return true;
4038 else
4039 eh_edge = e;
4043 if (lp == NULL)
4045 if (eh_edge)
4047 error ("BB %i can not throw but has an EH edge", bb->index);
4048 return true;
4050 return false;
4053 if (!stmt_could_throw_p (stmt))
4055 error ("BB %i last statement has incorrectly set lp", bb->index);
4056 return true;
4059 if (eh_edge == NULL)
4061 error ("BB %i is missing an EH edge", bb->index);
4062 return true;
4065 if (eh_edge->dest != label_to_block (lp->post_landing_pad))
4067 error ("Incorrect EH edge %i->%i", bb->index, eh_edge->dest->index);
4068 return true;
4071 return false;
4074 /* Similarly, but handle GIMPLE_EH_DISPATCH specifically. */
4076 DEBUG_FUNCTION bool
4077 verify_eh_dispatch_edge (gimple stmt)
4079 eh_region r;
4080 eh_catch c;
4081 basic_block src, dst;
4082 bool want_fallthru = true;
4083 edge_iterator ei;
4084 edge e, fall_edge;
4086 r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt));
4087 src = gimple_bb (stmt);
4089 FOR_EACH_EDGE (e, ei, src->succs)
4090 gcc_assert (e->aux == NULL);
4092 switch (r->type)
4094 case ERT_TRY:
4095 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
4097 dst = label_to_block (c->label);
4098 e = find_edge (src, dst);
4099 if (e == NULL)
4101 error ("BB %i is missing an edge", src->index);
4102 return true;
4104 e->aux = (void *)e;
4106 /* A catch-all handler doesn't have a fallthru. */
4107 if (c->type_list == NULL)
4109 want_fallthru = false;
4110 break;
4113 break;
4115 case ERT_ALLOWED_EXCEPTIONS:
4116 dst = label_to_block (r->u.allowed.label);
4117 e = find_edge (src, dst);
4118 if (e == NULL)
4120 error ("BB %i is missing an edge", src->index);
4121 return true;
4123 e->aux = (void *)e;
4124 break;
4126 default:
4127 gcc_unreachable ();
4130 fall_edge = NULL;
4131 FOR_EACH_EDGE (e, ei, src->succs)
4133 if (e->flags & EDGE_FALLTHRU)
4135 if (fall_edge != NULL)
4137 error ("BB %i too many fallthru edges", src->index);
4138 return true;
4140 fall_edge = e;
4142 else if (e->aux)
4143 e->aux = NULL;
4144 else
4146 error ("BB %i has incorrect edge", src->index);
4147 return true;
4150 if ((fall_edge != NULL) ^ want_fallthru)
4152 error ("BB %i has incorrect fallthru edge", src->index);
4153 return true;
4156 return false;