1 /* Exception handling semantics and decomposition for trees.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
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)
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/>. */
23 #include "coretypes.h"
31 #include "pointer-set.h"
32 #include "tree-flow.h"
33 #include "tree-dump.h"
34 #include "tree-inline.h"
35 #include "tree-iterator.h"
36 #include "tree-pass.h"
38 #include "langhooks.h"
44 /* In some instances a tree and a gimple need to be stored in a same table,
45 i.e. in hash tables. This is a structure to do this. */
46 typedef union {tree *tp; tree t; gimple g;} treemple;
48 /* Nonzero if we are using EH to handle cleanups. */
49 static int using_eh_for_cleanups_p = 0;
52 using_eh_for_cleanups (void)
54 using_eh_for_cleanups_p = 1;
57 /* Misc functions used in this file. */
59 /* Compare and hash for any structure which begins with a canonical
60 pointer. Assumes all pointers are interchangeable, which is sort
61 of already assumed by gcc elsewhere IIRC. */
64 struct_ptr_eq (const void *a, const void *b)
66 const void * const * x = (const void * const *) a;
67 const void * const * y = (const void * const *) b;
72 struct_ptr_hash (const void *a)
74 const void * const * x = (const void * const *) a;
75 return (size_t)*x >> 4;
79 /* Remember and lookup EH landing pad data for arbitrary statements.
80 Really this means any statement that could_throw_p. We could
81 stuff this information into the stmt_ann data structure, but:
83 (1) We absolutely rely on this information being kept until
84 we get to rtl. Once we're done with lowering here, if we lose
85 the information there's no way to recover it!
87 (2) There are many more statements that *cannot* throw as
88 compared to those that can. We should be saving some amount
89 of space by only allocating memory for those that can throw. */
91 /* Add statement T in function IFUN to landing pad NUM. */
94 add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num)
96 struct throw_stmt_node *n;
99 gcc_assert (num != 0);
101 n = GGC_NEW (struct throw_stmt_node);
105 if (!get_eh_throw_stmt_table (ifun))
106 set_eh_throw_stmt_table (ifun, htab_create_ggc (31, struct_ptr_hash,
110 slot = htab_find_slot (get_eh_throw_stmt_table (ifun), n, INSERT);
115 /* Add statement T in the current function (cfun) to EH landing pad NUM. */
118 add_stmt_to_eh_lp (gimple t, int num)
120 add_stmt_to_eh_lp_fn (cfun, t, num);
123 /* Add statement T to the single EH landing pad in REGION. */
126 record_stmt_eh_region (eh_region region, gimple t)
130 if (region->type == ERT_MUST_NOT_THROW)
131 add_stmt_to_eh_lp_fn (cfun, t, -region->index);
134 eh_landing_pad lp = region->landing_pads;
136 lp = gen_eh_landing_pad (region);
138 gcc_assert (lp->next_lp == NULL);
139 add_stmt_to_eh_lp_fn (cfun, t, lp->index);
144 /* Remove statement T in function IFUN from its EH landing pad. */
147 remove_stmt_from_eh_lp_fn (struct function *ifun, gimple t)
149 struct throw_stmt_node dummy;
152 if (!get_eh_throw_stmt_table (ifun))
156 slot = htab_find_slot (get_eh_throw_stmt_table (ifun), &dummy,
160 htab_clear_slot (get_eh_throw_stmt_table (ifun), slot);
168 /* Remove statement T in the current function (cfun) from its
172 remove_stmt_from_eh_lp (gimple t)
174 return remove_stmt_from_eh_lp_fn (cfun, t);
177 /* Determine if statement T is inside an EH region in function IFUN.
178 Positive numbers indicate a landing pad index; negative numbers
179 indicate a MUST_NOT_THROW region index; zero indicates that the
180 statement is not recorded in the region table. */
183 lookup_stmt_eh_lp_fn (struct function *ifun, gimple t)
185 struct throw_stmt_node *p, n;
187 if (ifun->eh->throw_stmt_table == NULL)
191 p = (struct throw_stmt_node *) htab_find (ifun->eh->throw_stmt_table, &n);
192 return p ? p->lp_nr : 0;
195 /* Likewise, but always use the current function. */
198 lookup_stmt_eh_lp (gimple t)
200 /* We can get called from initialized data when -fnon-call-exceptions
201 is on; prevent crash. */
204 return lookup_stmt_eh_lp_fn (cfun, t);
207 /* First pass of EH node decomposition. Build up a tree of GIMPLE_TRY_FINALLY
208 nodes and LABEL_DECL nodes. We will use this during the second phase to
209 determine if a goto leaves the body of a TRY_FINALLY_EXPR node. */
211 struct finally_tree_node
213 /* When storing a GIMPLE_TRY, we have to record a gimple. However
214 when deciding whether a GOTO to a certain LABEL_DECL (which is a
215 tree) leaves the TRY block, its necessary to record a tree in
216 this field. Thus a treemple is used. */
221 /* Note that this table is *not* marked GTY. It is short-lived. */
222 static htab_t finally_tree;
225 record_in_finally_tree (treemple child, gimple parent)
227 struct finally_tree_node *n;
230 n = XNEW (struct finally_tree_node);
234 slot = htab_find_slot (finally_tree, n, INSERT);
240 collect_finally_tree (gimple stmt, gimple region);
242 /* Go through the gimple sequence. Works with collect_finally_tree to
243 record all GIMPLE_LABEL and GIMPLE_TRY statements. */
246 collect_finally_tree_1 (gimple_seq seq, gimple region)
248 gimple_stmt_iterator gsi;
250 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
251 collect_finally_tree (gsi_stmt (gsi), region);
255 collect_finally_tree (gimple stmt, gimple region)
259 switch (gimple_code (stmt))
262 temp.t = gimple_label_label (stmt);
263 record_in_finally_tree (temp, region);
267 if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
270 record_in_finally_tree (temp, region);
271 collect_finally_tree_1 (gimple_try_eval (stmt), stmt);
272 collect_finally_tree_1 (gimple_try_cleanup (stmt), region);
274 else if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
276 collect_finally_tree_1 (gimple_try_eval (stmt), region);
277 collect_finally_tree_1 (gimple_try_cleanup (stmt), region);
282 collect_finally_tree_1 (gimple_catch_handler (stmt), region);
285 case GIMPLE_EH_FILTER:
286 collect_finally_tree_1 (gimple_eh_filter_failure (stmt), region);
290 /* A type, a decl, or some kind of statement that we're not
291 interested in. Don't walk them. */
297 /* Use the finally tree to determine if a jump from START to TARGET
298 would leave the try_finally node that START lives in. */
301 outside_finally_tree (treemple start, gimple target)
303 struct finally_tree_node n, *p;
308 p = (struct finally_tree_node *) htab_find (finally_tree, &n);
313 while (start.g != target);
318 /* Second pass of EH node decomposition. Actually transform the GIMPLE_TRY
319 nodes into a set of gotos, magic labels, and eh regions.
320 The eh region creation is straight-forward, but frobbing all the gotos
321 and such into shape isn't. */
323 /* The sequence into which we record all EH stuff. This will be
324 placed at the end of the function when we're all done. */
325 static gimple_seq eh_seq;
327 /* Record whether an EH region contains something that can throw,
328 indexed by EH region number. */
329 static bitmap eh_region_may_contain_throw_map;
331 /* The GOTO_QUEUE is is an array of GIMPLE_GOTO and GIMPLE_RETURN
332 statements that are seen to escape this GIMPLE_TRY_FINALLY node.
333 The idea is to record a gimple statement for everything except for
334 the conditionals, which get their labels recorded. Since labels are
335 of type 'tree', we need this node to store both gimple and tree
336 objects. REPL_STMT is the sequence used to replace the goto/return
337 statement. CONT_STMT is used to store the statement that allows
338 the return/goto to jump to the original destination. */
340 struct goto_queue_node
343 gimple_seq repl_stmt;
346 /* This is used when index >= 0 to indicate that stmt is a label (as
347 opposed to a goto stmt). */
351 /* State of the world while lowering. */
355 /* What's "current" while constructing the eh region tree. These
356 correspond to variables of the same name in cfun->eh, which we
357 don't have easy access to. */
358 eh_region cur_region;
360 /* What's "current" for the purposes of __builtin_eh_pointer. For
361 a CATCH, this is the associated TRY. For an EH_FILTER, this is
362 the associated ALLOWED_EXCEPTIONS, etc. */
363 eh_region ehp_region;
365 /* Processing of TRY_FINALLY requires a bit more state. This is
366 split out into a separate structure so that we don't have to
367 copy so much when processing other nodes. */
368 struct leh_tf_state *tf;
373 /* Pointer to the GIMPLE_TRY_FINALLY node under discussion. The
374 try_finally_expr is the original GIMPLE_TRY_FINALLY. We need to retain
375 this so that outside_finally_tree can reliably reference the tree used
376 in the collect_finally_tree data structures. */
377 gimple try_finally_expr;
380 /* While lowering a top_p usually it is expanded into multiple statements,
381 thus we need the following field to store them. */
382 gimple_seq top_p_seq;
384 /* The state outside this try_finally node. */
385 struct leh_state *outer;
387 /* The exception region created for it. */
390 /* The goto queue. */
391 struct goto_queue_node *goto_queue;
392 size_t goto_queue_size;
393 size_t goto_queue_active;
395 /* Pointer map to help in searching goto_queue when it is large. */
396 struct pointer_map_t *goto_queue_map;
398 /* The set of unique labels seen as entries in the goto queue. */
399 VEC(tree,heap) *dest_array;
401 /* A label to be added at the end of the completed transformed
402 sequence. It will be set if may_fallthru was true *at one time*,
403 though subsequent transformations may have cleared that flag. */
406 /* True if it is possible to fall out the bottom of the try block.
407 Cleared if the fallthru is converted to a goto. */
410 /* True if any entry in goto_queue is a GIMPLE_RETURN. */
413 /* True if the finally block can receive an exception edge.
414 Cleared if the exception case is handled by code duplication. */
418 static gimple_seq lower_eh_must_not_throw (struct leh_state *, gimple);
420 /* Search for STMT in the goto queue. Return the replacement,
421 or null if the statement isn't in the queue. */
423 #define LARGE_GOTO_QUEUE 20
425 static void lower_eh_constructs_1 (struct leh_state *state, gimple_seq seq);
428 find_goto_replacement (struct leh_tf_state *tf, treemple stmt)
433 if (tf->goto_queue_active < LARGE_GOTO_QUEUE)
435 for (i = 0; i < tf->goto_queue_active; i++)
436 if ( tf->goto_queue[i].stmt.g == stmt.g)
437 return tf->goto_queue[i].repl_stmt;
441 /* If we have a large number of entries in the goto_queue, create a
442 pointer map and use that for searching. */
444 if (!tf->goto_queue_map)
446 tf->goto_queue_map = pointer_map_create ();
447 for (i = 0; i < tf->goto_queue_active; i++)
449 slot = pointer_map_insert (tf->goto_queue_map,
450 tf->goto_queue[i].stmt.g);
451 gcc_assert (*slot == NULL);
452 *slot = &tf->goto_queue[i];
456 slot = pointer_map_contains (tf->goto_queue_map, stmt.g);
458 return (((struct goto_queue_node *) *slot)->repl_stmt);
463 /* A subroutine of replace_goto_queue_1. Handles the sub-clauses of a
464 lowered GIMPLE_COND. If, by chance, the replacement is a simple goto,
465 then we can just splat it in, otherwise we add the new stmts immediately
466 after the GIMPLE_COND and redirect. */
469 replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf,
470 gimple_stmt_iterator *gsi)
475 location_t loc = gimple_location (gsi_stmt (*gsi));
478 new_seq = find_goto_replacement (tf, temp);
482 if (gimple_seq_singleton_p (new_seq)
483 && gimple_code (gimple_seq_first_stmt (new_seq)) == GIMPLE_GOTO)
485 *tp = gimple_goto_dest (gimple_seq_first_stmt (new_seq));
489 label = create_artificial_label (loc);
490 /* Set the new label for the GIMPLE_COND */
493 gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING);
494 gsi_insert_seq_after (gsi, gimple_seq_copy (new_seq), GSI_CONTINUE_LINKING);
497 /* The real work of replace_goto_queue. Returns with TSI updated to
498 point to the next statement. */
500 static void replace_goto_queue_stmt_list (gimple_seq, struct leh_tf_state *);
503 replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
504 gimple_stmt_iterator *gsi)
510 switch (gimple_code (stmt))
515 seq = find_goto_replacement (tf, temp);
518 gsi_insert_seq_before (gsi, gimple_seq_copy (seq), GSI_SAME_STMT);
519 gsi_remove (gsi, false);
525 replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 2), tf, gsi);
526 replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 3), tf, gsi);
530 replace_goto_queue_stmt_list (gimple_try_eval (stmt), tf);
531 replace_goto_queue_stmt_list (gimple_try_cleanup (stmt), tf);
534 replace_goto_queue_stmt_list (gimple_catch_handler (stmt), tf);
536 case GIMPLE_EH_FILTER:
537 replace_goto_queue_stmt_list (gimple_eh_filter_failure (stmt), tf);
541 /* These won't have gotos in them. */
548 /* A subroutine of replace_goto_queue. Handles GIMPLE_SEQ. */
551 replace_goto_queue_stmt_list (gimple_seq seq, struct leh_tf_state *tf)
553 gimple_stmt_iterator gsi = gsi_start (seq);
555 while (!gsi_end_p (gsi))
556 replace_goto_queue_1 (gsi_stmt (gsi), tf, &gsi);
559 /* Replace all goto queue members. */
562 replace_goto_queue (struct leh_tf_state *tf)
564 if (tf->goto_queue_active == 0)
566 replace_goto_queue_stmt_list (tf->top_p_seq, tf);
569 /* Add a new record to the goto queue contained in TF. NEW_STMT is the
570 data to be added, IS_LABEL indicates whether NEW_STMT is a label or
574 record_in_goto_queue (struct leh_tf_state *tf,
580 struct goto_queue_node *q;
582 gcc_assert (!tf->goto_queue_map);
584 active = tf->goto_queue_active;
585 size = tf->goto_queue_size;
588 size = (size ? size * 2 : 32);
589 tf->goto_queue_size = size;
591 = XRESIZEVEC (struct goto_queue_node, tf->goto_queue, size);
594 q = &tf->goto_queue[active];
595 tf->goto_queue_active = active + 1;
597 memset (q, 0, sizeof (*q));
600 q->is_label = is_label;
603 /* Record the LABEL label in the goto queue contained in TF.
607 record_in_goto_queue_label (struct leh_tf_state *tf, treemple stmt, tree label)
610 treemple temp, new_stmt;
615 /* Computed and non-local gotos do not get processed. Given
616 their nature we can neither tell whether we've escaped the
617 finally block nor redirect them if we knew. */
618 if (TREE_CODE (label) != LABEL_DECL)
621 /* No need to record gotos that don't leave the try block. */
623 if (!outside_finally_tree (temp, tf->try_finally_expr))
626 if (! tf->dest_array)
628 tf->dest_array = VEC_alloc (tree, heap, 10);
629 VEC_quick_push (tree, tf->dest_array, label);
634 int n = VEC_length (tree, tf->dest_array);
635 for (index = 0; index < n; ++index)
636 if (VEC_index (tree, tf->dest_array, index) == label)
639 VEC_safe_push (tree, heap, tf->dest_array, label);
642 /* In the case of a GOTO we want to record the destination label,
643 since with a GIMPLE_COND we have an easy access to the then/else
646 record_in_goto_queue (tf, new_stmt, index, true);
650 /* For any GIMPLE_GOTO or GIMPLE_RETURN, decide whether it leaves a try_finally
651 node, and if so record that fact in the goto queue associated with that
655 maybe_record_in_goto_queue (struct leh_state *state, gimple stmt)
657 struct leh_tf_state *tf = state->tf;
663 switch (gimple_code (stmt))
666 new_stmt.tp = gimple_op_ptr (stmt, 2);
667 record_in_goto_queue_label (tf, new_stmt, gimple_cond_true_label (stmt));
668 new_stmt.tp = gimple_op_ptr (stmt, 3);
669 record_in_goto_queue_label (tf, new_stmt, gimple_cond_false_label (stmt));
673 record_in_goto_queue_label (tf, new_stmt, gimple_goto_dest (stmt));
677 tf->may_return = true;
679 record_in_goto_queue (tf, new_stmt, -1, false);
688 #ifdef ENABLE_CHECKING
689 /* We do not process GIMPLE_SWITCHes for now. As long as the original source
690 was in fact structured, and we've not yet done jump threading, then none
691 of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */
694 verify_norecord_switch_expr (struct leh_state *state, gimple switch_expr)
696 struct leh_tf_state *tf = state->tf;
702 n = gimple_switch_num_labels (switch_expr);
704 for (i = 0; i < n; ++i)
707 tree lab = CASE_LABEL (gimple_switch_label (switch_expr, i));
709 gcc_assert (!outside_finally_tree (temp, tf->try_finally_expr));
713 #define verify_norecord_switch_expr(state, switch_expr)
716 /* Redirect a RETURN_EXPR pointed to by STMT_P to FINLAB. Place in CONT_P
717 whatever is needed to finish the return. If MOD is non-null, insert it
718 before the new branch. RETURN_VALUE_P is a cache containing a temporary
719 variable to be used in manipulating the value returned from the function. */
722 do_return_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod,
723 tree *return_value_p)
728 /* In the case of a return, the queue node must be a gimple statement. */
729 gcc_assert (!q->is_label);
731 ret_expr = gimple_return_retval (q->stmt.g);
735 if (!*return_value_p)
736 *return_value_p = ret_expr;
738 gcc_assert (*return_value_p == ret_expr);
739 q->cont_stmt = q->stmt.g;
740 /* The nasty part about redirecting the return value is that the
741 return value itself is to be computed before the FINALLY block
755 should return 0, not 1. Arrange for this to happen by copying
756 computed the return value into a local temporary. This also
757 allows us to redirect multiple return statements through the
758 same destination block; whether this is a net win or not really
759 depends, I guess, but it does make generation of the switch in
760 lower_try_finally_switch easier. */
762 if (TREE_CODE (ret_expr) == RESULT_DECL)
764 if (!*return_value_p)
765 *return_value_p = ret_expr;
767 gcc_assert (*return_value_p == ret_expr);
768 q->cont_stmt = q->stmt.g;
774 /* If we don't return a value, all return statements are the same. */
775 q->cont_stmt = q->stmt.g;
778 q->repl_stmt = gimple_seq_alloc ();
781 gimple_seq_add_seq (&q->repl_stmt, mod);
783 x = gimple_build_goto (finlab);
784 gimple_seq_add_stmt (&q->repl_stmt, x);
787 /* Similar, but easier, for GIMPLE_GOTO. */
790 do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod,
791 struct leh_tf_state *tf)
795 gcc_assert (q->is_label);
797 q->repl_stmt = gimple_seq_alloc ();
799 q->cont_stmt = gimple_build_goto (VEC_index (tree, tf->dest_array, q->index));
802 gimple_seq_add_seq (&q->repl_stmt, mod);
804 x = gimple_build_goto (finlab);
805 gimple_seq_add_stmt (&q->repl_stmt, x);
808 /* Emit a standard landing pad sequence into SEQ for REGION. */
811 emit_post_landing_pad (gimple_seq *seq, eh_region region)
813 eh_landing_pad lp = region->landing_pads;
817 lp = gen_eh_landing_pad (region);
819 lp->post_landing_pad = create_artificial_label (UNKNOWN_LOCATION);
820 EH_LANDING_PAD_NR (lp->post_landing_pad) = lp->index;
822 x = gimple_build_label (lp->post_landing_pad);
823 gimple_seq_add_stmt (seq, x);
826 /* Emit a RESX statement into SEQ for REGION. */
829 emit_resx (gimple_seq *seq, eh_region region)
831 gimple x = gimple_build_resx (region->index);
832 gimple_seq_add_stmt (seq, x);
834 record_stmt_eh_region (region->outer, x);
837 /* Emit an EH_DISPATCH statement into SEQ for REGION. */
840 emit_eh_dispatch (gimple_seq *seq, eh_region region)
842 gimple x = gimple_build_eh_dispatch (region->index);
843 gimple_seq_add_stmt (seq, x);
846 /* Note that the current EH region may contain a throw, or a
847 call to a function which itself may contain a throw. */
850 note_eh_region_may_contain_throw (eh_region region)
852 while (!bitmap_bit_p (eh_region_may_contain_throw_map, region->index))
854 bitmap_set_bit (eh_region_may_contain_throw_map, region->index);
855 region = region->outer;
861 /* Check if REGION has been marked as containing a throw. If REGION is
862 NULL, this predicate is false. */
865 eh_region_may_contain_throw (eh_region r)
867 return r && bitmap_bit_p (eh_region_may_contain_throw_map, r->index);
870 /* We want to transform
871 try { body; } catch { stuff; }
881 TP is a GIMPLE_TRY node. REGION is the region whose post_landing_pad
882 should be placed before the second operand, or NULL. OVER is
883 an existing label that should be put at the exit, or NULL. */
886 frob_into_branch_around (gimple tp, eh_region region, tree over)
889 gimple_seq cleanup, result;
890 location_t loc = gimple_location (tp);
892 cleanup = gimple_try_cleanup (tp);
893 result = gimple_try_eval (tp);
896 emit_post_landing_pad (&eh_seq, region);
898 if (gimple_seq_may_fallthru (cleanup))
901 over = create_artificial_label (loc);
902 x = gimple_build_goto (over);
903 gimple_seq_add_stmt (&cleanup, x);
905 gimple_seq_add_seq (&eh_seq, cleanup);
909 x = gimple_build_label (over);
910 gimple_seq_add_stmt (&result, x);
915 /* A subroutine of lower_try_finally. Duplicate the tree rooted at T.
916 Make sure to record all new labels found. */
919 lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state)
921 gimple region = NULL;
924 new_seq = copy_gimple_seq_and_replace_locals (seq);
927 region = outer_state->tf->try_finally_expr;
928 collect_finally_tree_1 (new_seq, region);
933 /* A subroutine of lower_try_finally. Create a fallthru label for
934 the given try_finally state. The only tricky bit here is that
935 we have to make sure to record the label in our outer context. */
938 lower_try_finally_fallthru_label (struct leh_tf_state *tf)
940 tree label = tf->fallthru_label;
945 label = create_artificial_label (gimple_location (tf->try_finally_expr));
946 tf->fallthru_label = label;
950 record_in_finally_tree (temp, tf->outer->tf->try_finally_expr);
956 /* A subroutine of lower_try_finally. If lang_protect_cleanup_actions
957 returns non-null, then the language requires that the exception path out
958 of a try_finally be treated specially. To wit: the code within the
959 finally block may not itself throw an exception. We have two choices here.
960 First we can duplicate the finally block and wrap it in a must_not_throw
961 region. Second, we can generate code like
966 if (fintmp == eh_edge)
967 protect_cleanup_actions;
970 where "fintmp" is the temporary used in the switch statement generation
971 alternative considered below. For the nonce, we always choose the first
974 THIS_STATE may be null if this is a try-cleanup, not a try-finally. */
977 honor_protect_cleanup_actions (struct leh_state *outer_state,
978 struct leh_state *this_state,
979 struct leh_tf_state *tf)
981 tree protect_cleanup_actions;
982 gimple_stmt_iterator gsi;
983 bool finally_may_fallthru;
987 /* First check for nothing to do. */
988 if (lang_protect_cleanup_actions == NULL)
990 protect_cleanup_actions = lang_protect_cleanup_actions ();
991 if (protect_cleanup_actions == NULL)
994 finally = gimple_try_cleanup (tf->top_p);
995 finally_may_fallthru = gimple_seq_may_fallthru (finally);
997 /* Duplicate the FINALLY block. Only need to do this for try-finally,
998 and not for cleanups. */
1000 finally = lower_try_finally_dup_block (finally, outer_state);
1002 /* If this cleanup consists of a TRY_CATCH_EXPR with TRY_CATCH_IS_CLEANUP
1003 set, the handler of the TRY_CATCH_EXPR is another cleanup which ought
1004 to be in an enclosing scope, but needs to be implemented at this level
1005 to avoid a nesting violation (see wrap_temporary_cleanups in
1006 cp/decl.c). Since it's logically at an outer level, we should call
1007 terminate before we get to it, so strip it away before adding the
1008 MUST_NOT_THROW filter. */
1009 gsi = gsi_start (finally);
1011 if (gimple_code (x) == GIMPLE_TRY
1012 && gimple_try_kind (x) == GIMPLE_TRY_CATCH
1013 && gimple_try_catch_is_cleanup (x))
1015 gsi_insert_seq_before (&gsi, gimple_try_eval (x), GSI_SAME_STMT);
1016 gsi_remove (&gsi, false);
1019 /* Wrap the block with protect_cleanup_actions as the action. */
1020 x = gimple_build_eh_must_not_throw (protect_cleanup_actions);
1021 x = gimple_build_try (finally, gimple_seq_alloc_with_stmt (x),
1023 finally = lower_eh_must_not_throw (outer_state, x);
1025 /* Drop all of this into the exception sequence. */
1026 emit_post_landing_pad (&eh_seq, tf->region);
1027 gimple_seq_add_seq (&eh_seq, finally);
1028 if (finally_may_fallthru)
1029 emit_resx (&eh_seq, tf->region);
1031 /* Having now been handled, EH isn't to be considered with
1032 the rest of the outgoing edges. */
1033 tf->may_throw = false;
1036 /* A subroutine of lower_try_finally. We have determined that there is
1037 no fallthru edge out of the finally block. This means that there is
1038 no outgoing edge corresponding to any incoming edge. Restructure the
1039 try_finally node for this special case. */
1042 lower_try_finally_nofallthru (struct leh_state *state,
1043 struct leh_tf_state *tf)
1045 tree lab, return_val;
1048 struct goto_queue_node *q, *qe;
1050 lab = create_artificial_label (gimple_location (tf->try_finally_expr));
1052 /* We expect that tf->top_p is a GIMPLE_TRY. */
1053 finally = gimple_try_cleanup (tf->top_p);
1054 tf->top_p_seq = gimple_try_eval (tf->top_p);
1056 x = gimple_build_label (lab);
1057 gimple_seq_add_stmt (&tf->top_p_seq, x);
1061 qe = q + tf->goto_queue_active;
1064 do_return_redirection (q, lab, NULL, &return_val);
1066 do_goto_redirection (q, lab, NULL, tf);
1068 replace_goto_queue (tf);
1070 lower_eh_constructs_1 (state, finally);
1071 gimple_seq_add_seq (&tf->top_p_seq, finally);
1075 emit_post_landing_pad (&eh_seq, tf->region);
1077 x = gimple_build_goto (lab);
1078 gimple_seq_add_stmt (&eh_seq, x);
1082 /* A subroutine of lower_try_finally. We have determined that there is
1083 exactly one destination of the finally block. Restructure the
1084 try_finally node for this special case. */
1087 lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
1089 struct goto_queue_node *q, *qe;
1093 location_t loc = gimple_location (tf->try_finally_expr);
1095 finally = gimple_try_cleanup (tf->top_p);
1096 tf->top_p_seq = gimple_try_eval (tf->top_p);
1098 lower_eh_constructs_1 (state, finally);
1102 /* Only reachable via the exception edge. Add the given label to
1103 the head of the FINALLY block. Append a RESX at the end. */
1104 emit_post_landing_pad (&eh_seq, tf->region);
1105 gimple_seq_add_seq (&eh_seq, finally);
1106 emit_resx (&eh_seq, tf->region);
1110 if (tf->may_fallthru)
1112 /* Only reachable via the fallthru edge. Do nothing but let
1113 the two blocks run together; we'll fall out the bottom. */
1114 gimple_seq_add_seq (&tf->top_p_seq, finally);
1118 finally_label = create_artificial_label (loc);
1119 x = gimple_build_label (finally_label);
1120 gimple_seq_add_stmt (&tf->top_p_seq, x);
1122 gimple_seq_add_seq (&tf->top_p_seq, finally);
1125 qe = q + tf->goto_queue_active;
1129 /* Reachable by return expressions only. Redirect them. */
1130 tree return_val = NULL;
1132 do_return_redirection (q, finally_label, NULL, &return_val);
1133 replace_goto_queue (tf);
1137 /* Reachable by goto expressions only. Redirect them. */
1139 do_goto_redirection (q, finally_label, NULL, tf);
1140 replace_goto_queue (tf);
1142 if (VEC_index (tree, tf->dest_array, 0) == tf->fallthru_label)
1144 /* Reachable by goto to fallthru label only. Redirect it
1145 to the new label (already created, sadly), and do not
1146 emit the final branch out, or the fallthru label. */
1147 tf->fallthru_label = NULL;
1152 /* Place the original return/goto to the original destination
1153 immediately after the finally block. */
1154 x = tf->goto_queue[0].cont_stmt;
1155 gimple_seq_add_stmt (&tf->top_p_seq, x);
1156 maybe_record_in_goto_queue (state, x);
1159 /* A subroutine of lower_try_finally. There are multiple edges incoming
1160 and outgoing from the finally block. Implement this by duplicating the
1161 finally block for every destination. */
1164 lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf)
1167 gimple_seq new_stmt;
1171 location_t tf_loc = gimple_location (tf->try_finally_expr);
1173 finally = gimple_try_cleanup (tf->top_p);
1174 tf->top_p_seq = gimple_try_eval (tf->top_p);
1177 if (tf->may_fallthru)
1179 seq = lower_try_finally_dup_block (finally, state);
1180 lower_eh_constructs_1 (state, seq);
1181 gimple_seq_add_seq (&new_stmt, seq);
1183 tmp = lower_try_finally_fallthru_label (tf);
1184 x = gimple_build_goto (tmp);
1185 gimple_seq_add_stmt (&new_stmt, x);
1190 seq = lower_try_finally_dup_block (finally, state);
1191 lower_eh_constructs_1 (state, seq);
1193 emit_post_landing_pad (&eh_seq, tf->region);
1194 gimple_seq_add_seq (&eh_seq, seq);
1195 emit_resx (&eh_seq, tf->region);
1200 struct goto_queue_node *q, *qe;
1201 tree return_val = NULL;
1202 int return_index, index;
1205 struct goto_queue_node *q;
1209 return_index = VEC_length (tree, tf->dest_array);
1210 labels = XCNEWVEC (struct labels_s, return_index + 1);
1213 qe = q + tf->goto_queue_active;
1216 index = q->index < 0 ? return_index : q->index;
1218 if (!labels[index].q)
1219 labels[index].q = q;
1222 for (index = 0; index < return_index + 1; index++)
1226 q = labels[index].q;
1230 lab = labels[index].label
1231 = create_artificial_label (tf_loc);
1233 if (index == return_index)
1234 do_return_redirection (q, lab, NULL, &return_val);
1236 do_goto_redirection (q, lab, NULL, tf);
1238 x = gimple_build_label (lab);
1239 gimple_seq_add_stmt (&new_stmt, x);
1241 seq = lower_try_finally_dup_block (finally, state);
1242 lower_eh_constructs_1 (state, seq);
1243 gimple_seq_add_seq (&new_stmt, seq);
1245 gimple_seq_add_stmt (&new_stmt, q->cont_stmt);
1246 maybe_record_in_goto_queue (state, q->cont_stmt);
1249 for (q = tf->goto_queue; q < qe; q++)
1253 index = q->index < 0 ? return_index : q->index;
1255 if (labels[index].q == q)
1258 lab = labels[index].label;
1260 if (index == return_index)
1261 do_return_redirection (q, lab, NULL, &return_val);
1263 do_goto_redirection (q, lab, NULL, tf);
1266 replace_goto_queue (tf);
1270 /* Need to link new stmts after running replace_goto_queue due
1271 to not wanting to process the same goto stmts twice. */
1272 gimple_seq_add_seq (&tf->top_p_seq, new_stmt);
1275 /* A subroutine of lower_try_finally. There are multiple edges incoming
1276 and outgoing from the finally block. Implement this by instrumenting
1277 each incoming edge and creating a switch statement at the end of the
1278 finally block that branches to the appropriate destination. */
1281 lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf)
1283 struct goto_queue_node *q, *qe;
1284 tree return_val = NULL;
1285 tree finally_tmp, finally_label;
1286 int return_index, eh_index, fallthru_index;
1287 int nlabels, ndests, j, last_case_index;
1289 VEC (tree,heap) *case_label_vec;
1290 gimple_seq switch_body;
1295 struct pointer_map_t *cont_map = NULL;
1296 /* The location of the TRY_FINALLY stmt. */
1297 location_t tf_loc = gimple_location (tf->try_finally_expr);
1298 /* The location of the finally block. */
1299 location_t finally_loc;
1301 switch_body = gimple_seq_alloc ();
1303 /* Mash the TRY block to the head of the chain. */
1304 finally = gimple_try_cleanup (tf->top_p);
1305 tf->top_p_seq = gimple_try_eval (tf->top_p);
1307 /* The location of the finally is either the last stmt in the finally
1308 block or the location of the TRY_FINALLY itself. */
1309 finally_loc = gimple_seq_last_stmt (tf->top_p_seq) != NULL ?
1310 gimple_location (gimple_seq_last_stmt (tf->top_p_seq))
1313 /* Lower the finally block itself. */
1314 lower_eh_constructs_1 (state, finally);
1316 /* Prepare for switch statement generation. */
1317 nlabels = VEC_length (tree, tf->dest_array);
1318 return_index = nlabels;
1319 eh_index = return_index + tf->may_return;
1320 fallthru_index = eh_index + tf->may_throw;
1321 ndests = fallthru_index + tf->may_fallthru;
1323 finally_tmp = create_tmp_var (integer_type_node, "finally_tmp");
1324 finally_label = create_artificial_label (finally_loc);
1326 /* We use VEC_quick_push on case_label_vec throughout this function,
1327 since we know the size in advance and allocate precisely as muce
1329 case_label_vec = VEC_alloc (tree, heap, ndests);
1331 last_case_index = 0;
1333 /* Begin inserting code for getting to the finally block. Things
1334 are done in this order to correspond to the sequence the code is
1337 if (tf->may_fallthru)
1339 x = gimple_build_assign (finally_tmp,
1340 build_int_cst (NULL, fallthru_index));
1341 gimple_seq_add_stmt (&tf->top_p_seq, x);
1343 last_case = build3 (CASE_LABEL_EXPR, void_type_node,
1344 build_int_cst (NULL, fallthru_index),
1345 NULL, create_artificial_label (tf_loc));
1346 VEC_quick_push (tree, case_label_vec, last_case);
1349 x = gimple_build_label (CASE_LABEL (last_case));
1350 gimple_seq_add_stmt (&switch_body, x);
1352 tmp = lower_try_finally_fallthru_label (tf);
1353 x = gimple_build_goto (tmp);
1354 gimple_seq_add_stmt (&switch_body, x);
1359 emit_post_landing_pad (&eh_seq, tf->region);
1361 x = gimple_build_assign (finally_tmp,
1362 build_int_cst (NULL, eh_index));
1363 gimple_seq_add_stmt (&eh_seq, x);
1365 x = gimple_build_goto (finally_label);
1366 gimple_seq_add_stmt (&eh_seq, x);
1368 last_case = build3 (CASE_LABEL_EXPR, void_type_node,
1369 build_int_cst (NULL, eh_index),
1370 NULL, create_artificial_label (tf_loc));
1371 VEC_quick_push (tree, case_label_vec, last_case);
1374 x = gimple_build_label (CASE_LABEL (last_case));
1375 gimple_seq_add_stmt (&eh_seq, x);
1376 emit_resx (&eh_seq, tf->region);
1379 x = gimple_build_label (finally_label);
1380 gimple_seq_add_stmt (&tf->top_p_seq, x);
1382 gimple_seq_add_seq (&tf->top_p_seq, finally);
1384 /* Redirect each incoming goto edge. */
1386 qe = q + tf->goto_queue_active;
1387 j = last_case_index + tf->may_return;
1388 /* Prepare the assignments to finally_tmp that are executed upon the
1389 entrance through a particular edge. */
1394 unsigned int case_index;
1396 mod = gimple_seq_alloc ();
1400 x = gimple_build_assign (finally_tmp,
1401 build_int_cst (NULL, return_index));
1402 gimple_seq_add_stmt (&mod, x);
1403 do_return_redirection (q, finally_label, mod, &return_val);
1404 switch_id = return_index;
1408 x = gimple_build_assign (finally_tmp,
1409 build_int_cst (NULL, q->index));
1410 gimple_seq_add_stmt (&mod, x);
1411 do_goto_redirection (q, finally_label, mod, tf);
1412 switch_id = q->index;
1415 case_index = j + q->index;
1416 if (VEC_length (tree, case_label_vec) <= case_index
1417 || !VEC_index (tree, case_label_vec, case_index))
1421 case_lab = build3 (CASE_LABEL_EXPR, void_type_node,
1422 build_int_cst (NULL, switch_id),
1424 /* We store the cont_stmt in the pointer map, so that we can recover
1425 it in the loop below. We don't create the new label while
1426 walking the goto_queue because pointers don't offer a stable
1429 cont_map = pointer_map_create ();
1430 slot = pointer_map_insert (cont_map, case_lab);
1431 *slot = q->cont_stmt;
1432 VEC_quick_push (tree, case_label_vec, case_lab);
1435 for (j = last_case_index; j < last_case_index + nlabels; j++)
1441 last_case = VEC_index (tree, case_label_vec, j);
1443 gcc_assert (last_case);
1444 gcc_assert (cont_map);
1446 slot = pointer_map_contains (cont_map, last_case);
1447 /* As the comment above suggests, CASE_LABEL (last_case) was just a
1448 placeholder, it does not store an actual label, yet. */
1450 cont_stmt = *(gimple *) slot;
1452 label = create_artificial_label (tf_loc);
1453 CASE_LABEL (last_case) = label;
1455 x = gimple_build_label (label);
1456 gimple_seq_add_stmt (&switch_body, x);
1457 gimple_seq_add_stmt (&switch_body, cont_stmt);
1458 maybe_record_in_goto_queue (state, cont_stmt);
1461 pointer_map_destroy (cont_map);
1463 replace_goto_queue (tf);
1465 /* Make sure that the last case is the default label, as one is required.
1466 Then sort the labels, which is also required in GIMPLE. */
1467 CASE_LOW (last_case) = NULL;
1468 sort_case_labels (case_label_vec);
1470 /* Build the switch statement, setting last_case to be the default
1472 switch_stmt = gimple_build_switch_vec (finally_tmp, last_case,
1474 gimple_set_location (switch_stmt, finally_loc);
1476 /* Need to link SWITCH_STMT after running replace_goto_queue
1477 due to not wanting to process the same goto stmts twice. */
1478 gimple_seq_add_stmt (&tf->top_p_seq, switch_stmt);
1479 gimple_seq_add_seq (&tf->top_p_seq, switch_body);
1482 /* Decide whether or not we are going to duplicate the finally block.
1483 There are several considerations.
1485 First, if this is Java, then the finally block contains code
1486 written by the user. It has line numbers associated with it,
1487 so duplicating the block means it's difficult to set a breakpoint.
1488 Since controlling code generation via -g is verboten, we simply
1489 never duplicate code without optimization.
1491 Second, we'd like to prevent egregious code growth. One way to
1492 do this is to estimate the size of the finally block, multiply
1493 that by the number of copies we'd need to make, and compare against
1494 the estimate of the size of the switch machinery we'd have to add. */
1497 decide_copy_try_finally (int ndests, gimple_seq finally)
1499 int f_estimate, sw_estimate;
1504 /* Finally estimate N times, plus N gotos. */
1505 f_estimate = count_insns_seq (finally, &eni_size_weights);
1506 f_estimate = (f_estimate + 1) * ndests;
1508 /* Switch statement (cost 10), N variable assignments, N gotos. */
1509 sw_estimate = 10 + 2 * ndests;
1511 /* Optimize for size clearly wants our best guess. */
1512 if (optimize_function_for_size_p (cfun))
1513 return f_estimate < sw_estimate;
1515 /* ??? These numbers are completely made up so far. */
1517 return f_estimate < 100 || f_estimate < sw_estimate * 2;
1519 return f_estimate < 40 || f_estimate * 2 < sw_estimate * 3;
1523 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_FINALLY nodes
1524 to a sequence of labels and blocks, plus the exception region trees
1525 that record all the magic. This is complicated by the need to
1526 arrange for the FINALLY block to be executed on all exits. */
1529 lower_try_finally (struct leh_state *state, gimple tp)
1531 struct leh_tf_state this_tf;
1532 struct leh_state this_state;
1535 /* Process the try block. */
1537 memset (&this_tf, 0, sizeof (this_tf));
1538 this_tf.try_finally_expr = tp;
1540 this_tf.outer = state;
1541 if (using_eh_for_cleanups_p)
1542 this_tf.region = gen_eh_region_cleanup (state->cur_region);
1544 this_tf.region = NULL;
1546 this_state.cur_region = this_tf.region;
1547 this_state.ehp_region = state->ehp_region;
1548 this_state.tf = &this_tf;
1550 lower_eh_constructs_1 (&this_state, gimple_try_eval(tp));
1552 /* Determine if the try block is escaped through the bottom. */
1553 this_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp));
1555 /* Determine if any exceptions are possible within the try block. */
1556 if (using_eh_for_cleanups_p)
1557 this_tf.may_throw = eh_region_may_contain_throw (this_tf.region);
1558 if (this_tf.may_throw)
1559 honor_protect_cleanup_actions (state, &this_state, &this_tf);
1561 /* Determine how many edges (still) reach the finally block. Or rather,
1562 how many destinations are reached by the finally block. Use this to
1563 determine how we process the finally block itself. */
1565 ndests = VEC_length (tree, this_tf.dest_array);
1566 ndests += this_tf.may_fallthru;
1567 ndests += this_tf.may_return;
1568 ndests += this_tf.may_throw;
1570 /* If the FINALLY block is not reachable, dike it out. */
1573 gimple_seq_add_seq (&this_tf.top_p_seq, gimple_try_eval (tp));
1574 gimple_try_set_cleanup (tp, NULL);
1576 /* If the finally block doesn't fall through, then any destination
1577 we might try to impose there isn't reached either. There may be
1578 some minor amount of cleanup and redirection still needed. */
1579 else if (!gimple_seq_may_fallthru (gimple_try_cleanup (tp)))
1580 lower_try_finally_nofallthru (state, &this_tf);
1582 /* We can easily special-case redirection to a single destination. */
1583 else if (ndests == 1)
1584 lower_try_finally_onedest (state, &this_tf);
1585 else if (decide_copy_try_finally (ndests, gimple_try_cleanup (tp)))
1586 lower_try_finally_copy (state, &this_tf);
1588 lower_try_finally_switch (state, &this_tf);
1590 /* If someone requested we add a label at the end of the transformed
1592 if (this_tf.fallthru_label)
1594 /* This must be reached only if ndests == 0. */
1595 gimple x = gimple_build_label (this_tf.fallthru_label);
1596 gimple_seq_add_stmt (&this_tf.top_p_seq, x);
1599 VEC_free (tree, heap, this_tf.dest_array);
1600 if (this_tf.goto_queue)
1601 free (this_tf.goto_queue);
1602 if (this_tf.goto_queue_map)
1603 pointer_map_destroy (this_tf.goto_queue_map);
1605 return this_tf.top_p_seq;
1608 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_CATCH with a
1609 list of GIMPLE_CATCH to a sequence of labels and blocks, plus the
1610 exception region trees that records all the magic. */
1613 lower_catch (struct leh_state *state, gimple tp)
1615 eh_region try_region = NULL;
1616 struct leh_state this_state = *state;
1617 gimple_stmt_iterator gsi;
1621 location_t try_catch_loc = gimple_location (tp);
1623 if (flag_exceptions)
1625 try_region = gen_eh_region_try (state->cur_region);
1626 this_state.cur_region = try_region;
1629 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
1631 if (!eh_region_may_contain_throw (try_region))
1632 return gimple_try_eval (tp);
1635 emit_eh_dispatch (&new_seq, try_region);
1636 emit_resx (&new_seq, try_region);
1638 this_state.cur_region = state->cur_region;
1639 this_state.ehp_region = try_region;
1642 for (gsi = gsi_start (gimple_try_cleanup (tp));
1650 gcatch = gsi_stmt (gsi);
1651 c = gen_eh_region_catch (try_region, gimple_catch_types (gcatch));
1653 handler = gimple_catch_handler (gcatch);
1654 lower_eh_constructs_1 (&this_state, handler);
1656 c->label = create_artificial_label (UNKNOWN_LOCATION);
1657 x = gimple_build_label (c->label);
1658 gimple_seq_add_stmt (&new_seq, x);
1660 gimple_seq_add_seq (&new_seq, handler);
1662 if (gimple_seq_may_fallthru (new_seq))
1665 out_label = create_artificial_label (try_catch_loc);
1667 x = gimple_build_goto (out_label);
1668 gimple_seq_add_stmt (&new_seq, x);
1674 gimple_try_set_cleanup (tp, new_seq);
1676 return frob_into_branch_around (tp, try_region, out_label);
1679 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with a
1680 GIMPLE_EH_FILTER to a sequence of labels and blocks, plus the exception
1681 region trees that record all the magic. */
1684 lower_eh_filter (struct leh_state *state, gimple tp)
1686 struct leh_state this_state = *state;
1687 eh_region this_region = NULL;
1691 inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
1693 if (flag_exceptions)
1695 this_region = gen_eh_region_allowed (state->cur_region,
1696 gimple_eh_filter_types (inner));
1697 this_state.cur_region = this_region;
1700 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
1702 if (!eh_region_may_contain_throw (this_region))
1703 return gimple_try_eval (tp);
1706 this_state.cur_region = state->cur_region;
1707 this_state.ehp_region = this_region;
1709 emit_eh_dispatch (&new_seq, this_region);
1710 emit_resx (&new_seq, this_region);
1712 this_region->u.allowed.label = create_artificial_label (UNKNOWN_LOCATION);
1713 x = gimple_build_label (this_region->u.allowed.label);
1714 gimple_seq_add_stmt (&new_seq, x);
1716 lower_eh_constructs_1 (&this_state, gimple_eh_filter_failure (inner));
1717 gimple_seq_add_seq (&new_seq, gimple_eh_filter_failure (inner));
1719 gimple_try_set_cleanup (tp, new_seq);
1721 return frob_into_branch_around (tp, this_region, NULL);
1724 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with
1725 an GIMPLE_EH_MUST_NOT_THROW to a sequence of labels and blocks,
1726 plus the exception region trees that record all the magic. */
1729 lower_eh_must_not_throw (struct leh_state *state, gimple tp)
1731 struct leh_state this_state = *state;
1733 if (flag_exceptions)
1735 gimple inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
1736 eh_region this_region;
1738 this_region = gen_eh_region_must_not_throw (state->cur_region);
1739 this_region->u.must_not_throw.failure_decl
1740 = gimple_eh_must_not_throw_fndecl (inner);
1741 this_region->u.must_not_throw.failure_loc = gimple_location (tp);
1743 /* In order to get mangling applied to this decl, we must mark it
1744 used now. Otherwise, pass_ipa_free_lang_data won't think it
1746 TREE_USED (this_region->u.must_not_throw.failure_decl) = 1;
1748 this_state.cur_region = this_region;
1751 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
1753 return gimple_try_eval (tp);
1756 /* Implement a cleanup expression. This is similar to try-finally,
1757 except that we only execute the cleanup block for exception edges. */
1760 lower_cleanup (struct leh_state *state, gimple tp)
1762 struct leh_state this_state = *state;
1763 eh_region this_region = NULL;
1764 struct leh_tf_state fake_tf;
1767 if (flag_exceptions)
1769 this_region = gen_eh_region_cleanup (state->cur_region);
1770 this_state.cur_region = this_region;
1773 lower_eh_constructs_1 (&this_state, gimple_try_eval (tp));
1775 if (!eh_region_may_contain_throw (this_region))
1776 return gimple_try_eval (tp);
1778 /* Build enough of a try-finally state so that we can reuse
1779 honor_protect_cleanup_actions. */
1780 memset (&fake_tf, 0, sizeof (fake_tf));
1781 fake_tf.top_p = fake_tf.try_finally_expr = tp;
1782 fake_tf.outer = state;
1783 fake_tf.region = this_region;
1784 fake_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp));
1785 fake_tf.may_throw = true;
1787 honor_protect_cleanup_actions (state, NULL, &fake_tf);
1789 if (fake_tf.may_throw)
1791 /* In this case honor_protect_cleanup_actions had nothing to do,
1792 and we should process this normally. */
1793 lower_eh_constructs_1 (state, gimple_try_cleanup (tp));
1794 result = frob_into_branch_around (tp, this_region,
1795 fake_tf.fallthru_label);
1799 /* In this case honor_protect_cleanup_actions did nearly all of
1800 the work. All we have left is to append the fallthru_label. */
1802 result = gimple_try_eval (tp);
1803 if (fake_tf.fallthru_label)
1805 gimple x = gimple_build_label (fake_tf.fallthru_label);
1806 gimple_seq_add_stmt (&result, x);
1812 /* Main loop for lowering eh constructs. Also moves gsi to the next
1816 lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
1820 gimple stmt = gsi_stmt (*gsi);
1822 switch (gimple_code (stmt))
1826 tree fndecl = gimple_call_fndecl (stmt);
1829 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
1830 switch (DECL_FUNCTION_CODE (fndecl))
1832 case BUILT_IN_EH_POINTER:
1833 /* The front end may have generated a call to
1834 __builtin_eh_pointer (0) within a catch region. Replace
1835 this zero argument with the current catch region number. */
1836 if (state->ehp_region)
1838 tree nr = build_int_cst (NULL, state->ehp_region->index);
1839 gimple_call_set_arg (stmt, 0, nr);
1843 /* The user has dome something silly. Remove it. */
1844 rhs = build_int_cst (ptr_type_node, 0);
1849 case BUILT_IN_EH_FILTER:
1850 /* ??? This should never appear, but since it's a builtin it
1851 is accessible to abuse by users. Just remove it and
1852 replace the use with the arbitrary value zero. */
1853 rhs = build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
1855 lhs = gimple_call_lhs (stmt);
1856 x = gimple_build_assign (lhs, rhs);
1857 gsi_insert_before (gsi, x, GSI_SAME_STMT);
1860 case BUILT_IN_EH_COPY_VALUES:
1861 /* Likewise this should not appear. Remove it. */
1862 gsi_remove (gsi, true);
1872 /* If the stmt can throw use a new temporary for the assignment
1873 to a LHS. This makes sure the old value of the LHS is
1874 available on the EH edge. Only do so for statements that
1875 potentially fall thru (no noreturn calls e.g.), otherwise
1876 this new assignment might create fake fallthru regions. */
1877 if (stmt_could_throw_p (stmt)
1878 && gimple_has_lhs (stmt)
1879 && gimple_stmt_may_fallthru (stmt)
1880 && !tree_could_throw_p (gimple_get_lhs (stmt))
1881 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
1883 tree lhs = gimple_get_lhs (stmt);
1884 tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
1885 gimple s = gimple_build_assign (lhs, tmp);
1886 gimple_set_location (s, gimple_location (stmt));
1887 gimple_set_block (s, gimple_block (stmt));
1888 gimple_set_lhs (stmt, tmp);
1889 if (TREE_CODE (TREE_TYPE (tmp)) == COMPLEX_TYPE
1890 || TREE_CODE (TREE_TYPE (tmp)) == VECTOR_TYPE)
1891 DECL_GIMPLE_REG_P (tmp) = 1;
1892 gsi_insert_after (gsi, s, GSI_SAME_STMT);
1894 /* Look for things that can throw exceptions, and record them. */
1895 if (state->cur_region && stmt_could_throw_p (stmt))
1897 record_stmt_eh_region (state->cur_region, stmt);
1898 note_eh_region_may_contain_throw (state->cur_region);
1905 maybe_record_in_goto_queue (state, stmt);
1909 verify_norecord_switch_expr (state, stmt);
1913 if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
1914 replace = lower_try_finally (state, stmt);
1917 x = gimple_seq_first_stmt (gimple_try_cleanup (stmt));
1920 replace = gimple_try_eval (stmt);
1921 lower_eh_constructs_1 (state, replace);
1924 switch (gimple_code (x))
1927 replace = lower_catch (state, stmt);
1929 case GIMPLE_EH_FILTER:
1930 replace = lower_eh_filter (state, stmt);
1932 case GIMPLE_EH_MUST_NOT_THROW:
1933 replace = lower_eh_must_not_throw (state, stmt);
1936 replace = lower_cleanup (state, stmt);
1941 /* Remove the old stmt and insert the transformed sequence
1943 gsi_insert_seq_before (gsi, replace, GSI_SAME_STMT);
1944 gsi_remove (gsi, true);
1946 /* Return since we don't want gsi_next () */
1950 /* A type, a decl, or some kind of statement that we're not
1951 interested in. Don't walk them. */
1958 /* A helper to unwrap a gimple_seq and feed stmts to lower_eh_constructs_2. */
1961 lower_eh_constructs_1 (struct leh_state *state, gimple_seq seq)
1963 gimple_stmt_iterator gsi;
1964 for (gsi = gsi_start (seq); !gsi_end_p (gsi);)
1965 lower_eh_constructs_2 (state, &gsi);
1969 lower_eh_constructs (void)
1971 struct leh_state null_state;
1974 bodyp = gimple_body (current_function_decl);
1978 finally_tree = htab_create (31, struct_ptr_hash, struct_ptr_eq, free);
1979 eh_region_may_contain_throw_map = BITMAP_ALLOC (NULL);
1980 memset (&null_state, 0, sizeof (null_state));
1982 collect_finally_tree_1 (bodyp, NULL);
1983 lower_eh_constructs_1 (&null_state, bodyp);
1985 /* We assume there's a return statement, or something, at the end of
1986 the function, and thus ploping the EH sequence afterward won't
1988 gcc_assert (!gimple_seq_may_fallthru (bodyp));
1989 gimple_seq_add_seq (&bodyp, eh_seq);
1991 /* We assume that since BODYP already existed, adding EH_SEQ to it
1992 didn't change its value, and we don't have to re-set the function. */
1993 gcc_assert (bodyp == gimple_body (current_function_decl));
1995 htab_delete (finally_tree);
1996 BITMAP_FREE (eh_region_may_contain_throw_map);
1999 /* If this function needs a language specific EH personality routine
2000 and the frontend didn't already set one do so now. */
2001 if (function_needs_eh_personality (cfun) == eh_personality_lang
2002 && !DECL_FUNCTION_PERSONALITY (current_function_decl))
2003 DECL_FUNCTION_PERSONALITY (current_function_decl)
2004 = lang_hooks.eh_personality ();
2009 struct gimple_opt_pass pass_lower_eh =
2015 lower_eh_constructs, /* execute */
2018 0, /* static_pass_number */
2019 TV_TREE_EH, /* tv_id */
2020 PROP_gimple_lcf, /* properties_required */
2021 PROP_gimple_leh, /* properties_provided */
2022 0, /* properties_destroyed */
2023 0, /* todo_flags_start */
2024 TODO_dump_func /* todo_flags_finish */
2028 /* Create the multiple edges from an EH_DISPATCH statement to all of
2029 the possible handlers for its EH region. Return true if there's
2030 no fallthru edge; false if there is. */
2033 make_eh_dispatch_edges (gimple stmt)
2037 basic_block src, dst;
2039 r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt));
2040 src = gimple_bb (stmt);
2045 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
2047 dst = label_to_block (c->label);
2048 make_edge (src, dst, 0);
2050 /* A catch-all handler doesn't have a fallthru. */
2051 if (c->type_list == NULL)
2056 case ERT_ALLOWED_EXCEPTIONS:
2057 dst = label_to_block (r->u.allowed.label);
2058 make_edge (src, dst, 0);
2068 /* Create the single EH edge from STMT to its nearest landing pad,
2069 if there is such a landing pad within the current function. */
2072 make_eh_edges (gimple stmt)
2074 basic_block src, dst;
2078 lp_nr = lookup_stmt_eh_lp (stmt);
2082 lp = get_eh_landing_pad_from_number (lp_nr);
2083 gcc_assert (lp != NULL);
2085 src = gimple_bb (stmt);
2086 dst = label_to_block (lp->post_landing_pad);
2087 make_edge (src, dst, EDGE_EH);
2090 /* Do the work in redirecting EDGE_IN to NEW_BB within the EH region tree;
2091 do not actually perform the final edge redirection.
2093 CHANGE_REGION is true when we're being called from cleanup_empty_eh and
2094 we intend to change the destination EH region as well; this means
2095 EH_LANDING_PAD_NR must already be set on the destination block label.
2096 If false, we're being called from generic cfg manipulation code and we
2097 should preserve our place within the region tree. */
2100 redirect_eh_edge_1 (edge edge_in, basic_block new_bb, bool change_region)
2102 eh_landing_pad old_lp, new_lp;
2105 int old_lp_nr, new_lp_nr;
2106 tree old_label, new_label;
2110 old_bb = edge_in->dest;
2111 old_label = gimple_block_label (old_bb);
2112 old_lp_nr = EH_LANDING_PAD_NR (old_label);
2113 gcc_assert (old_lp_nr > 0);
2114 old_lp = get_eh_landing_pad_from_number (old_lp_nr);
2116 throw_stmt = last_stmt (edge_in->src);
2117 gcc_assert (lookup_stmt_eh_lp (throw_stmt) == old_lp_nr);
2119 new_label = gimple_block_label (new_bb);
2121 /* Look for an existing region that might be using NEW_BB already. */
2122 new_lp_nr = EH_LANDING_PAD_NR (new_label);
2125 new_lp = get_eh_landing_pad_from_number (new_lp_nr);
2126 gcc_assert (new_lp);
2128 /* Unless CHANGE_REGION is true, the new and old landing pad
2129 had better be associated with the same EH region. */
2130 gcc_assert (change_region || new_lp->region == old_lp->region);
2135 gcc_assert (!change_region);
2138 /* Notice when we redirect the last EH edge away from OLD_BB. */
2139 FOR_EACH_EDGE (e, ei, old_bb->preds)
2140 if (e != edge_in && (e->flags & EDGE_EH))
2145 /* NEW_LP already exists. If there are still edges into OLD_LP,
2146 there's nothing to do with the EH tree. If there are no more
2147 edges into OLD_LP, then we want to remove OLD_LP as it is unused.
2148 If CHANGE_REGION is true, then our caller is expecting to remove
2150 if (e == NULL && !change_region)
2151 remove_eh_landing_pad (old_lp);
2155 /* No correct landing pad exists. If there are no more edges
2156 into OLD_LP, then we can simply re-use the existing landing pad.
2157 Otherwise, we have to create a new landing pad. */
2160 EH_LANDING_PAD_NR (old_lp->post_landing_pad) = 0;
2164 new_lp = gen_eh_landing_pad (old_lp->region);
2165 new_lp->post_landing_pad = new_label;
2166 EH_LANDING_PAD_NR (new_label) = new_lp->index;
2169 /* Maybe move the throwing statement to the new region. */
2170 if (old_lp != new_lp)
2172 remove_stmt_from_eh_lp (throw_stmt);
2173 add_stmt_to_eh_lp (throw_stmt, new_lp->index);
2177 /* Redirect EH edge E to NEW_BB. */
2180 redirect_eh_edge (edge edge_in, basic_block new_bb)
2182 redirect_eh_edge_1 (edge_in, new_bb, false);
2183 return ssa_redirect_edge (edge_in, new_bb);
2186 /* This is a subroutine of gimple_redirect_edge_and_branch. Update the
2187 labels for redirecting a non-fallthru EH_DISPATCH edge E to NEW_BB.
2188 The actual edge update will happen in the caller. */
2191 redirect_eh_dispatch_edge (gimple stmt, edge e, basic_block new_bb)
2193 tree new_lab = gimple_block_label (new_bb);
2194 bool any_changed = false;
2199 r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt));
2203 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
2205 old_bb = label_to_block (c->label);
2206 if (old_bb == e->dest)
2214 case ERT_ALLOWED_EXCEPTIONS:
2215 old_bb = label_to_block (r->u.allowed.label);
2216 gcc_assert (old_bb == e->dest);
2217 r->u.allowed.label = new_lab;
2225 gcc_assert (any_changed);
2228 /* Helper function for operation_could_trap_p and stmt_could_throw_p. */
2231 operation_could_trap_helper_p (enum tree_code op,
2242 case TRUNC_DIV_EXPR:
2244 case FLOOR_DIV_EXPR:
2245 case ROUND_DIV_EXPR:
2246 case EXACT_DIV_EXPR:
2248 case FLOOR_MOD_EXPR:
2249 case ROUND_MOD_EXPR:
2250 case TRUNC_MOD_EXPR:
2252 if (honor_snans || honor_trapv)
2255 return flag_trapping_math;
2256 if (!TREE_CONSTANT (divisor) || integer_zerop (divisor))
2265 /* Some floating point comparisons may trap. */
2270 case UNORDERED_EXPR:
2280 case FIX_TRUNC_EXPR:
2281 /* Conversion of floating point might trap. */
2287 /* These operations don't trap with floating point. */
2295 /* Any floating arithmetic may trap. */
2296 if (fp_operation && flag_trapping_math)
2303 /* Any floating arithmetic may trap. */
2304 if (fp_operation && flag_trapping_math)
2312 /* Return true if operation OP may trap. FP_OPERATION is true if OP is applied
2313 on floating-point values. HONOR_TRAPV is true if OP is applied on integer
2314 type operands that may trap. If OP is a division operator, DIVISOR contains
2315 the value of the divisor. */
2318 operation_could_trap_p (enum tree_code op, bool fp_operation, bool honor_trapv,
2321 bool honor_nans = (fp_operation && flag_trapping_math
2322 && !flag_finite_math_only);
2323 bool honor_snans = fp_operation && flag_signaling_nans != 0;
2326 if (TREE_CODE_CLASS (op) != tcc_comparison
2327 && TREE_CODE_CLASS (op) != tcc_unary
2328 && TREE_CODE_CLASS (op) != tcc_binary)
2331 return operation_could_trap_helper_p (op, fp_operation, honor_trapv,
2332 honor_nans, honor_snans, divisor,
2336 /* Return true if EXPR can trap, as in dereferencing an invalid pointer
2337 location or floating point arithmetic. C.f. the rtl version, may_trap_p.
2338 This routine expects only GIMPLE lhs or rhs input. */
2341 tree_could_trap_p (tree expr)
2343 enum tree_code code;
2344 bool fp_operation = false;
2345 bool honor_trapv = false;
2346 tree t, base, div = NULL_TREE;
2351 code = TREE_CODE (expr);
2352 t = TREE_TYPE (expr);
2356 if (COMPARISON_CLASS_P (expr))
2357 fp_operation = FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0)));
2359 fp_operation = FLOAT_TYPE_P (t);
2360 honor_trapv = INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t);
2363 if (TREE_CODE_CLASS (code) == tcc_binary)
2364 div = TREE_OPERAND (expr, 1);
2365 if (operation_could_trap_p (code, fp_operation, honor_trapv, div))
2371 case TARGET_MEM_REF:
2372 /* For TARGET_MEM_REFs use the information based on the original
2374 expr = TMR_ORIGINAL (expr);
2375 code = TREE_CODE (expr);
2382 case VIEW_CONVERT_EXPR:
2383 case WITH_SIZE_EXPR:
2384 expr = TREE_OPERAND (expr, 0);
2385 code = TREE_CODE (expr);
2388 case ARRAY_RANGE_REF:
2389 base = TREE_OPERAND (expr, 0);
2390 if (tree_could_trap_p (base))
2392 if (TREE_THIS_NOTRAP (expr))
2394 return !range_in_array_bounds_p (expr);
2397 base = TREE_OPERAND (expr, 0);
2398 if (tree_could_trap_p (base))
2400 if (TREE_THIS_NOTRAP (expr))
2402 return !in_array_bounds_p (expr);
2405 case ALIGN_INDIRECT_REF:
2406 case MISALIGNED_INDIRECT_REF:
2407 return !TREE_THIS_NOTRAP (expr);
2410 return TREE_THIS_VOLATILE (expr);
2413 t = get_callee_fndecl (expr);
2414 /* Assume that calls to weak functions may trap. */
2415 if (!t || !DECL_P (t) || DECL_WEAK (t))
2425 /* Helper for stmt_could_throw_p. Return true if STMT (assumed to be a
2426 an assignment or a conditional) may throw. */
2429 stmt_could_throw_1_p (gimple stmt)
2431 enum tree_code code = gimple_expr_code (stmt);
2432 bool honor_nans = false;
2433 bool honor_snans = false;
2434 bool fp_operation = false;
2435 bool honor_trapv = false;
2440 if (TREE_CODE_CLASS (code) == tcc_comparison
2441 || TREE_CODE_CLASS (code) == tcc_unary
2442 || TREE_CODE_CLASS (code) == tcc_binary)
2444 t = gimple_expr_type (stmt);
2445 fp_operation = FLOAT_TYPE_P (t);
2448 honor_nans = flag_trapping_math && !flag_finite_math_only;
2449 honor_snans = flag_signaling_nans != 0;
2451 else if (INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t))
2455 /* Check if the main expression may trap. */
2456 t = is_gimple_assign (stmt) ? gimple_assign_rhs2 (stmt) : NULL;
2457 ret = operation_could_trap_helper_p (code, fp_operation, honor_trapv,
2458 honor_nans, honor_snans, t,
2463 /* If the expression does not trap, see if any of the individual operands may
2465 for (i = 0; i < gimple_num_ops (stmt); i++)
2466 if (tree_could_trap_p (gimple_op (stmt, i)))
2473 /* Return true if statement STMT could throw an exception. */
2476 stmt_could_throw_p (gimple stmt)
2478 if (!flag_exceptions)
2481 /* The only statements that can throw an exception are assignments,
2482 conditionals, calls, resx, and asms. */
2483 switch (gimple_code (stmt))
2489 return !gimple_call_nothrow_p (stmt);
2493 if (!flag_non_call_exceptions)
2495 return stmt_could_throw_1_p (stmt);
2498 if (!flag_non_call_exceptions)
2500 return gimple_asm_volatile_p (stmt);
2508 /* Return true if expression T could throw an exception. */
2511 tree_could_throw_p (tree t)
2513 if (!flag_exceptions)
2515 if (TREE_CODE (t) == MODIFY_EXPR)
2517 if (flag_non_call_exceptions
2518 && tree_could_trap_p (TREE_OPERAND (t, 0)))
2520 t = TREE_OPERAND (t, 1);
2523 if (TREE_CODE (t) == WITH_SIZE_EXPR)
2524 t = TREE_OPERAND (t, 0);
2525 if (TREE_CODE (t) == CALL_EXPR)
2526 return (call_expr_flags (t) & ECF_NOTHROW) == 0;
2527 if (flag_non_call_exceptions)
2528 return tree_could_trap_p (t);
2532 /* Return true if STMT can throw an exception that is not caught within
2533 the current function (CFUN). */
2536 stmt_can_throw_external (gimple stmt)
2540 if (!stmt_could_throw_p (stmt))
2543 lp_nr = lookup_stmt_eh_lp (stmt);
2547 /* Return true if STMT can throw an exception that is caught within
2548 the current function (CFUN). */
2551 stmt_can_throw_internal (gimple stmt)
2555 if (!stmt_could_throw_p (stmt))
2558 lp_nr = lookup_stmt_eh_lp (stmt);
2562 /* Given a statement STMT in IFUN, if STMT can no longer throw, then
2563 remove any entry it might have from the EH table. Return true if
2564 any change was made. */
2567 maybe_clean_eh_stmt_fn (struct function *ifun, gimple stmt)
2569 if (stmt_could_throw_p (stmt))
2571 return remove_stmt_from_eh_lp_fn (ifun, stmt);
2574 /* Likewise, but always use the current function. */
2577 maybe_clean_eh_stmt (gimple stmt)
2579 return maybe_clean_eh_stmt_fn (cfun, stmt);
2582 /* Given a statement OLD_STMT and a new statement NEW_STMT that has replaced
2583 OLD_STMT in the function, remove OLD_STMT from the EH table and put NEW_STMT
2584 in the table if it should be in there. Return TRUE if a replacement was
2585 done that my require an EH edge purge. */
2588 maybe_clean_or_replace_eh_stmt (gimple old_stmt, gimple new_stmt)
2590 int lp_nr = lookup_stmt_eh_lp (old_stmt);
2594 bool new_stmt_could_throw = stmt_could_throw_p (new_stmt);
2596 if (new_stmt == old_stmt && new_stmt_could_throw)
2599 remove_stmt_from_eh_lp (old_stmt);
2600 if (new_stmt_could_throw)
2602 add_stmt_to_eh_lp (new_stmt, lp_nr);
2612 /* Given a statement OLD_STMT in OLD_FUN and a duplicate statment NEW_STMT
2613 in NEW_FUN, copy the EH table data from OLD_STMT to NEW_STMT. The MAP
2614 operand is the return value of duplicate_eh_regions. */
2617 maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple new_stmt,
2618 struct function *old_fun, gimple old_stmt,
2619 struct pointer_map_t *map, int default_lp_nr)
2621 int old_lp_nr, new_lp_nr;
2624 if (!stmt_could_throw_p (new_stmt))
2627 old_lp_nr = lookup_stmt_eh_lp_fn (old_fun, old_stmt);
2630 if (default_lp_nr == 0)
2632 new_lp_nr = default_lp_nr;
2634 else if (old_lp_nr > 0)
2636 eh_landing_pad old_lp, new_lp;
2638 old_lp = VEC_index (eh_landing_pad, old_fun->eh->lp_array, old_lp_nr);
2639 slot = pointer_map_contains (map, old_lp);
2640 new_lp = (eh_landing_pad) *slot;
2641 new_lp_nr = new_lp->index;
2645 eh_region old_r, new_r;
2647 old_r = VEC_index (eh_region, old_fun->eh->region_array, -old_lp_nr);
2648 slot = pointer_map_contains (map, old_r);
2649 new_r = (eh_region) *slot;
2650 new_lp_nr = -new_r->index;
2653 add_stmt_to_eh_lp_fn (new_fun, new_stmt, new_lp_nr);
2657 /* Similar, but both OLD_STMT and NEW_STMT are within the current function,
2658 and thus no remapping is required. */
2661 maybe_duplicate_eh_stmt (gimple new_stmt, gimple old_stmt)
2665 if (!stmt_could_throw_p (new_stmt))
2668 lp_nr = lookup_stmt_eh_lp (old_stmt);
2672 add_stmt_to_eh_lp (new_stmt, lp_nr);
2676 /* Returns TRUE if oneh and twoh are exception handlers (gimple_try_cleanup of
2677 GIMPLE_TRY) that are similar enough to be considered the same. Currently
2678 this only handles handlers consisting of a single call, as that's the
2679 important case for C++: a destructor call for a particular object showing
2680 up in multiple handlers. */
2683 same_handler_p (gimple_seq oneh, gimple_seq twoh)
2685 gimple_stmt_iterator gsi;
2689 gsi = gsi_start (oneh);
2690 if (!gsi_one_before_end_p (gsi))
2692 ones = gsi_stmt (gsi);
2694 gsi = gsi_start (twoh);
2695 if (!gsi_one_before_end_p (gsi))
2697 twos = gsi_stmt (gsi);
2699 if (!is_gimple_call (ones)
2700 || !is_gimple_call (twos)
2701 || gimple_call_lhs (ones)
2702 || gimple_call_lhs (twos)
2703 || gimple_call_chain (ones)
2704 || gimple_call_chain (twos)
2705 || !operand_equal_p (gimple_call_fn (ones), gimple_call_fn (twos), 0)
2706 || gimple_call_num_args (ones) != gimple_call_num_args (twos))
2709 for (ai = 0; ai < gimple_call_num_args (ones); ++ai)
2710 if (!operand_equal_p (gimple_call_arg (ones, ai),
2711 gimple_call_arg (twos, ai), 0))
2718 try { A() } finally { try { ~B() } catch { ~A() } }
2719 try { ... } finally { ~A() }
2721 try { A() } catch { ~B() }
2722 try { ~B() ... } finally { ~A() }
2724 This occurs frequently in C++, where A is a local variable and B is a
2725 temporary used in the initializer for A. */
2728 optimize_double_finally (gimple one, gimple two)
2731 gimple_stmt_iterator gsi;
2733 gsi = gsi_start (gimple_try_cleanup (one));
2734 if (!gsi_one_before_end_p (gsi))
2737 oneh = gsi_stmt (gsi);
2738 if (gimple_code (oneh) != GIMPLE_TRY
2739 || gimple_try_kind (oneh) != GIMPLE_TRY_CATCH)
2742 if (same_handler_p (gimple_try_cleanup (oneh), gimple_try_cleanup (two)))
2744 gimple_seq seq = gimple_try_eval (oneh);
2746 gimple_try_set_cleanup (one, seq);
2747 gimple_try_set_kind (one, GIMPLE_TRY_CATCH);
2748 seq = copy_gimple_seq_and_replace_locals (seq);
2749 gimple_seq_add_seq (&seq, gimple_try_eval (two));
2750 gimple_try_set_eval (two, seq);
2754 /* Perform EH refactoring optimizations that are simpler to do when code
2755 flow has been lowered but EH structures haven't. */
2758 refactor_eh_r (gimple_seq seq)
2760 gimple_stmt_iterator gsi;
2765 gsi = gsi_start (seq);
2769 if (gsi_end_p (gsi))
2772 two = gsi_stmt (gsi);
2775 && gimple_code (one) == GIMPLE_TRY
2776 && gimple_code (two) == GIMPLE_TRY
2777 && gimple_try_kind (one) == GIMPLE_TRY_FINALLY
2778 && gimple_try_kind (two) == GIMPLE_TRY_FINALLY)
2779 optimize_double_finally (one, two);
2781 switch (gimple_code (one))
2784 refactor_eh_r (gimple_try_eval (one));
2785 refactor_eh_r (gimple_try_cleanup (one));
2788 refactor_eh_r (gimple_catch_handler (one));
2790 case GIMPLE_EH_FILTER:
2791 refactor_eh_r (gimple_eh_filter_failure (one));
2806 refactor_eh_r (gimple_body (current_function_decl));
2811 gate_refactor_eh (void)
2813 return flag_exceptions != 0;
2816 struct gimple_opt_pass pass_refactor_eh =
2821 gate_refactor_eh, /* gate */
2822 refactor_eh, /* execute */
2825 0, /* static_pass_number */
2826 TV_TREE_EH, /* tv_id */
2827 PROP_gimple_lcf, /* properties_required */
2828 0, /* properties_provided */
2829 0, /* properties_destroyed */
2830 0, /* todo_flags_start */
2831 TODO_dump_func /* todo_flags_finish */
2835 /* At the end of gimple optimization, we can lower RESX. */
2838 lower_resx (basic_block bb, gimple stmt, struct pointer_map_t *mnt_map)
2841 eh_region src_r, dst_r;
2842 gimple_stmt_iterator gsi;
2847 lp_nr = lookup_stmt_eh_lp (stmt);
2849 dst_r = get_eh_region_from_lp_number (lp_nr);
2853 src_r = get_eh_region_from_number (gimple_resx_region (stmt));
2854 gsi = gsi_last_bb (bb);
2858 /* We can wind up with no source region when pass_cleanup_eh shows
2859 that there are no entries into an eh region and deletes it, but
2860 then the block that contains the resx isn't removed. This can
2861 happen without optimization when the switch statement created by
2862 lower_try_finally_switch isn't simplified to remove the eh case.
2864 Resolve this by expanding the resx node to an abort. */
2866 fn = implicit_built_in_decls[BUILT_IN_TRAP];
2867 x = gimple_build_call (fn, 0);
2868 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
2870 while (EDGE_COUNT (bb->succs) > 0)
2871 remove_edge (EDGE_SUCC (bb, 0));
2875 /* When we have a destination region, we resolve this by copying
2876 the excptr and filter values into place, and changing the edge
2877 to immediately after the landing pad. */
2886 /* We are resuming into a MUST_NOT_CALL region. Expand a call to
2887 the failure decl into a new block, if needed. */
2888 gcc_assert (dst_r->type == ERT_MUST_NOT_THROW);
2890 slot = pointer_map_contains (mnt_map, dst_r);
2893 gimple_stmt_iterator gsi2;
2895 new_bb = create_empty_bb (bb);
2896 lab = gimple_block_label (new_bb);
2897 gsi2 = gsi_start_bb (new_bb);
2899 fn = dst_r->u.must_not_throw.failure_decl;
2900 x = gimple_build_call (fn, 0);
2901 gimple_set_location (x, dst_r->u.must_not_throw.failure_loc);
2902 gsi_insert_after (&gsi2, x, GSI_CONTINUE_LINKING);
2904 slot = pointer_map_insert (mnt_map, dst_r);
2910 new_bb = label_to_block (lab);
2913 gcc_assert (EDGE_COUNT (bb->succs) == 0);
2914 e = make_edge (bb, new_bb, EDGE_FALLTHRU);
2915 e->count = bb->count;
2916 e->probability = REG_BR_PROB_BASE;
2921 tree dst_nr = build_int_cst (NULL, dst_r->index);
2923 fn = implicit_built_in_decls[BUILT_IN_EH_COPY_VALUES];
2924 src_nr = build_int_cst (NULL, src_r->index);
2925 x = gimple_build_call (fn, 2, dst_nr, src_nr);
2926 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
2928 /* Update the flags for the outgoing edge. */
2929 e = single_succ_edge (bb);
2930 gcc_assert (e->flags & EDGE_EH);
2931 e->flags = (e->flags & ~EDGE_EH) | EDGE_FALLTHRU;
2933 /* If there are no more EH users of the landing pad, delete it. */
2934 FOR_EACH_EDGE (e, ei, e->dest->preds)
2935 if (e->flags & EDGE_EH)
2939 eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
2940 remove_eh_landing_pad (lp);
2950 /* When we don't have a destination region, this exception escapes
2951 up the call chain. We resolve this by generating a call to the
2952 _Unwind_Resume library function. */
2954 /* The ARM EABI redefines _Unwind_Resume as __cxa_end_cleanup
2955 with no arguments for C++ and Java. Check for that. */
2956 if (src_r->use_cxa_end_cleanup)
2958 fn = implicit_built_in_decls[BUILT_IN_CXA_END_CLEANUP];
2959 x = gimple_build_call (fn, 0);
2960 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
2964 fn = implicit_built_in_decls[BUILT_IN_EH_POINTER];
2965 src_nr = build_int_cst (NULL, src_r->index);
2966 x = gimple_build_call (fn, 1, src_nr);
2967 var = create_tmp_var (ptr_type_node, NULL);
2968 var = make_ssa_name (var, x);
2969 gimple_call_set_lhs (x, var);
2970 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
2972 fn = implicit_built_in_decls[BUILT_IN_UNWIND_RESUME];
2973 x = gimple_build_call (fn, 1, var);
2974 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
2977 gcc_assert (EDGE_COUNT (bb->succs) == 0);
2980 gsi_remove (&gsi, true);
2986 execute_lower_resx (void)
2989 struct pointer_map_t *mnt_map;
2990 bool dominance_invalidated = false;
2991 bool any_rewritten = false;
2993 mnt_map = pointer_map_create ();
2997 gimple last = last_stmt (bb);
2998 if (last && is_gimple_resx (last))
3000 dominance_invalidated |= lower_resx (bb, last, mnt_map);
3001 any_rewritten = true;
3005 pointer_map_destroy (mnt_map);
3007 if (dominance_invalidated)
3009 free_dominance_info (CDI_DOMINATORS);
3010 free_dominance_info (CDI_POST_DOMINATORS);
3013 return any_rewritten ? TODO_update_ssa_only_virtuals : 0;
3017 gate_lower_resx (void)
3019 return flag_exceptions != 0;
3022 struct gimple_opt_pass pass_lower_resx =
3027 gate_lower_resx, /* gate */
3028 execute_lower_resx, /* execute */
3031 0, /* static_pass_number */
3032 TV_TREE_EH, /* tv_id */
3033 PROP_gimple_lcf, /* properties_required */
3034 0, /* properties_provided */
3035 0, /* properties_destroyed */
3036 0, /* todo_flags_start */
3037 TODO_dump_func | TODO_verify_flow /* todo_flags_finish */
3042 /* At the end of inlining, we can lower EH_DISPATCH. Return true when
3043 we have found some duplicate labels and removed some edges. */
3046 lower_eh_dispatch (basic_block src, gimple stmt)
3048 gimple_stmt_iterator gsi;
3053 bool redirected = false;
3055 region_nr = gimple_eh_dispatch_region (stmt);
3056 r = get_eh_region_from_number (region_nr);
3058 gsi = gsi_last_bb (src);
3064 VEC (tree, heap) *labels = NULL;
3065 tree default_label = NULL;
3069 struct pointer_set_t *seen_values = pointer_set_create ();
3071 /* Collect the labels for a switch. Zero the post_landing_pad
3072 field becase we'll no longer have anything keeping these labels
3073 in existance and the optimizer will be free to merge these
3075 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
3077 tree tp_node, flt_node, lab = c->label;
3078 bool have_label = false;
3081 tp_node = c->type_list;
3082 flt_node = c->filter_list;
3084 if (tp_node == NULL)
3086 default_label = lab;
3091 /* Filter out duplicate labels that arise when this handler
3092 is shadowed by an earlier one. When no labels are
3093 attached to the handler anymore, we remove
3094 the corresponding edge and then we delete unreachable
3095 blocks at the end of this pass. */
3096 if (! pointer_set_contains (seen_values, TREE_VALUE (flt_node)))
3098 tree t = build3 (CASE_LABEL_EXPR, void_type_node,
3099 TREE_VALUE (flt_node), NULL, lab);
3100 VEC_safe_push (tree, heap, labels, t);
3101 pointer_set_insert (seen_values, TREE_VALUE (flt_node));
3105 tp_node = TREE_CHAIN (tp_node);
3106 flt_node = TREE_CHAIN (flt_node);
3111 remove_edge (find_edge (src, label_to_block (lab)));
3116 /* Clean up the edge flags. */
3117 FOR_EACH_EDGE (e, ei, src->succs)
3119 if (e->flags & EDGE_FALLTHRU)
3121 /* If there was no catch-all, use the fallthru edge. */
3122 if (default_label == NULL)
3123 default_label = gimple_block_label (e->dest);
3124 e->flags &= ~EDGE_FALLTHRU;
3127 gcc_assert (default_label != NULL);
3129 /* Don't generate a switch if there's only a default case.
3130 This is common in the form of try { A; } catch (...) { B; }. */
3133 e = single_succ_edge (src);
3134 e->flags |= EDGE_FALLTHRU;
3138 fn = implicit_built_in_decls[BUILT_IN_EH_FILTER];
3139 x = gimple_build_call (fn, 1, build_int_cst (NULL, region_nr));
3140 filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL);
3141 filter = make_ssa_name (filter, x);
3142 gimple_call_set_lhs (x, filter);
3143 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3145 /* Turn the default label into a default case. */
3146 default_label = build3 (CASE_LABEL_EXPR, void_type_node,
3147 NULL, NULL, default_label);
3148 sort_case_labels (labels);
3150 x = gimple_build_switch_vec (filter, default_label, labels);
3151 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3153 VEC_free (tree, heap, labels);
3155 pointer_set_destroy (seen_values);
3159 case ERT_ALLOWED_EXCEPTIONS:
3161 edge b_e = BRANCH_EDGE (src);
3162 edge f_e = FALLTHRU_EDGE (src);
3164 fn = implicit_built_in_decls[BUILT_IN_EH_FILTER];
3165 x = gimple_build_call (fn, 1, build_int_cst (NULL, region_nr));
3166 filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL);
3167 filter = make_ssa_name (filter, x);
3168 gimple_call_set_lhs (x, filter);
3169 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3171 r->u.allowed.label = NULL;
3172 x = gimple_build_cond (EQ_EXPR, filter,
3173 build_int_cst (TREE_TYPE (filter),
3174 r->u.allowed.filter),
3175 NULL_TREE, NULL_TREE);
3176 gsi_insert_before (&gsi, x, GSI_SAME_STMT);
3178 b_e->flags = b_e->flags | EDGE_TRUE_VALUE;
3179 f_e->flags = (f_e->flags & ~EDGE_FALLTHRU) | EDGE_FALSE_VALUE;
3187 /* Replace the EH_DISPATCH with the SWITCH or COND generated above. */
3188 gsi_remove (&gsi, true);
3193 execute_lower_eh_dispatch (void)
3196 bool any_rewritten = false;
3197 bool redirected = false;
3199 assign_filter_values ();
3203 gimple last = last_stmt (bb);
3204 if (last && gimple_code (last) == GIMPLE_EH_DISPATCH)
3206 redirected |= lower_eh_dispatch (bb, last);
3207 any_rewritten = true;
3212 delete_unreachable_blocks ();
3213 return any_rewritten ? TODO_update_ssa_only_virtuals : 0;
3217 gate_lower_eh_dispatch (void)
3219 return cfun->eh->region_tree != NULL;
3222 struct gimple_opt_pass pass_lower_eh_dispatch =
3226 "ehdisp", /* name */
3227 gate_lower_eh_dispatch, /* gate */
3228 execute_lower_eh_dispatch, /* execute */
3231 0, /* static_pass_number */
3232 TV_TREE_EH, /* tv_id */
3233 PROP_gimple_lcf, /* properties_required */
3234 0, /* properties_provided */
3235 0, /* properties_destroyed */
3236 0, /* todo_flags_start */
3237 TODO_dump_func | TODO_verify_flow /* todo_flags_finish */
3241 /* Walk statements, see what regions are really referenced and remove
3242 those that are unused. */
3245 remove_unreachable_handlers (void)
3247 sbitmap r_reachable, lp_reachable;
3253 r_reachable = sbitmap_alloc (VEC_length (eh_region, cfun->eh->region_array));
3255 = sbitmap_alloc (VEC_length (eh_landing_pad, cfun->eh->lp_array));
3256 sbitmap_zero (r_reachable);
3257 sbitmap_zero (lp_reachable);
3261 gimple_stmt_iterator gsi = gsi_start_bb (bb);
3263 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
3265 gimple stmt = gsi_stmt (gsi);
3266 lp_nr = lookup_stmt_eh_lp (stmt);
3268 /* Negative LP numbers are MUST_NOT_THROW regions which
3269 are not considered BB enders. */
3271 SET_BIT (r_reachable, -lp_nr);
3273 /* Positive LP numbers are real landing pads, are are BB enders. */
3276 gcc_assert (gsi_one_before_end_p (gsi));
3277 region = get_eh_region_from_lp_number (lp_nr);
3278 SET_BIT (r_reachable, region->index);
3279 SET_BIT (lp_reachable, lp_nr);
3286 fprintf (dump_file, "Before removal of unreachable regions:\n");
3287 dump_eh_tree (dump_file, cfun);
3288 fprintf (dump_file, "Reachable regions: ");
3289 dump_sbitmap_file (dump_file, r_reachable);
3290 fprintf (dump_file, "Reachable landing pads: ");
3291 dump_sbitmap_file (dump_file, lp_reachable);
3295 VEC_iterate (eh_region, cfun->eh->region_array, r_nr, region); ++r_nr)
3296 if (region && !TEST_BIT (r_reachable, r_nr))
3299 fprintf (dump_file, "Removing unreachable region %d\n", r_nr);
3300 remove_eh_handler (region);
3304 VEC_iterate (eh_landing_pad, cfun->eh->lp_array, lp_nr, lp); ++lp_nr)
3305 if (lp && !TEST_BIT (lp_reachable, lp_nr))
3308 fprintf (dump_file, "Removing unreachable landing pad %d\n", lp_nr);
3309 remove_eh_landing_pad (lp);
3314 fprintf (dump_file, "\n\nAfter removal of unreachable regions:\n");
3315 dump_eh_tree (dump_file, cfun);
3316 fprintf (dump_file, "\n\n");
3319 sbitmap_free (r_reachable);
3320 sbitmap_free (lp_reachable);
3322 #ifdef ENABLE_CHECKING
3323 verify_eh_tree (cfun);
3327 /* Remove regions that do not have landing pads. This assumes
3328 that remove_unreachable_handlers has already been run, and
3329 that we've just manipulated the landing pads since then. */
3332 remove_unreachable_handlers_no_lp (void)
3337 for (i = 1; VEC_iterate (eh_region, cfun->eh->region_array, i, r); ++i)
3338 if (r && r->landing_pads == NULL && r->type != ERT_MUST_NOT_THROW)
3341 fprintf (dump_file, "Removing unreachable region %d\n", i);
3342 remove_eh_handler (r);
3346 /* Undo critical edge splitting on an EH landing pad. Earlier, we
3347 optimisticaly split all sorts of edges, including EH edges. The
3348 optimization passes in between may not have needed them; if not,
3349 we should undo the split.
3351 Recognize this case by having one EH edge incoming to the BB and
3352 one normal edge outgoing; BB should be empty apart from the
3353 post_landing_pad label.
3355 Note that this is slightly different from the empty handler case
3356 handled by cleanup_empty_eh, in that the actual handler may yet
3357 have actual code but the landing pad has been separated from the
3358 handler. As such, cleanup_empty_eh relies on this transformation
3359 having been done first. */
3362 unsplit_eh (eh_landing_pad lp)
3364 basic_block bb = label_to_block (lp->post_landing_pad);
3365 gimple_stmt_iterator gsi;
3368 /* Quickly check the edge counts on BB for singularity. */
3369 if (EDGE_COUNT (bb->preds) != 1 || EDGE_COUNT (bb->succs) != 1)
3371 e_in = EDGE_PRED (bb, 0);
3372 e_out = EDGE_SUCC (bb, 0);
3374 /* Input edge must be EH and output edge must be normal. */
3375 if ((e_in->flags & EDGE_EH) == 0 || (e_out->flags & EDGE_EH) != 0)
3378 /* The block must be empty except for the labels and debug insns. */
3379 gsi = gsi_after_labels (bb);
3380 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
3381 gsi_next_nondebug (&gsi);
3382 if (!gsi_end_p (gsi))
3385 /* The destination block must not already have a landing pad
3386 for a different region. */
3387 for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
3389 gimple stmt = gsi_stmt (gsi);
3393 if (gimple_code (stmt) != GIMPLE_LABEL)
3395 lab = gimple_label_label (stmt);
3396 lp_nr = EH_LANDING_PAD_NR (lab);
3397 if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region)
3401 /* The new destination block must not already be a destination of
3402 the source block, lest we merge fallthru and eh edges and get
3403 all sorts of confused. */
3404 if (find_edge (e_in->src, e_out->dest))
3407 /* ??? We can get degenerate phis due to cfg cleanups. I would have
3408 thought this should have been cleaned up by a phicprop pass, but
3409 that doesn't appear to handle virtuals. Propagate by hand. */
3410 if (!gimple_seq_empty_p (phi_nodes (bb)))
3412 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
3414 gimple use_stmt, phi = gsi_stmt (gsi);
3415 tree lhs = gimple_phi_result (phi);
3416 tree rhs = gimple_phi_arg_def (phi, 0);
3417 use_operand_p use_p;
3418 imm_use_iterator iter;
3420 FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
3422 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
3423 SET_USE (use_p, rhs);
3426 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
3427 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs) = 1;
3429 remove_phi_node (&gsi, true);
3433 if (dump_file && (dump_flags & TDF_DETAILS))
3434 fprintf (dump_file, "Unsplit EH landing pad %d to block %i.\n",
3435 lp->index, e_out->dest->index);
3437 /* Redirect the edge. Since redirect_eh_edge_1 expects to be moving
3438 a successor edge, humor it. But do the real CFG change with the
3439 predecessor of E_OUT in order to preserve the ordering of arguments
3440 to the PHI nodes in E_OUT->DEST. */
3441 redirect_eh_edge_1 (e_in, e_out->dest, false);
3442 redirect_edge_pred (e_out, e_in->src);
3443 e_out->flags = e_in->flags;
3444 e_out->probability = e_in->probability;
3445 e_out->count = e_in->count;
3451 /* Examine each landing pad block and see if it matches unsplit_eh. */
3454 unsplit_all_eh (void)
3456 bool changed = false;
3460 for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
3462 changed |= unsplit_eh (lp);
3467 /* A subroutine of cleanup_empty_eh. Redirect all EH edges incoming
3468 to OLD_BB to NEW_BB; return true on success, false on failure.
3470 OLD_BB_OUT is the edge into NEW_BB from OLD_BB, so if we miss any
3471 PHI variables from OLD_BB we can pick them up from OLD_BB_OUT.
3472 Virtual PHIs may be deleted and marked for renaming. */
3475 cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
3476 edge old_bb_out, bool change_region)
3478 gimple_stmt_iterator ngsi, ogsi;
3481 bitmap rename_virts;
3482 bitmap ophi_handled;
3484 FOR_EACH_EDGE (e, ei, old_bb->preds)
3485 redirect_edge_var_map_clear (e);
3487 ophi_handled = BITMAP_ALLOC (NULL);
3488 rename_virts = BITMAP_ALLOC (NULL);
3490 /* First, iterate through the PHIs on NEW_BB and set up the edge_var_map
3491 for the edges we're going to move. */
3492 for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); gsi_next (&ngsi))
3494 gimple ophi, nphi = gsi_stmt (ngsi);
3497 nresult = gimple_phi_result (nphi);
3498 nop = gimple_phi_arg_def (nphi, old_bb_out->dest_idx);
3500 /* Find the corresponding PHI in OLD_BB so we can forward-propagate
3501 the source ssa_name. */
3503 for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
3505 ophi = gsi_stmt (ogsi);
3506 if (gimple_phi_result (ophi) == nop)
3511 /* If we did find the corresponding PHI, copy those inputs. */
3514 bitmap_set_bit (ophi_handled, SSA_NAME_VERSION (nop));
3515 FOR_EACH_EDGE (e, ei, old_bb->preds)
3520 if ((e->flags & EDGE_EH) == 0)
3522 oop = gimple_phi_arg_def (ophi, e->dest_idx);
3523 oloc = gimple_phi_arg_location (ophi, e->dest_idx);
3524 redirect_edge_var_map_add (e, nresult, oop, oloc);
3527 /* If we didn't find the PHI, but it's a VOP, remember to rename
3528 it later, assuming all other tests succeed. */
3529 else if (!is_gimple_reg (nresult))
3530 bitmap_set_bit (rename_virts, SSA_NAME_VERSION (nresult));
3531 /* If we didn't find the PHI, and it's a real variable, we know
3532 from the fact that OLD_BB is tree_empty_eh_handler_p that the
3533 variable is unchanged from input to the block and we can simply
3534 re-use the input to NEW_BB from the OLD_BB_OUT edge. */
3538 = gimple_phi_arg_location (nphi, old_bb_out->dest_idx);
3539 FOR_EACH_EDGE (e, ei, old_bb->preds)
3540 redirect_edge_var_map_add (e, nresult, nop, nloc);
3544 /* Second, verify that all PHIs from OLD_BB have been handled. If not,
3545 we don't know what values from the other edges into NEW_BB to use. */
3546 for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
3548 gimple ophi = gsi_stmt (ogsi);
3549 tree oresult = gimple_phi_result (ophi);
3550 if (!bitmap_bit_p (ophi_handled, SSA_NAME_VERSION (oresult)))
3554 /* At this point we know that the merge will succeed. Remove the PHI
3555 nodes for the virtuals that we want to rename. */
3556 if (!bitmap_empty_p (rename_virts))
3558 for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); )
3560 gimple nphi = gsi_stmt (ngsi);
3561 tree nresult = gimple_phi_result (nphi);
3562 if (bitmap_bit_p (rename_virts, SSA_NAME_VERSION (nresult)))
3564 mark_virtual_phi_result_for_renaming (nphi);
3565 remove_phi_node (&ngsi, true);
3572 /* Finally, move the edges and update the PHIs. */
3573 for (ei = ei_start (old_bb->preds); (e = ei_safe_edge (ei)); )
3574 if (e->flags & EDGE_EH)
3576 redirect_eh_edge_1 (e, new_bb, change_region);
3577 redirect_edge_succ (e, new_bb);
3578 flush_pending_stmts (e);
3583 BITMAP_FREE (ophi_handled);
3584 BITMAP_FREE (rename_virts);
3588 FOR_EACH_EDGE (e, ei, old_bb->preds)
3589 redirect_edge_var_map_clear (e);
3590 BITMAP_FREE (ophi_handled);
3591 BITMAP_FREE (rename_virts);
3595 /* A subroutine of cleanup_empty_eh. Move a landing pad LP from its
3596 old region to NEW_REGION at BB. */
3599 cleanup_empty_eh_move_lp (basic_block bb, edge e_out,
3600 eh_landing_pad lp, eh_region new_region)
3602 gimple_stmt_iterator gsi;
3605 for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp)
3609 lp->region = new_region;
3610 lp->next_lp = new_region->landing_pads;
3611 new_region->landing_pads = lp;
3613 /* Delete the RESX that was matched within the empty handler block. */
3614 gsi = gsi_last_bb (bb);
3615 mark_virtual_ops_for_renaming (gsi_stmt (gsi));
3616 gsi_remove (&gsi, true);
3618 /* Clean up E_OUT for the fallthru. */
3619 e_out->flags = (e_out->flags & ~EDGE_EH) | EDGE_FALLTHRU;
3620 e_out->probability = REG_BR_PROB_BASE;
3623 /* A subroutine of cleanup_empty_eh. Handle more complex cases of
3624 unsplitting than unsplit_eh was prepared to handle, e.g. when
3625 multiple incoming edges and phis are involved. */
3628 cleanup_empty_eh_unsplit (basic_block bb, edge e_out, eh_landing_pad lp)
3630 gimple_stmt_iterator gsi;
3633 /* We really ought not have totally lost everything following
3634 a landing pad label. Given that BB is empty, there had better
3636 gcc_assert (e_out != NULL);
3638 /* The destination block must not already have a landing pad
3639 for a different region. */
3641 for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
3643 gimple stmt = gsi_stmt (gsi);
3646 if (gimple_code (stmt) != GIMPLE_LABEL)
3648 lab = gimple_label_label (stmt);
3649 lp_nr = EH_LANDING_PAD_NR (lab);
3650 if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region)
3654 /* Attempt to move the PHIs into the successor block. */
3655 if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, false))
3657 if (dump_file && (dump_flags & TDF_DETAILS))
3659 "Unsplit EH landing pad %d to block %i "
3660 "(via cleanup_empty_eh).\n",
3661 lp->index, e_out->dest->index);
3668 /* Examine the block associated with LP to determine if it's an empty
3669 handler for its EH region. If so, attempt to redirect EH edges to
3670 an outer region. Return true the CFG was updated in any way. This
3671 is similar to jump forwarding, just across EH edges. */
3674 cleanup_empty_eh (eh_landing_pad lp)
3676 basic_block bb = label_to_block (lp->post_landing_pad);
3677 gimple_stmt_iterator gsi;
3679 eh_region new_region;
3682 bool has_non_eh_pred;
3685 /* There can be zero or one edges out of BB. This is the quickest test. */
3686 switch (EDGE_COUNT (bb->succs))
3692 e_out = EDGE_SUCC (bb, 0);
3697 gsi = gsi_after_labels (bb);
3699 /* Make sure to skip debug statements. */
3700 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
3701 gsi_next_nondebug (&gsi);
3703 /* If the block is totally empty, look for more unsplitting cases. */
3704 if (gsi_end_p (gsi))
3705 return cleanup_empty_eh_unsplit (bb, e_out, lp);
3707 /* The block should consist only of a single RESX statement. */
3708 resx = gsi_stmt (gsi);
3709 if (!is_gimple_resx (resx))
3711 gcc_assert (gsi_one_before_end_p (gsi));
3713 /* Determine if there are non-EH edges, or resx edges into the handler. */
3714 has_non_eh_pred = false;
3715 FOR_EACH_EDGE (e, ei, bb->preds)
3716 if (!(e->flags & EDGE_EH))
3717 has_non_eh_pred = true;
3719 /* Find the handler that's outer of the empty handler by looking at
3720 where the RESX instruction was vectored. */
3721 new_lp_nr = lookup_stmt_eh_lp (resx);
3722 new_region = get_eh_region_from_lp_number (new_lp_nr);
3724 /* If there's no destination region within the current function,
3725 redirection is trivial via removing the throwing statements from
3726 the EH region, removing the EH edges, and allowing the block
3727 to go unreachable. */
3728 if (new_region == NULL)
3730 gcc_assert (e_out == NULL);
3731 for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
3732 if (e->flags & EDGE_EH)
3734 gimple stmt = last_stmt (e->src);
3735 remove_stmt_from_eh_lp (stmt);
3743 /* If the destination region is a MUST_NOT_THROW, allow the runtime
3744 to handle the abort and allow the blocks to go unreachable. */
3745 if (new_region->type == ERT_MUST_NOT_THROW)
3747 for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
3748 if (e->flags & EDGE_EH)
3750 gimple stmt = last_stmt (e->src);
3751 remove_stmt_from_eh_lp (stmt);
3752 add_stmt_to_eh_lp (stmt, new_lp_nr);
3760 /* Try to redirect the EH edges and merge the PHIs into the destination
3761 landing pad block. If the merge succeeds, we'll already have redirected
3762 all the EH edges. The handler itself will go unreachable if there were
3764 if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, true))
3767 /* Finally, if all input edges are EH edges, then we can (potentially)
3768 reduce the number of transfers from the runtime by moving the landing
3769 pad from the original region to the new region. This is a win when
3770 we remove the last CLEANUP region along a particular exception
3771 propagation path. Since nothing changes except for the region with
3772 which the landing pad is associated, the PHI nodes do not need to be
3774 if (!has_non_eh_pred)
3776 cleanup_empty_eh_move_lp (bb, e_out, lp, new_region);
3777 if (dump_file && (dump_flags & TDF_DETAILS))
3778 fprintf (dump_file, "Empty EH handler %i moved to EH region %i.\n",
3779 lp->index, new_region->index);
3781 /* ??? The CFG didn't change, but we may have rendered the
3782 old EH region unreachable. Trigger a cleanup there. */
3789 if (dump_file && (dump_flags & TDF_DETAILS))
3790 fprintf (dump_file, "Empty EH handler %i removed.\n", lp->index);
3791 remove_eh_landing_pad (lp);
3795 /* Do a post-order traversal of the EH region tree. Examine each
3796 post_landing_pad block and see if we can eliminate it as empty. */
3799 cleanup_all_empty_eh (void)
3801 bool changed = false;
3805 for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i)
3807 changed |= cleanup_empty_eh (lp);
3812 /* Perform cleanups and lowering of exception handling
3813 1) cleanups regions with handlers doing nothing are optimized out
3814 2) MUST_NOT_THROW regions that became dead because of 1) are optimized out
3815 3) Info about regions that are containing instructions, and regions
3816 reachable via local EH edges is collected
3817 4) Eh tree is pruned for regions no longer neccesary.
3819 TODO: Push MUST_NOT_THROW regions to the root of the EH tree.
3820 Unify those that have the same failure decl and locus.
3824 execute_cleanup_eh (void)
3826 /* Do this first: unsplit_all_eh and cleanup_all_empty_eh can die
3827 looking up unreachable landing pads. */
3828 remove_unreachable_handlers ();
3830 /* Watch out for the region tree vanishing due to all unreachable. */
3831 if (cfun->eh->region_tree && optimize)
3833 bool changed = false;
3835 changed |= unsplit_all_eh ();
3836 changed |= cleanup_all_empty_eh ();
3840 free_dominance_info (CDI_DOMINATORS);
3841 free_dominance_info (CDI_POST_DOMINATORS);
3843 /* We delayed all basic block deletion, as we may have performed
3844 cleanups on EH edges while non-EH edges were still present. */
3845 delete_unreachable_blocks ();
3847 /* We manipulated the landing pads. Remove any region that no
3848 longer has a landing pad. */
3849 remove_unreachable_handlers_no_lp ();
3851 return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals;
3859 gate_cleanup_eh (void)
3861 return cfun->eh != NULL && cfun->eh->region_tree != NULL;
3864 struct gimple_opt_pass pass_cleanup_eh = {
3867 "ehcleanup", /* name */
3868 gate_cleanup_eh, /* gate */
3869 execute_cleanup_eh, /* execute */
3872 0, /* static_pass_number */
3873 TV_TREE_EH, /* tv_id */
3874 PROP_gimple_lcf, /* properties_required */
3875 0, /* properties_provided */
3876 0, /* properties_destroyed */
3877 0, /* todo_flags_start */
3878 TODO_dump_func /* todo_flags_finish */
3882 /* Verify that BB containing STMT as the last statement, has precisely the
3883 edge that make_eh_edges would create. */
3886 verify_eh_edges (gimple stmt)
3888 basic_block bb = gimple_bb (stmt);
3889 eh_landing_pad lp = NULL;
3894 lp_nr = lookup_stmt_eh_lp (stmt);
3896 lp = get_eh_landing_pad_from_number (lp_nr);
3899 FOR_EACH_EDGE (e, ei, bb->succs)
3901 if (e->flags & EDGE_EH)
3905 error ("BB %i has multiple EH edges", bb->index);
3917 error ("BB %i can not throw but has an EH edge", bb->index);
3923 if (!stmt_could_throw_p (stmt))
3925 error ("BB %i last statement has incorrectly set lp", bb->index);
3929 if (eh_edge == NULL)
3931 error ("BB %i is missing an EH edge", bb->index);
3935 if (eh_edge->dest != label_to_block (lp->post_landing_pad))
3937 error ("Incorrect EH edge %i->%i", bb->index, eh_edge->dest->index);
3944 /* Similarly, but handle GIMPLE_EH_DISPATCH specifically. */
3947 verify_eh_dispatch_edge (gimple stmt)
3951 basic_block src, dst;
3952 bool want_fallthru = true;
3956 r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt));
3957 src = gimple_bb (stmt);
3959 FOR_EACH_EDGE (e, ei, src->succs)
3960 gcc_assert (e->aux == NULL);
3965 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
3967 dst = label_to_block (c->label);
3968 e = find_edge (src, dst);
3971 error ("BB %i is missing an edge", src->index);
3976 /* A catch-all handler doesn't have a fallthru. */
3977 if (c->type_list == NULL)
3979 want_fallthru = false;
3985 case ERT_ALLOWED_EXCEPTIONS:
3986 dst = label_to_block (r->u.allowed.label);
3987 e = find_edge (src, dst);
3990 error ("BB %i is missing an edge", src->index);
4001 FOR_EACH_EDGE (e, ei, src->succs)
4003 if (e->flags & EDGE_FALLTHRU)
4005 if (fall_edge != NULL)
4007 error ("BB %i too many fallthru edges", src->index);
4016 error ("BB %i has incorrect edge", src->index);
4020 if ((fall_edge != NULL) ^ want_fallthru)
4022 error ("BB %i has incorrect fallthru edge", src->index);