1 /* Exception handling semantics and decomposition for trees.
2 Copyright (C) 2003-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
23 #include "hash-table.h"
32 #include "basic-block.h"
33 #include "tree-ssa-alias.h"
34 #include "internal-fn.h"
36 #include "gimple-expr.h"
39 #include "gimple-iterator.h"
40 #include "gimple-ssa.h"
43 #include "tree-phinodes.h"
44 #include "ssa-iterators.h"
45 #include "stringpool.h"
46 #include "tree-ssanames.h"
47 #include "tree-into-ssa.h"
49 #include "tree-inline.h"
50 #include "tree-pass.h"
51 #include "langhooks.h"
52 #include "diagnostic-core.h"
55 #include "gimple-low.h"
57 /* In some instances a tree and a gimple need to be stored in a same table,
58 i.e. in hash tables. This is a structure to do this. */
59 typedef union {tree
*tp
; tree t
; gimple g
;} treemple
;
61 /* Misc functions used in this file. */
63 /* Remember and lookup EH landing pad data for arbitrary statements.
64 Really this means any statement that could_throw_p. We could
65 stuff this information into the stmt_ann data structure, but:
67 (1) We absolutely rely on this information being kept until
68 we get to rtl. Once we're done with lowering here, if we lose
69 the information there's no way to recover it!
71 (2) There are many more statements that *cannot* throw as
72 compared to those that can. We should be saving some amount
73 of space by only allocating memory for those that can throw. */
75 /* Add statement T in function IFUN to landing pad NUM. */
78 add_stmt_to_eh_lp_fn (struct function
*ifun
, gimple t
, int num
)
80 gcc_assert (num
!= 0);
82 if (!get_eh_throw_stmt_table (ifun
))
83 set_eh_throw_stmt_table (ifun
, hash_map
<gimple
, int>::create_ggc (31));
85 gcc_assert (!get_eh_throw_stmt_table (ifun
)->put (t
, num
));
88 /* Add statement T in the current function (cfun) to EH landing pad NUM. */
91 add_stmt_to_eh_lp (gimple t
, int num
)
93 add_stmt_to_eh_lp_fn (cfun
, t
, num
);
96 /* Add statement T to the single EH landing pad in REGION. */
99 record_stmt_eh_region (eh_region region
, gimple t
)
103 if (region
->type
== ERT_MUST_NOT_THROW
)
104 add_stmt_to_eh_lp_fn (cfun
, t
, -region
->index
);
107 eh_landing_pad lp
= region
->landing_pads
;
109 lp
= gen_eh_landing_pad (region
);
111 gcc_assert (lp
->next_lp
== NULL
);
112 add_stmt_to_eh_lp_fn (cfun
, t
, lp
->index
);
117 /* Remove statement T in function IFUN from its EH landing pad. */
120 remove_stmt_from_eh_lp_fn (struct function
*ifun
, gimple t
)
122 if (!get_eh_throw_stmt_table (ifun
))
125 if (!get_eh_throw_stmt_table (ifun
)->get (t
))
128 get_eh_throw_stmt_table (ifun
)->remove (t
);
133 /* Remove statement T in the current function (cfun) from its
137 remove_stmt_from_eh_lp (gimple t
)
139 return remove_stmt_from_eh_lp_fn (cfun
, t
);
142 /* Determine if statement T is inside an EH region in function IFUN.
143 Positive numbers indicate a landing pad index; negative numbers
144 indicate a MUST_NOT_THROW region index; zero indicates that the
145 statement is not recorded in the region table. */
148 lookup_stmt_eh_lp_fn (struct function
*ifun
, gimple t
)
150 if (ifun
->eh
->throw_stmt_table
== NULL
)
153 int *lp_nr
= ifun
->eh
->throw_stmt_table
->get (t
);
154 return lp_nr
? *lp_nr
: 0;
157 /* Likewise, but always use the current function. */
160 lookup_stmt_eh_lp (gimple t
)
162 /* We can get called from initialized data when -fnon-call-exceptions
163 is on; prevent crash. */
166 return lookup_stmt_eh_lp_fn (cfun
, t
);
169 /* First pass of EH node decomposition. Build up a tree of GIMPLE_TRY_FINALLY
170 nodes and LABEL_DECL nodes. We will use this during the second phase to
171 determine if a goto leaves the body of a TRY_FINALLY_EXPR node. */
173 struct finally_tree_node
175 /* When storing a GIMPLE_TRY, we have to record a gimple. However
176 when deciding whether a GOTO to a certain LABEL_DECL (which is a
177 tree) leaves the TRY block, its necessary to record a tree in
178 this field. Thus a treemple is used. */
183 /* Hashtable helpers. */
185 struct finally_tree_hasher
: typed_free_remove
<finally_tree_node
>
187 typedef finally_tree_node value_type
;
188 typedef finally_tree_node compare_type
;
189 static inline hashval_t
hash (const value_type
*);
190 static inline bool equal (const value_type
*, const compare_type
*);
194 finally_tree_hasher::hash (const value_type
*v
)
196 return (intptr_t)v
->child
.t
>> 4;
200 finally_tree_hasher::equal (const value_type
*v
, const compare_type
*c
)
202 return v
->child
.t
== c
->child
.t
;
205 /* Note that this table is *not* marked GTY. It is short-lived. */
206 static hash_table
<finally_tree_hasher
> *finally_tree
;
209 record_in_finally_tree (treemple child
, gimple_try parent
)
211 struct finally_tree_node
*n
;
212 finally_tree_node
**slot
;
214 n
= XNEW (struct finally_tree_node
);
218 slot
= finally_tree
->find_slot (n
, INSERT
);
224 collect_finally_tree (gimple stmt
, gimple_try region
);
226 /* Go through the gimple sequence. Works with collect_finally_tree to
227 record all GIMPLE_LABEL and GIMPLE_TRY statements. */
230 collect_finally_tree_1 (gimple_seq seq
, gimple_try region
)
232 gimple_stmt_iterator gsi
;
234 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
235 collect_finally_tree (gsi_stmt (gsi
), region
);
239 collect_finally_tree (gimple stmt
, gimple_try region
)
243 switch (gimple_code (stmt
))
246 temp
.t
= gimple_label_label (as_a
<gimple_label
> (stmt
));
247 record_in_finally_tree (temp
, region
);
251 if (gimple_try_kind (stmt
) == GIMPLE_TRY_FINALLY
)
254 record_in_finally_tree (temp
, region
);
255 collect_finally_tree_1 (gimple_try_eval (stmt
),
256 as_a
<gimple_try
> (stmt
));
257 collect_finally_tree_1 (gimple_try_cleanup (stmt
), region
);
259 else if (gimple_try_kind (stmt
) == GIMPLE_TRY_CATCH
)
261 collect_finally_tree_1 (gimple_try_eval (stmt
), region
);
262 collect_finally_tree_1 (gimple_try_cleanup (stmt
), region
);
267 collect_finally_tree_1 (gimple_catch_handler (
268 as_a
<gimple_catch
> (stmt
)),
272 case GIMPLE_EH_FILTER
:
273 collect_finally_tree_1 (gimple_eh_filter_failure (stmt
), region
);
278 gimple_eh_else eh_else_stmt
= as_a
<gimple_eh_else
> (stmt
);
279 collect_finally_tree_1 (gimple_eh_else_n_body (eh_else_stmt
), region
);
280 collect_finally_tree_1 (gimple_eh_else_e_body (eh_else_stmt
), region
);
285 /* A type, a decl, or some kind of statement that we're not
286 interested in. Don't walk them. */
292 /* Use the finally tree to determine if a jump from START to TARGET
293 would leave the try_finally node that START lives in. */
296 outside_finally_tree (treemple start
, gimple target
)
298 struct finally_tree_node n
, *p
;
303 p
= finally_tree
->find (&n
);
308 while (start
.g
!= target
);
313 /* Second pass of EH node decomposition. Actually transform the GIMPLE_TRY
314 nodes into a set of gotos, magic labels, and eh regions.
315 The eh region creation is straight-forward, but frobbing all the gotos
316 and such into shape isn't. */
318 /* The sequence into which we record all EH stuff. This will be
319 placed at the end of the function when we're all done. */
320 static gimple_seq eh_seq
;
322 /* Record whether an EH region contains something that can throw,
323 indexed by EH region number. */
324 static bitmap eh_region_may_contain_throw_map
;
326 /* The GOTO_QUEUE is is an array of GIMPLE_GOTO and GIMPLE_RETURN
327 statements that are seen to escape this GIMPLE_TRY_FINALLY node.
328 The idea is to record a gimple statement for everything except for
329 the conditionals, which get their labels recorded. Since labels are
330 of type 'tree', we need this node to store both gimple and tree
331 objects. REPL_STMT is the sequence used to replace the goto/return
332 statement. CONT_STMT is used to store the statement that allows
333 the return/goto to jump to the original destination. */
335 struct goto_queue_node
339 gimple_seq repl_stmt
;
342 /* This is used when index >= 0 to indicate that stmt is a label (as
343 opposed to a goto stmt). */
347 /* State of the world while lowering. */
351 /* What's "current" while constructing the eh region tree. These
352 correspond to variables of the same name in cfun->eh, which we
353 don't have easy access to. */
354 eh_region cur_region
;
356 /* What's "current" for the purposes of __builtin_eh_pointer. For
357 a CATCH, this is the associated TRY. For an EH_FILTER, this is
358 the associated ALLOWED_EXCEPTIONS, etc. */
359 eh_region ehp_region
;
361 /* Processing of TRY_FINALLY requires a bit more state. This is
362 split out into a separate structure so that we don't have to
363 copy so much when processing other nodes. */
364 struct leh_tf_state
*tf
;
369 /* Pointer to the GIMPLE_TRY_FINALLY node under discussion. The
370 try_finally_expr is the original GIMPLE_TRY_FINALLY. We need to retain
371 this so that outside_finally_tree can reliably reference the tree used
372 in the collect_finally_tree data structures. */
373 gimple_try try_finally_expr
;
376 /* While lowering a top_p usually it is expanded into multiple statements,
377 thus we need the following field to store them. */
378 gimple_seq top_p_seq
;
380 /* The state outside this try_finally node. */
381 struct leh_state
*outer
;
383 /* The exception region created for it. */
386 /* The goto queue. */
387 struct goto_queue_node
*goto_queue
;
388 size_t goto_queue_size
;
389 size_t goto_queue_active
;
391 /* Pointer map to help in searching goto_queue when it is large. */
392 hash_map
<gimple
, goto_queue_node
*> *goto_queue_map
;
394 /* The set of unique labels seen as entries in the goto queue. */
395 vec
<tree
> dest_array
;
397 /* A label to be added at the end of the completed transformed
398 sequence. It will be set if may_fallthru was true *at one time*,
399 though subsequent transformations may have cleared that flag. */
402 /* True if it is possible to fall out the bottom of the try block.
403 Cleared if the fallthru is converted to a goto. */
406 /* True if any entry in goto_queue is a GIMPLE_RETURN. */
409 /* True if the finally block can receive an exception edge.
410 Cleared if the exception case is handled by code duplication. */
414 static gimple_seq
lower_eh_must_not_throw (struct leh_state
*, gimple_try
);
416 /* Search for STMT in the goto queue. Return the replacement,
417 or null if the statement isn't in the queue. */
419 #define LARGE_GOTO_QUEUE 20
421 static void lower_eh_constructs_1 (struct leh_state
*state
, gimple_seq
*seq
);
424 find_goto_replacement (struct leh_tf_state
*tf
, treemple stmt
)
428 if (tf
->goto_queue_active
< LARGE_GOTO_QUEUE
)
430 for (i
= 0; i
< tf
->goto_queue_active
; i
++)
431 if ( tf
->goto_queue
[i
].stmt
.g
== stmt
.g
)
432 return tf
->goto_queue
[i
].repl_stmt
;
436 /* If we have a large number of entries in the goto_queue, create a
437 pointer map and use that for searching. */
439 if (!tf
->goto_queue_map
)
441 tf
->goto_queue_map
= new hash_map
<gimple
, goto_queue_node
*>;
442 for (i
= 0; i
< tf
->goto_queue_active
; i
++)
444 bool existed
= tf
->goto_queue_map
->put (tf
->goto_queue
[i
].stmt
.g
,
446 gcc_assert (!existed
);
450 goto_queue_node
**slot
= tf
->goto_queue_map
->get (stmt
.g
);
452 return ((*slot
)->repl_stmt
);
457 /* A subroutine of replace_goto_queue_1. Handles the sub-clauses of a
458 lowered GIMPLE_COND. If, by chance, the replacement is a simple goto,
459 then we can just splat it in, otherwise we add the new stmts immediately
460 after the GIMPLE_COND and redirect. */
463 replace_goto_queue_cond_clause (tree
*tp
, struct leh_tf_state
*tf
,
464 gimple_stmt_iterator
*gsi
)
469 location_t loc
= gimple_location (gsi_stmt (*gsi
));
472 new_seq
= find_goto_replacement (tf
, temp
);
476 if (gimple_seq_singleton_p (new_seq
)
477 && gimple_code (gimple_seq_first_stmt (new_seq
)) == GIMPLE_GOTO
)
479 *tp
= gimple_goto_dest (gimple_seq_first_stmt (new_seq
));
483 label
= create_artificial_label (loc
);
484 /* Set the new label for the GIMPLE_COND */
487 gsi_insert_after (gsi
, gimple_build_label (label
), GSI_CONTINUE_LINKING
);
488 gsi_insert_seq_after (gsi
, gimple_seq_copy (new_seq
), GSI_CONTINUE_LINKING
);
491 /* The real work of replace_goto_queue. Returns with TSI updated to
492 point to the next statement. */
494 static void replace_goto_queue_stmt_list (gimple_seq
*, struct leh_tf_state
*);
497 replace_goto_queue_1 (gimple stmt
, struct leh_tf_state
*tf
,
498 gimple_stmt_iterator
*gsi
)
504 switch (gimple_code (stmt
))
509 seq
= find_goto_replacement (tf
, temp
);
512 gsi_insert_seq_before (gsi
, gimple_seq_copy (seq
), GSI_SAME_STMT
);
513 gsi_remove (gsi
, false);
519 replace_goto_queue_cond_clause (gimple_op_ptr (stmt
, 2), tf
, gsi
);
520 replace_goto_queue_cond_clause (gimple_op_ptr (stmt
, 3), tf
, gsi
);
524 replace_goto_queue_stmt_list (gimple_try_eval_ptr (stmt
), tf
);
525 replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (stmt
), tf
);
528 replace_goto_queue_stmt_list (gimple_catch_handler_ptr (
529 as_a
<gimple_catch
> (stmt
)),
532 case GIMPLE_EH_FILTER
:
533 replace_goto_queue_stmt_list (gimple_eh_filter_failure_ptr (stmt
), tf
);
537 gimple_eh_else eh_else_stmt
= as_a
<gimple_eh_else
> (stmt
);
538 replace_goto_queue_stmt_list (gimple_eh_else_n_body_ptr (eh_else_stmt
),
540 replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (eh_else_stmt
),
546 /* These won't have gotos in them. */
553 /* A subroutine of replace_goto_queue. Handles GIMPLE_SEQ. */
556 replace_goto_queue_stmt_list (gimple_seq
*seq
, struct leh_tf_state
*tf
)
558 gimple_stmt_iterator gsi
= gsi_start (*seq
);
560 while (!gsi_end_p (gsi
))
561 replace_goto_queue_1 (gsi_stmt (gsi
), tf
, &gsi
);
564 /* Replace all goto queue members. */
567 replace_goto_queue (struct leh_tf_state
*tf
)
569 if (tf
->goto_queue_active
== 0)
571 replace_goto_queue_stmt_list (&tf
->top_p_seq
, tf
);
572 replace_goto_queue_stmt_list (&eh_seq
, tf
);
575 /* Add a new record to the goto queue contained in TF. NEW_STMT is the
576 data to be added, IS_LABEL indicates whether NEW_STMT is a label or
580 record_in_goto_queue (struct leh_tf_state
*tf
,
587 struct goto_queue_node
*q
;
589 gcc_assert (!tf
->goto_queue_map
);
591 active
= tf
->goto_queue_active
;
592 size
= tf
->goto_queue_size
;
595 size
= (size
? size
* 2 : 32);
596 tf
->goto_queue_size
= size
;
598 = XRESIZEVEC (struct goto_queue_node
, tf
->goto_queue
, size
);
601 q
= &tf
->goto_queue
[active
];
602 tf
->goto_queue_active
= active
+ 1;
604 memset (q
, 0, sizeof (*q
));
607 q
->location
= location
;
608 q
->is_label
= is_label
;
611 /* Record the LABEL label in the goto queue contained in TF.
615 record_in_goto_queue_label (struct leh_tf_state
*tf
, treemple stmt
, tree label
,
619 treemple temp
, new_stmt
;
624 /* Computed and non-local gotos do not get processed. Given
625 their nature we can neither tell whether we've escaped the
626 finally block nor redirect them if we knew. */
627 if (TREE_CODE (label
) != LABEL_DECL
)
630 /* No need to record gotos that don't leave the try block. */
632 if (!outside_finally_tree (temp
, tf
->try_finally_expr
))
635 if (! tf
->dest_array
.exists ())
637 tf
->dest_array
.create (10);
638 tf
->dest_array
.quick_push (label
);
643 int n
= tf
->dest_array
.length ();
644 for (index
= 0; index
< n
; ++index
)
645 if (tf
->dest_array
[index
] == label
)
648 tf
->dest_array
.safe_push (label
);
651 /* In the case of a GOTO we want to record the destination label,
652 since with a GIMPLE_COND we have an easy access to the then/else
655 record_in_goto_queue (tf
, new_stmt
, index
, true, location
);
658 /* For any GIMPLE_GOTO or GIMPLE_RETURN, decide whether it leaves a try_finally
659 node, and if so record that fact in the goto queue associated with that
663 maybe_record_in_goto_queue (struct leh_state
*state
, gimple stmt
)
665 struct leh_tf_state
*tf
= state
->tf
;
671 switch (gimple_code (stmt
))
675 gimple_cond cond_stmt
= as_a
<gimple_cond
> (stmt
);
676 new_stmt
.tp
= gimple_op_ptr (cond_stmt
, 2);
677 record_in_goto_queue_label (tf
, new_stmt
,
678 gimple_cond_true_label (cond_stmt
),
679 EXPR_LOCATION (*new_stmt
.tp
));
680 new_stmt
.tp
= gimple_op_ptr (cond_stmt
, 3);
681 record_in_goto_queue_label (tf
, new_stmt
,
682 gimple_cond_false_label (cond_stmt
),
683 EXPR_LOCATION (*new_stmt
.tp
));
688 record_in_goto_queue_label (tf
, new_stmt
, gimple_goto_dest (stmt
),
689 gimple_location (stmt
));
693 tf
->may_return
= true;
695 record_in_goto_queue (tf
, new_stmt
, -1, false, gimple_location (stmt
));
704 #ifdef ENABLE_CHECKING
705 /* We do not process GIMPLE_SWITCHes for now. As long as the original source
706 was in fact structured, and we've not yet done jump threading, then none
707 of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */
710 verify_norecord_switch_expr (struct leh_state
*state
,
711 gimple_switch switch_expr
)
713 struct leh_tf_state
*tf
= state
->tf
;
719 n
= gimple_switch_num_labels (switch_expr
);
721 for (i
= 0; i
< n
; ++i
)
724 tree lab
= CASE_LABEL (gimple_switch_label (switch_expr
, i
));
726 gcc_assert (!outside_finally_tree (temp
, tf
->try_finally_expr
));
730 #define verify_norecord_switch_expr(state, switch_expr)
733 /* Redirect a RETURN_EXPR pointed to by Q to FINLAB. If MOD is
734 non-null, insert it before the new branch. */
737 do_return_redirection (struct goto_queue_node
*q
, tree finlab
, gimple_seq mod
)
741 /* In the case of a return, the queue node must be a gimple statement. */
742 gcc_assert (!q
->is_label
);
744 /* Note that the return value may have already been computed, e.g.,
757 should return 0, not 1. We don't have to do anything to make
758 this happens because the return value has been placed in the
759 RESULT_DECL already. */
761 q
->cont_stmt
= q
->stmt
.g
;
764 gimple_seq_add_seq (&q
->repl_stmt
, mod
);
766 x
= gimple_build_goto (finlab
);
767 gimple_set_location (x
, q
->location
);
768 gimple_seq_add_stmt (&q
->repl_stmt
, x
);
771 /* Similar, but easier, for GIMPLE_GOTO. */
774 do_goto_redirection (struct goto_queue_node
*q
, tree finlab
, gimple_seq mod
,
775 struct leh_tf_state
*tf
)
779 gcc_assert (q
->is_label
);
781 q
->cont_stmt
= gimple_build_goto (tf
->dest_array
[q
->index
]);
784 gimple_seq_add_seq (&q
->repl_stmt
, mod
);
786 x
= gimple_build_goto (finlab
);
787 gimple_set_location (x
, q
->location
);
788 gimple_seq_add_stmt (&q
->repl_stmt
, x
);
791 /* Emit a standard landing pad sequence into SEQ for REGION. */
794 emit_post_landing_pad (gimple_seq
*seq
, eh_region region
)
796 eh_landing_pad lp
= region
->landing_pads
;
800 lp
= gen_eh_landing_pad (region
);
802 lp
->post_landing_pad
= create_artificial_label (UNKNOWN_LOCATION
);
803 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = lp
->index
;
805 x
= gimple_build_label (lp
->post_landing_pad
);
806 gimple_seq_add_stmt (seq
, x
);
809 /* Emit a RESX statement into SEQ for REGION. */
812 emit_resx (gimple_seq
*seq
, eh_region region
)
814 gimple_resx x
= gimple_build_resx (region
->index
);
815 gimple_seq_add_stmt (seq
, x
);
817 record_stmt_eh_region (region
->outer
, x
);
820 /* Emit an EH_DISPATCH statement into SEQ for REGION. */
823 emit_eh_dispatch (gimple_seq
*seq
, eh_region region
)
825 gimple_eh_dispatch x
= gimple_build_eh_dispatch (region
->index
);
826 gimple_seq_add_stmt (seq
, x
);
829 /* Note that the current EH region may contain a throw, or a
830 call to a function which itself may contain a throw. */
833 note_eh_region_may_contain_throw (eh_region region
)
835 while (bitmap_set_bit (eh_region_may_contain_throw_map
, region
->index
))
837 if (region
->type
== ERT_MUST_NOT_THROW
)
839 region
= region
->outer
;
845 /* Check if REGION has been marked as containing a throw. If REGION is
846 NULL, this predicate is false. */
849 eh_region_may_contain_throw (eh_region r
)
851 return r
&& bitmap_bit_p (eh_region_may_contain_throw_map
, r
->index
);
854 /* We want to transform
855 try { body; } catch { stuff; }
865 TP is a GIMPLE_TRY node. REGION is the region whose post_landing_pad
866 should be placed before the second operand, or NULL. OVER is
867 an existing label that should be put at the exit, or NULL. */
870 frob_into_branch_around (gimple_try tp
, eh_region region
, tree over
)
873 gimple_seq cleanup
, result
;
874 location_t loc
= gimple_location (tp
);
876 cleanup
= gimple_try_cleanup (tp
);
877 result
= gimple_try_eval (tp
);
880 emit_post_landing_pad (&eh_seq
, region
);
882 if (gimple_seq_may_fallthru (cleanup
))
885 over
= create_artificial_label (loc
);
886 x
= gimple_build_goto (over
);
887 gimple_set_location (x
, loc
);
888 gimple_seq_add_stmt (&cleanup
, x
);
890 gimple_seq_add_seq (&eh_seq
, cleanup
);
894 x
= gimple_build_label (over
);
895 gimple_seq_add_stmt (&result
, x
);
900 /* A subroutine of lower_try_finally. Duplicate the tree rooted at T.
901 Make sure to record all new labels found. */
904 lower_try_finally_dup_block (gimple_seq seq
, struct leh_state
*outer_state
,
907 gimple_try region
= NULL
;
909 gimple_stmt_iterator gsi
;
911 new_seq
= copy_gimple_seq_and_replace_locals (seq
);
913 for (gsi
= gsi_start (new_seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
915 gimple stmt
= gsi_stmt (gsi
);
916 if (LOCATION_LOCUS (gimple_location (stmt
)) == UNKNOWN_LOCATION
)
918 tree block
= gimple_block (stmt
);
919 gimple_set_location (stmt
, loc
);
920 gimple_set_block (stmt
, block
);
925 region
= outer_state
->tf
->try_finally_expr
;
926 collect_finally_tree_1 (new_seq
, region
);
931 /* A subroutine of lower_try_finally. Create a fallthru label for
932 the given try_finally state. The only tricky bit here is that
933 we have to make sure to record the label in our outer context. */
936 lower_try_finally_fallthru_label (struct leh_tf_state
*tf
)
938 tree label
= tf
->fallthru_label
;
943 label
= create_artificial_label (gimple_location (tf
->try_finally_expr
));
944 tf
->fallthru_label
= label
;
948 record_in_finally_tree (temp
, tf
->outer
->tf
->try_finally_expr
);
954 /* A subroutine of lower_try_finally. If FINALLY consits of a
955 GIMPLE_EH_ELSE node, return it. */
957 static inline gimple_eh_else
958 get_eh_else (gimple_seq finally
)
960 gimple x
= gimple_seq_first_stmt (finally
);
961 if (gimple_code (x
) == GIMPLE_EH_ELSE
)
963 gcc_assert (gimple_seq_singleton_p (finally
));
964 return as_a
<gimple_eh_else
> (x
);
969 /* A subroutine of lower_try_finally. If the eh_protect_cleanup_actions
970 langhook returns non-null, then the language requires that the exception
971 path out of a try_finally be treated specially. To wit: the code within
972 the finally block may not itself throw an exception. We have two choices
973 here. First we can duplicate the finally block and wrap it in a
974 must_not_throw region. Second, we can generate code like
979 if (fintmp == eh_edge)
980 protect_cleanup_actions;
983 where "fintmp" is the temporary used in the switch statement generation
984 alternative considered below. For the nonce, we always choose the first
987 THIS_STATE may be null if this is a try-cleanup, not a try-finally. */
990 honor_protect_cleanup_actions (struct leh_state
*outer_state
,
991 struct leh_state
*this_state
,
992 struct leh_tf_state
*tf
)
994 tree protect_cleanup_actions
;
995 gimple_stmt_iterator gsi
;
996 bool finally_may_fallthru
;
999 gimple_eh_must_not_throw eh_mnt
;
1000 gimple_try try_stmt
;
1001 gimple_eh_else eh_else
;
1003 /* First check for nothing to do. */
1004 if (lang_hooks
.eh_protect_cleanup_actions
== NULL
)
1006 protect_cleanup_actions
= lang_hooks
.eh_protect_cleanup_actions ();
1007 if (protect_cleanup_actions
== NULL
)
1010 finally
= gimple_try_cleanup (tf
->top_p
);
1011 eh_else
= get_eh_else (finally
);
1013 /* Duplicate the FINALLY block. Only need to do this for try-finally,
1014 and not for cleanups. If we've got an EH_ELSE, extract it now. */
1017 finally
= gimple_eh_else_e_body (eh_else
);
1018 gimple_try_set_cleanup (tf
->top_p
, gimple_eh_else_n_body (eh_else
));
1020 else if (this_state
)
1021 finally
= lower_try_finally_dup_block (finally
, outer_state
,
1022 gimple_location (tf
->try_finally_expr
));
1023 finally_may_fallthru
= gimple_seq_may_fallthru (finally
);
1025 /* If this cleanup consists of a TRY_CATCH_EXPR with TRY_CATCH_IS_CLEANUP
1026 set, the handler of the TRY_CATCH_EXPR is another cleanup which ought
1027 to be in an enclosing scope, but needs to be implemented at this level
1028 to avoid a nesting violation (see wrap_temporary_cleanups in
1029 cp/decl.c). Since it's logically at an outer level, we should call
1030 terminate before we get to it, so strip it away before adding the
1031 MUST_NOT_THROW filter. */
1032 gsi
= gsi_start (finally
);
1034 if (gimple_code (x
) == GIMPLE_TRY
1035 && gimple_try_kind (x
) == GIMPLE_TRY_CATCH
1036 && gimple_try_catch_is_cleanup (x
))
1038 gsi_insert_seq_before (&gsi
, gimple_try_eval (x
), GSI_SAME_STMT
);
1039 gsi_remove (&gsi
, false);
1042 /* Wrap the block with protect_cleanup_actions as the action. */
1043 eh_mnt
= gimple_build_eh_must_not_throw (protect_cleanup_actions
);
1044 try_stmt
= gimple_build_try (finally
, gimple_seq_alloc_with_stmt (eh_mnt
),
1046 finally
= lower_eh_must_not_throw (outer_state
, try_stmt
);
1048 /* Drop all of this into the exception sequence. */
1049 emit_post_landing_pad (&eh_seq
, tf
->region
);
1050 gimple_seq_add_seq (&eh_seq
, finally
);
1051 if (finally_may_fallthru
)
1052 emit_resx (&eh_seq
, tf
->region
);
1054 /* Having now been handled, EH isn't to be considered with
1055 the rest of the outgoing edges. */
1056 tf
->may_throw
= false;
1059 /* A subroutine of lower_try_finally. We have determined that there is
1060 no fallthru edge out of the finally block. This means that there is
1061 no outgoing edge corresponding to any incoming edge. Restructure the
1062 try_finally node for this special case. */
1065 lower_try_finally_nofallthru (struct leh_state
*state
,
1066 struct leh_tf_state
*tf
)
1070 gimple_eh_else eh_else
;
1072 struct goto_queue_node
*q
, *qe
;
1074 lab
= create_artificial_label (gimple_location (tf
->try_finally_expr
));
1076 /* We expect that tf->top_p is a GIMPLE_TRY. */
1077 finally
= gimple_try_cleanup (tf
->top_p
);
1078 tf
->top_p_seq
= gimple_try_eval (tf
->top_p
);
1080 x
= gimple_build_label (lab
);
1081 gimple_seq_add_stmt (&tf
->top_p_seq
, x
);
1084 qe
= q
+ tf
->goto_queue_active
;
1087 do_return_redirection (q
, lab
, NULL
);
1089 do_goto_redirection (q
, lab
, NULL
, tf
);
1091 replace_goto_queue (tf
);
1093 /* Emit the finally block into the stream. Lower EH_ELSE at this time. */
1094 eh_else
= get_eh_else (finally
);
1097 finally
= gimple_eh_else_n_body (eh_else
);
1098 lower_eh_constructs_1 (state
, &finally
);
1099 gimple_seq_add_seq (&tf
->top_p_seq
, finally
);
1103 finally
= gimple_eh_else_e_body (eh_else
);
1104 lower_eh_constructs_1 (state
, &finally
);
1106 emit_post_landing_pad (&eh_seq
, tf
->region
);
1107 gimple_seq_add_seq (&eh_seq
, finally
);
1112 lower_eh_constructs_1 (state
, &finally
);
1113 gimple_seq_add_seq (&tf
->top_p_seq
, finally
);
1117 emit_post_landing_pad (&eh_seq
, tf
->region
);
1119 x
= gimple_build_goto (lab
);
1120 gimple_set_location (x
, gimple_location (tf
->try_finally_expr
));
1121 gimple_seq_add_stmt (&eh_seq
, x
);
1126 /* A subroutine of lower_try_finally. We have determined that there is
1127 exactly one destination of the finally block. Restructure the
1128 try_finally node for this special case. */
1131 lower_try_finally_onedest (struct leh_state
*state
, struct leh_tf_state
*tf
)
1133 struct goto_queue_node
*q
, *qe
;
1134 gimple_eh_else eh_else
;
1135 gimple_label label_stmt
;
1138 gimple_stmt_iterator gsi
;
1140 location_t loc
= gimple_location (tf
->try_finally_expr
);
1142 finally
= gimple_try_cleanup (tf
->top_p
);
1143 tf
->top_p_seq
= gimple_try_eval (tf
->top_p
);
1145 /* Since there's only one destination, and the destination edge can only
1146 either be EH or non-EH, that implies that all of our incoming edges
1147 are of the same type. Therefore we can lower EH_ELSE immediately. */
1148 eh_else
= get_eh_else (finally
);
1152 finally
= gimple_eh_else_e_body (eh_else
);
1154 finally
= gimple_eh_else_n_body (eh_else
);
1157 lower_eh_constructs_1 (state
, &finally
);
1159 for (gsi
= gsi_start (finally
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1161 gimple stmt
= gsi_stmt (gsi
);
1162 if (LOCATION_LOCUS (gimple_location (stmt
)) == UNKNOWN_LOCATION
)
1164 tree block
= gimple_block (stmt
);
1165 gimple_set_location (stmt
, gimple_location (tf
->try_finally_expr
));
1166 gimple_set_block (stmt
, block
);
1172 /* Only reachable via the exception edge. Add the given label to
1173 the head of the FINALLY block. Append a RESX at the end. */
1174 emit_post_landing_pad (&eh_seq
, tf
->region
);
1175 gimple_seq_add_seq (&eh_seq
, finally
);
1176 emit_resx (&eh_seq
, tf
->region
);
1180 if (tf
->may_fallthru
)
1182 /* Only reachable via the fallthru edge. Do nothing but let
1183 the two blocks run together; we'll fall out the bottom. */
1184 gimple_seq_add_seq (&tf
->top_p_seq
, finally
);
1188 finally_label
= create_artificial_label (loc
);
1189 label_stmt
= gimple_build_label (finally_label
);
1190 gimple_seq_add_stmt (&tf
->top_p_seq
, label_stmt
);
1192 gimple_seq_add_seq (&tf
->top_p_seq
, finally
);
1195 qe
= q
+ tf
->goto_queue_active
;
1199 /* Reachable by return expressions only. Redirect them. */
1201 do_return_redirection (q
, finally_label
, NULL
);
1202 replace_goto_queue (tf
);
1206 /* Reachable by goto expressions only. Redirect them. */
1208 do_goto_redirection (q
, finally_label
, NULL
, tf
);
1209 replace_goto_queue (tf
);
1211 if (tf
->dest_array
[0] == tf
->fallthru_label
)
1213 /* Reachable by goto to fallthru label only. Redirect it
1214 to the new label (already created, sadly), and do not
1215 emit the final branch out, or the fallthru label. */
1216 tf
->fallthru_label
= NULL
;
1221 /* Place the original return/goto to the original destination
1222 immediately after the finally block. */
1223 x
= tf
->goto_queue
[0].cont_stmt
;
1224 gimple_seq_add_stmt (&tf
->top_p_seq
, x
);
1225 maybe_record_in_goto_queue (state
, x
);
1228 /* A subroutine of lower_try_finally. There are multiple edges incoming
1229 and outgoing from the finally block. Implement this by duplicating the
1230 finally block for every destination. */
1233 lower_try_finally_copy (struct leh_state
*state
, struct leh_tf_state
*tf
)
1236 gimple_seq new_stmt
;
1239 gimple_eh_else eh_else
;
1241 location_t tf_loc
= gimple_location (tf
->try_finally_expr
);
1243 finally
= gimple_try_cleanup (tf
->top_p
);
1245 /* Notice EH_ELSE, and simplify some of the remaining code
1246 by considering FINALLY to be the normal return path only. */
1247 eh_else
= get_eh_else (finally
);
1249 finally
= gimple_eh_else_n_body (eh_else
);
1251 tf
->top_p_seq
= gimple_try_eval (tf
->top_p
);
1254 if (tf
->may_fallthru
)
1256 seq
= lower_try_finally_dup_block (finally
, state
, tf_loc
);
1257 lower_eh_constructs_1 (state
, &seq
);
1258 gimple_seq_add_seq (&new_stmt
, seq
);
1260 tmp
= lower_try_finally_fallthru_label (tf
);
1261 x
= gimple_build_goto (tmp
);
1262 gimple_set_location (x
, tf_loc
);
1263 gimple_seq_add_stmt (&new_stmt
, x
);
1268 /* We don't need to copy the EH path of EH_ELSE,
1269 since it is only emitted once. */
1271 seq
= gimple_eh_else_e_body (eh_else
);
1273 seq
= lower_try_finally_dup_block (finally
, state
, tf_loc
);
1274 lower_eh_constructs_1 (state
, &seq
);
1276 emit_post_landing_pad (&eh_seq
, tf
->region
);
1277 gimple_seq_add_seq (&eh_seq
, seq
);
1278 emit_resx (&eh_seq
, tf
->region
);
1283 struct goto_queue_node
*q
, *qe
;
1284 int return_index
, index
;
1287 struct goto_queue_node
*q
;
1291 return_index
= tf
->dest_array
.length ();
1292 labels
= XCNEWVEC (struct labels_s
, return_index
+ 1);
1295 qe
= q
+ tf
->goto_queue_active
;
1298 index
= q
->index
< 0 ? return_index
: q
->index
;
1300 if (!labels
[index
].q
)
1301 labels
[index
].q
= q
;
1304 for (index
= 0; index
< return_index
+ 1; index
++)
1308 q
= labels
[index
].q
;
1312 lab
= labels
[index
].label
1313 = create_artificial_label (tf_loc
);
1315 if (index
== return_index
)
1316 do_return_redirection (q
, lab
, NULL
);
1318 do_goto_redirection (q
, lab
, NULL
, tf
);
1320 x
= gimple_build_label (lab
);
1321 gimple_seq_add_stmt (&new_stmt
, x
);
1323 seq
= lower_try_finally_dup_block (finally
, state
, q
->location
);
1324 lower_eh_constructs_1 (state
, &seq
);
1325 gimple_seq_add_seq (&new_stmt
, seq
);
1327 gimple_seq_add_stmt (&new_stmt
, q
->cont_stmt
);
1328 maybe_record_in_goto_queue (state
, q
->cont_stmt
);
1331 for (q
= tf
->goto_queue
; q
< qe
; q
++)
1335 index
= q
->index
< 0 ? return_index
: q
->index
;
1337 if (labels
[index
].q
== q
)
1340 lab
= labels
[index
].label
;
1342 if (index
== return_index
)
1343 do_return_redirection (q
, lab
, NULL
);
1345 do_goto_redirection (q
, lab
, NULL
, tf
);
1348 replace_goto_queue (tf
);
1352 /* Need to link new stmts after running replace_goto_queue due
1353 to not wanting to process the same goto stmts twice. */
1354 gimple_seq_add_seq (&tf
->top_p_seq
, new_stmt
);
1357 /* A subroutine of lower_try_finally. There are multiple edges incoming
1358 and outgoing from the finally block. Implement this by instrumenting
1359 each incoming edge and creating a switch statement at the end of the
1360 finally block that branches to the appropriate destination. */
1363 lower_try_finally_switch (struct leh_state
*state
, struct leh_tf_state
*tf
)
1365 struct goto_queue_node
*q
, *qe
;
1366 tree finally_tmp
, finally_label
;
1367 int return_index
, eh_index
, fallthru_index
;
1368 int nlabels
, ndests
, j
, last_case_index
;
1370 vec
<tree
> case_label_vec
;
1371 gimple_seq switch_body
= NULL
;
1373 gimple_eh_else eh_else
;
1377 hash_map
<tree
, gimple
> *cont_map
= NULL
;
1378 /* The location of the TRY_FINALLY stmt. */
1379 location_t tf_loc
= gimple_location (tf
->try_finally_expr
);
1380 /* The location of the finally block. */
1381 location_t finally_loc
;
1383 finally
= gimple_try_cleanup (tf
->top_p
);
1384 eh_else
= get_eh_else (finally
);
1386 /* Mash the TRY block to the head of the chain. */
1387 tf
->top_p_seq
= gimple_try_eval (tf
->top_p
);
1389 /* The location of the finally is either the last stmt in the finally
1390 block or the location of the TRY_FINALLY itself. */
1391 x
= gimple_seq_last_stmt (finally
);
1392 finally_loc
= x
? gimple_location (x
) : tf_loc
;
1394 /* Prepare for switch statement generation. */
1395 nlabels
= tf
->dest_array
.length ();
1396 return_index
= nlabels
;
1397 eh_index
= return_index
+ tf
->may_return
;
1398 fallthru_index
= eh_index
+ (tf
->may_throw
&& !eh_else
);
1399 ndests
= fallthru_index
+ tf
->may_fallthru
;
1401 finally_tmp
= create_tmp_var (integer_type_node
, "finally_tmp");
1402 finally_label
= create_artificial_label (finally_loc
);
1404 /* We use vec::quick_push on case_label_vec throughout this function,
1405 since we know the size in advance and allocate precisely as muce
1407 case_label_vec
.create (ndests
);
1409 last_case_index
= 0;
1411 /* Begin inserting code for getting to the finally block. Things
1412 are done in this order to correspond to the sequence the code is
1415 if (tf
->may_fallthru
)
1417 x
= gimple_build_assign (finally_tmp
,
1418 build_int_cst (integer_type_node
,
1420 gimple_seq_add_stmt (&tf
->top_p_seq
, x
);
1422 tmp
= build_int_cst (integer_type_node
, fallthru_index
);
1423 last_case
= build_case_label (tmp
, NULL
,
1424 create_artificial_label (tf_loc
));
1425 case_label_vec
.quick_push (last_case
);
1428 x
= gimple_build_label (CASE_LABEL (last_case
));
1429 gimple_seq_add_stmt (&switch_body
, x
);
1431 tmp
= lower_try_finally_fallthru_label (tf
);
1432 x
= gimple_build_goto (tmp
);
1433 gimple_set_location (x
, tf_loc
);
1434 gimple_seq_add_stmt (&switch_body
, x
);
1437 /* For EH_ELSE, emit the exception path (plus resx) now, then
1438 subsequently we only need consider the normal path. */
1443 finally
= gimple_eh_else_e_body (eh_else
);
1444 lower_eh_constructs_1 (state
, &finally
);
1446 emit_post_landing_pad (&eh_seq
, tf
->region
);
1447 gimple_seq_add_seq (&eh_seq
, finally
);
1448 emit_resx (&eh_seq
, tf
->region
);
1451 finally
= gimple_eh_else_n_body (eh_else
);
1453 else if (tf
->may_throw
)
1455 emit_post_landing_pad (&eh_seq
, tf
->region
);
1457 x
= gimple_build_assign (finally_tmp
,
1458 build_int_cst (integer_type_node
, eh_index
));
1459 gimple_seq_add_stmt (&eh_seq
, x
);
1461 x
= gimple_build_goto (finally_label
);
1462 gimple_set_location (x
, tf_loc
);
1463 gimple_seq_add_stmt (&eh_seq
, x
);
1465 tmp
= build_int_cst (integer_type_node
, eh_index
);
1466 last_case
= build_case_label (tmp
, NULL
,
1467 create_artificial_label (tf_loc
));
1468 case_label_vec
.quick_push (last_case
);
1471 x
= gimple_build_label (CASE_LABEL (last_case
));
1472 gimple_seq_add_stmt (&eh_seq
, x
);
1473 emit_resx (&eh_seq
, tf
->region
);
1476 x
= gimple_build_label (finally_label
);
1477 gimple_seq_add_stmt (&tf
->top_p_seq
, x
);
1479 lower_eh_constructs_1 (state
, &finally
);
1480 gimple_seq_add_seq (&tf
->top_p_seq
, finally
);
1482 /* Redirect each incoming goto edge. */
1484 qe
= q
+ tf
->goto_queue_active
;
1485 j
= last_case_index
+ tf
->may_return
;
1486 /* Prepare the assignments to finally_tmp that are executed upon the
1487 entrance through a particular edge. */
1490 gimple_seq mod
= NULL
;
1492 unsigned int case_index
;
1496 x
= gimple_build_assign (finally_tmp
,
1497 build_int_cst (integer_type_node
,
1499 gimple_seq_add_stmt (&mod
, x
);
1500 do_return_redirection (q
, finally_label
, mod
);
1501 switch_id
= return_index
;
1505 x
= gimple_build_assign (finally_tmp
,
1506 build_int_cst (integer_type_node
, q
->index
));
1507 gimple_seq_add_stmt (&mod
, x
);
1508 do_goto_redirection (q
, finally_label
, mod
, tf
);
1509 switch_id
= q
->index
;
1512 case_index
= j
+ q
->index
;
1513 if (case_label_vec
.length () <= case_index
|| !case_label_vec
[case_index
])
1516 tmp
= build_int_cst (integer_type_node
, switch_id
);
1517 case_lab
= build_case_label (tmp
, NULL
,
1518 create_artificial_label (tf_loc
));
1519 /* We store the cont_stmt in the pointer map, so that we can recover
1520 it in the loop below. */
1522 cont_map
= new hash_map
<tree
, gimple
>;
1523 cont_map
->put (case_lab
, q
->cont_stmt
);
1524 case_label_vec
.quick_push (case_lab
);
1527 for (j
= last_case_index
; j
< last_case_index
+ nlabels
; j
++)
1531 last_case
= case_label_vec
[j
];
1533 gcc_assert (last_case
);
1534 gcc_assert (cont_map
);
1536 cont_stmt
= *cont_map
->get (last_case
);
1538 x
= gimple_build_label (CASE_LABEL (last_case
));
1539 gimple_seq_add_stmt (&switch_body
, x
);
1540 gimple_seq_add_stmt (&switch_body
, cont_stmt
);
1541 maybe_record_in_goto_queue (state
, cont_stmt
);
1546 replace_goto_queue (tf
);
1548 /* Make sure that the last case is the default label, as one is required.
1549 Then sort the labels, which is also required in GIMPLE. */
1550 CASE_LOW (last_case
) = NULL
;
1551 tree tem
= case_label_vec
.pop ();
1552 gcc_assert (tem
== last_case
);
1553 sort_case_labels (case_label_vec
);
1555 /* Build the switch statement, setting last_case to be the default
1557 switch_stmt
= gimple_build_switch (finally_tmp
, last_case
,
1559 gimple_set_location (switch_stmt
, finally_loc
);
1561 /* Need to link SWITCH_STMT after running replace_goto_queue
1562 due to not wanting to process the same goto stmts twice. */
1563 gimple_seq_add_stmt (&tf
->top_p_seq
, switch_stmt
);
1564 gimple_seq_add_seq (&tf
->top_p_seq
, switch_body
);
1567 /* Decide whether or not we are going to duplicate the finally block.
1568 There are several considerations.
1570 First, if this is Java, then the finally block contains code
1571 written by the user. It has line numbers associated with it,
1572 so duplicating the block means it's difficult to set a breakpoint.
1573 Since controlling code generation via -g is verboten, we simply
1574 never duplicate code without optimization.
1576 Second, we'd like to prevent egregious code growth. One way to
1577 do this is to estimate the size of the finally block, multiply
1578 that by the number of copies we'd need to make, and compare against
1579 the estimate of the size of the switch machinery we'd have to add. */
1582 decide_copy_try_finally (int ndests
, bool may_throw
, gimple_seq finally
)
1584 int f_estimate
, sw_estimate
;
1585 gimple_eh_else eh_else
;
1587 /* If there's an EH_ELSE involved, the exception path is separate
1588 and really doesn't come into play for this computation. */
1589 eh_else
= get_eh_else (finally
);
1592 ndests
-= may_throw
;
1593 finally
= gimple_eh_else_n_body (eh_else
);
1598 gimple_stmt_iterator gsi
;
1603 for (gsi
= gsi_start (finally
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1605 gimple stmt
= gsi_stmt (gsi
);
1606 if (!is_gimple_debug (stmt
) && !gimple_clobber_p (stmt
))
1612 /* Finally estimate N times, plus N gotos. */
1613 f_estimate
= count_insns_seq (finally
, &eni_size_weights
);
1614 f_estimate
= (f_estimate
+ 1) * ndests
;
1616 /* Switch statement (cost 10), N variable assignments, N gotos. */
1617 sw_estimate
= 10 + 2 * ndests
;
1619 /* Optimize for size clearly wants our best guess. */
1620 if (optimize_function_for_size_p (cfun
))
1621 return f_estimate
< sw_estimate
;
1623 /* ??? These numbers are completely made up so far. */
1625 return f_estimate
< 100 || f_estimate
< sw_estimate
* 2;
1627 return f_estimate
< 40 || f_estimate
* 2 < sw_estimate
* 3;
1630 /* REG is the enclosing region for a possible cleanup region, or the region
1631 itself. Returns TRUE if such a region would be unreachable.
1633 Cleanup regions within a must-not-throw region aren't actually reachable
1634 even if there are throwing stmts within them, because the personality
1635 routine will call terminate before unwinding. */
1638 cleanup_is_dead_in (eh_region reg
)
1640 while (reg
&& reg
->type
== ERT_CLEANUP
)
1642 return (reg
&& reg
->type
== ERT_MUST_NOT_THROW
);
1645 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_FINALLY nodes
1646 to a sequence of labels and blocks, plus the exception region trees
1647 that record all the magic. This is complicated by the need to
1648 arrange for the FINALLY block to be executed on all exits. */
1651 lower_try_finally (struct leh_state
*state
, gimple_try tp
)
1653 struct leh_tf_state this_tf
;
1654 struct leh_state this_state
;
1656 gimple_seq old_eh_seq
;
1658 /* Process the try block. */
1660 memset (&this_tf
, 0, sizeof (this_tf
));
1661 this_tf
.try_finally_expr
= tp
;
1663 this_tf
.outer
= state
;
1664 if (using_eh_for_cleanups_p () && !cleanup_is_dead_in (state
->cur_region
))
1666 this_tf
.region
= gen_eh_region_cleanup (state
->cur_region
);
1667 this_state
.cur_region
= this_tf
.region
;
1671 this_tf
.region
= NULL
;
1672 this_state
.cur_region
= state
->cur_region
;
1675 this_state
.ehp_region
= state
->ehp_region
;
1676 this_state
.tf
= &this_tf
;
1678 old_eh_seq
= eh_seq
;
1681 lower_eh_constructs_1 (&this_state
, gimple_try_eval_ptr (tp
));
1683 /* Determine if the try block is escaped through the bottom. */
1684 this_tf
.may_fallthru
= gimple_seq_may_fallthru (gimple_try_eval (tp
));
1686 /* Determine if any exceptions are possible within the try block. */
1688 this_tf
.may_throw
= eh_region_may_contain_throw (this_tf
.region
);
1689 if (this_tf
.may_throw
)
1690 honor_protect_cleanup_actions (state
, &this_state
, &this_tf
);
1692 /* Determine how many edges (still) reach the finally block. Or rather,
1693 how many destinations are reached by the finally block. Use this to
1694 determine how we process the finally block itself. */
1696 ndests
= this_tf
.dest_array
.length ();
1697 ndests
+= this_tf
.may_fallthru
;
1698 ndests
+= this_tf
.may_return
;
1699 ndests
+= this_tf
.may_throw
;
1701 /* If the FINALLY block is not reachable, dike it out. */
1704 gimple_seq_add_seq (&this_tf
.top_p_seq
, gimple_try_eval (tp
));
1705 gimple_try_set_cleanup (tp
, NULL
);
1707 /* If the finally block doesn't fall through, then any destination
1708 we might try to impose there isn't reached either. There may be
1709 some minor amount of cleanup and redirection still needed. */
1710 else if (!gimple_seq_may_fallthru (gimple_try_cleanup (tp
)))
1711 lower_try_finally_nofallthru (state
, &this_tf
);
1713 /* We can easily special-case redirection to a single destination. */
1714 else if (ndests
== 1)
1715 lower_try_finally_onedest (state
, &this_tf
);
1716 else if (decide_copy_try_finally (ndests
, this_tf
.may_throw
,
1717 gimple_try_cleanup (tp
)))
1718 lower_try_finally_copy (state
, &this_tf
);
1720 lower_try_finally_switch (state
, &this_tf
);
1722 /* If someone requested we add a label at the end of the transformed
1724 if (this_tf
.fallthru_label
)
1726 /* This must be reached only if ndests == 0. */
1727 gimple x
= gimple_build_label (this_tf
.fallthru_label
);
1728 gimple_seq_add_stmt (&this_tf
.top_p_seq
, x
);
1731 this_tf
.dest_array
.release ();
1732 free (this_tf
.goto_queue
);
1733 if (this_tf
.goto_queue_map
)
1734 delete this_tf
.goto_queue_map
;
1736 /* If there was an old (aka outer) eh_seq, append the current eh_seq.
1737 If there was no old eh_seq, then the append is trivially already done. */
1741 eh_seq
= old_eh_seq
;
1744 gimple_seq new_eh_seq
= eh_seq
;
1745 eh_seq
= old_eh_seq
;
1746 gimple_seq_add_seq (&eh_seq
, new_eh_seq
);
1750 return this_tf
.top_p_seq
;
1753 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_CATCH with a
1754 list of GIMPLE_CATCH to a sequence of labels and blocks, plus the
1755 exception region trees that records all the magic. */
1758 lower_catch (struct leh_state
*state
, gimple_try tp
)
1760 eh_region try_region
= NULL
;
1761 struct leh_state this_state
= *state
;
1762 gimple_stmt_iterator gsi
;
1764 gimple_seq new_seq
, cleanup
;
1766 location_t try_catch_loc
= gimple_location (tp
);
1768 if (flag_exceptions
)
1770 try_region
= gen_eh_region_try (state
->cur_region
);
1771 this_state
.cur_region
= try_region
;
1774 lower_eh_constructs_1 (&this_state
, gimple_try_eval_ptr (tp
));
1776 if (!eh_region_may_contain_throw (try_region
))
1777 return gimple_try_eval (tp
);
1780 emit_eh_dispatch (&new_seq
, try_region
);
1781 emit_resx (&new_seq
, try_region
);
1783 this_state
.cur_region
= state
->cur_region
;
1784 this_state
.ehp_region
= try_region
;
1787 cleanup
= gimple_try_cleanup (tp
);
1788 for (gsi
= gsi_start (cleanup
);
1793 gimple_catch gcatch
;
1796 gcatch
= as_a
<gimple_catch
> (gsi_stmt (gsi
));
1797 c
= gen_eh_region_catch (try_region
, gimple_catch_types (gcatch
));
1799 handler
= gimple_catch_handler (gcatch
);
1800 lower_eh_constructs_1 (&this_state
, &handler
);
1802 c
->label
= create_artificial_label (UNKNOWN_LOCATION
);
1803 x
= gimple_build_label (c
->label
);
1804 gimple_seq_add_stmt (&new_seq
, x
);
1806 gimple_seq_add_seq (&new_seq
, handler
);
1808 if (gimple_seq_may_fallthru (new_seq
))
1811 out_label
= create_artificial_label (try_catch_loc
);
1813 x
= gimple_build_goto (out_label
);
1814 gimple_seq_add_stmt (&new_seq
, x
);
1820 gimple_try_set_cleanup (tp
, new_seq
);
1822 return frob_into_branch_around (tp
, try_region
, out_label
);
1825 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with a
1826 GIMPLE_EH_FILTER to a sequence of labels and blocks, plus the exception
1827 region trees that record all the magic. */
1830 lower_eh_filter (struct leh_state
*state
, gimple_try tp
)
1832 struct leh_state this_state
= *state
;
1833 eh_region this_region
= NULL
;
1837 inner
= gimple_seq_first_stmt (gimple_try_cleanup (tp
));
1839 if (flag_exceptions
)
1841 this_region
= gen_eh_region_allowed (state
->cur_region
,
1842 gimple_eh_filter_types (inner
));
1843 this_state
.cur_region
= this_region
;
1846 lower_eh_constructs_1 (&this_state
, gimple_try_eval_ptr (tp
));
1848 if (!eh_region_may_contain_throw (this_region
))
1849 return gimple_try_eval (tp
);
1852 this_state
.cur_region
= state
->cur_region
;
1853 this_state
.ehp_region
= this_region
;
1855 emit_eh_dispatch (&new_seq
, this_region
);
1856 emit_resx (&new_seq
, this_region
);
1858 this_region
->u
.allowed
.label
= create_artificial_label (UNKNOWN_LOCATION
);
1859 x
= gimple_build_label (this_region
->u
.allowed
.label
);
1860 gimple_seq_add_stmt (&new_seq
, x
);
1862 lower_eh_constructs_1 (&this_state
, gimple_eh_filter_failure_ptr (inner
));
1863 gimple_seq_add_seq (&new_seq
, gimple_eh_filter_failure (inner
));
1865 gimple_try_set_cleanup (tp
, new_seq
);
1867 return frob_into_branch_around (tp
, this_region
, NULL
);
1870 /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with
1871 an GIMPLE_EH_MUST_NOT_THROW to a sequence of labels and blocks,
1872 plus the exception region trees that record all the magic. */
1875 lower_eh_must_not_throw (struct leh_state
*state
, gimple_try tp
)
1877 struct leh_state this_state
= *state
;
1879 if (flag_exceptions
)
1881 gimple inner
= gimple_seq_first_stmt (gimple_try_cleanup (tp
));
1882 eh_region this_region
;
1884 this_region
= gen_eh_region_must_not_throw (state
->cur_region
);
1885 this_region
->u
.must_not_throw
.failure_decl
1886 = gimple_eh_must_not_throw_fndecl (
1887 as_a
<gimple_eh_must_not_throw
> (inner
));
1888 this_region
->u
.must_not_throw
.failure_loc
1889 = LOCATION_LOCUS (gimple_location (tp
));
1891 /* In order to get mangling applied to this decl, we must mark it
1892 used now. Otherwise, pass_ipa_free_lang_data won't think it
1894 TREE_USED (this_region
->u
.must_not_throw
.failure_decl
) = 1;
1896 this_state
.cur_region
= this_region
;
1899 lower_eh_constructs_1 (&this_state
, gimple_try_eval_ptr (tp
));
1901 return gimple_try_eval (tp
);
1904 /* Implement a cleanup expression. This is similar to try-finally,
1905 except that we only execute the cleanup block for exception edges. */
1908 lower_cleanup (struct leh_state
*state
, gimple_try tp
)
1910 struct leh_state this_state
= *state
;
1911 eh_region this_region
= NULL
;
1912 struct leh_tf_state fake_tf
;
1914 bool cleanup_dead
= cleanup_is_dead_in (state
->cur_region
);
1916 if (flag_exceptions
&& !cleanup_dead
)
1918 this_region
= gen_eh_region_cleanup (state
->cur_region
);
1919 this_state
.cur_region
= this_region
;
1922 lower_eh_constructs_1 (&this_state
, gimple_try_eval_ptr (tp
));
1924 if (cleanup_dead
|| !eh_region_may_contain_throw (this_region
))
1925 return gimple_try_eval (tp
);
1927 /* Build enough of a try-finally state so that we can reuse
1928 honor_protect_cleanup_actions. */
1929 memset (&fake_tf
, 0, sizeof (fake_tf
));
1930 fake_tf
.top_p
= fake_tf
.try_finally_expr
= tp
;
1931 fake_tf
.outer
= state
;
1932 fake_tf
.region
= this_region
;
1933 fake_tf
.may_fallthru
= gimple_seq_may_fallthru (gimple_try_eval (tp
));
1934 fake_tf
.may_throw
= true;
1936 honor_protect_cleanup_actions (state
, NULL
, &fake_tf
);
1938 if (fake_tf
.may_throw
)
1940 /* In this case honor_protect_cleanup_actions had nothing to do,
1941 and we should process this normally. */
1942 lower_eh_constructs_1 (state
, gimple_try_cleanup_ptr (tp
));
1943 result
= frob_into_branch_around (tp
, this_region
,
1944 fake_tf
.fallthru_label
);
1948 /* In this case honor_protect_cleanup_actions did nearly all of
1949 the work. All we have left is to append the fallthru_label. */
1951 result
= gimple_try_eval (tp
);
1952 if (fake_tf
.fallthru_label
)
1954 gimple x
= gimple_build_label (fake_tf
.fallthru_label
);
1955 gimple_seq_add_stmt (&result
, x
);
1961 /* Main loop for lowering eh constructs. Also moves gsi to the next
1965 lower_eh_constructs_2 (struct leh_state
*state
, gimple_stmt_iterator
*gsi
)
1969 gimple stmt
= gsi_stmt (*gsi
);
1971 switch (gimple_code (stmt
))
1975 tree fndecl
= gimple_call_fndecl (stmt
);
1978 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
1979 switch (DECL_FUNCTION_CODE (fndecl
))
1981 case BUILT_IN_EH_POINTER
:
1982 /* The front end may have generated a call to
1983 __builtin_eh_pointer (0) within a catch region. Replace
1984 this zero argument with the current catch region number. */
1985 if (state
->ehp_region
)
1987 tree nr
= build_int_cst (integer_type_node
,
1988 state
->ehp_region
->index
);
1989 gimple_call_set_arg (stmt
, 0, nr
);
1993 /* The user has dome something silly. Remove it. */
1994 rhs
= null_pointer_node
;
1999 case BUILT_IN_EH_FILTER
:
2000 /* ??? This should never appear, but since it's a builtin it
2001 is accessible to abuse by users. Just remove it and
2002 replace the use with the arbitrary value zero. */
2003 rhs
= build_int_cst (TREE_TYPE (TREE_TYPE (fndecl
)), 0);
2005 lhs
= gimple_call_lhs (stmt
);
2006 x
= gimple_build_assign (lhs
, rhs
);
2007 gsi_insert_before (gsi
, x
, GSI_SAME_STMT
);
2010 case BUILT_IN_EH_COPY_VALUES
:
2011 /* Likewise this should not appear. Remove it. */
2012 gsi_remove (gsi
, true);
2022 /* If the stmt can throw use a new temporary for the assignment
2023 to a LHS. This makes sure the old value of the LHS is
2024 available on the EH edge. Only do so for statements that
2025 potentially fall through (no noreturn calls e.g.), otherwise
2026 this new assignment might create fake fallthru regions. */
2027 if (stmt_could_throw_p (stmt
)
2028 && gimple_has_lhs (stmt
)
2029 && gimple_stmt_may_fallthru (stmt
)
2030 && !tree_could_throw_p (gimple_get_lhs (stmt
))
2031 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
2033 tree lhs
= gimple_get_lhs (stmt
);
2034 tree tmp
= create_tmp_var (TREE_TYPE (lhs
), NULL
);
2035 gimple s
= gimple_build_assign (lhs
, tmp
);
2036 gimple_set_location (s
, gimple_location (stmt
));
2037 gimple_set_block (s
, gimple_block (stmt
));
2038 gimple_set_lhs (stmt
, tmp
);
2039 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
2040 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
2041 DECL_GIMPLE_REG_P (tmp
) = 1;
2042 gsi_insert_after (gsi
, s
, GSI_SAME_STMT
);
2044 /* Look for things that can throw exceptions, and record them. */
2045 if (state
->cur_region
&& stmt_could_throw_p (stmt
))
2047 record_stmt_eh_region (state
->cur_region
, stmt
);
2048 note_eh_region_may_contain_throw (state
->cur_region
);
2055 maybe_record_in_goto_queue (state
, stmt
);
2059 verify_norecord_switch_expr (state
, as_a
<gimple_switch
> (stmt
));
2064 gimple_try try_stmt
= as_a
<gimple_try
> (stmt
);
2065 if (gimple_try_kind (try_stmt
) == GIMPLE_TRY_FINALLY
)
2066 replace
= lower_try_finally (state
, try_stmt
);
2069 x
= gimple_seq_first_stmt (gimple_try_cleanup (try_stmt
));
2072 replace
= gimple_try_eval (try_stmt
);
2073 lower_eh_constructs_1 (state
, &replace
);
2076 switch (gimple_code (x
))
2079 replace
= lower_catch (state
, try_stmt
);
2081 case GIMPLE_EH_FILTER
:
2082 replace
= lower_eh_filter (state
, try_stmt
);
2084 case GIMPLE_EH_MUST_NOT_THROW
:
2085 replace
= lower_eh_must_not_throw (state
, try_stmt
);
2087 case GIMPLE_EH_ELSE
:
2088 /* This code is only valid with GIMPLE_TRY_FINALLY. */
2091 replace
= lower_cleanup (state
, try_stmt
);
2097 /* Remove the old stmt and insert the transformed sequence
2099 gsi_insert_seq_before (gsi
, replace
, GSI_SAME_STMT
);
2100 gsi_remove (gsi
, true);
2102 /* Return since we don't want gsi_next () */
2105 case GIMPLE_EH_ELSE
:
2106 /* We should be eliminating this in lower_try_finally et al. */
2110 /* A type, a decl, or some kind of statement that we're not
2111 interested in. Don't walk them. */
2118 /* A helper to unwrap a gimple_seq and feed stmts to lower_eh_constructs_2. */
2121 lower_eh_constructs_1 (struct leh_state
*state
, gimple_seq
*pseq
)
2123 gimple_stmt_iterator gsi
;
2124 for (gsi
= gsi_start (*pseq
); !gsi_end_p (gsi
);)
2125 lower_eh_constructs_2 (state
, &gsi
);
2130 const pass_data pass_data_lower_eh
=
2132 GIMPLE_PASS
, /* type */
2134 OPTGROUP_NONE
, /* optinfo_flags */
2135 TV_TREE_EH
, /* tv_id */
2136 PROP_gimple_lcf
, /* properties_required */
2137 PROP_gimple_leh
, /* properties_provided */
2138 0, /* properties_destroyed */
2139 0, /* todo_flags_start */
2140 0, /* todo_flags_finish */
2143 class pass_lower_eh
: public gimple_opt_pass
2146 pass_lower_eh (gcc::context
*ctxt
)
2147 : gimple_opt_pass (pass_data_lower_eh
, ctxt
)
2150 /* opt_pass methods: */
2151 virtual unsigned int execute (function
*);
2153 }; // class pass_lower_eh
2156 pass_lower_eh::execute (function
*fun
)
2158 struct leh_state null_state
;
2161 bodyp
= gimple_body (current_function_decl
);
2165 finally_tree
= new hash_table
<finally_tree_hasher
> (31);
2166 eh_region_may_contain_throw_map
= BITMAP_ALLOC (NULL
);
2167 memset (&null_state
, 0, sizeof (null_state
));
2169 collect_finally_tree_1 (bodyp
, NULL
);
2170 lower_eh_constructs_1 (&null_state
, &bodyp
);
2171 gimple_set_body (current_function_decl
, bodyp
);
2173 /* We assume there's a return statement, or something, at the end of
2174 the function, and thus ploping the EH sequence afterward won't
2176 gcc_assert (!gimple_seq_may_fallthru (bodyp
));
2177 gimple_seq_add_seq (&bodyp
, eh_seq
);
2179 /* We assume that since BODYP already existed, adding EH_SEQ to it
2180 didn't change its value, and we don't have to re-set the function. */
2181 gcc_assert (bodyp
== gimple_body (current_function_decl
));
2183 delete finally_tree
;
2184 finally_tree
= NULL
;
2185 BITMAP_FREE (eh_region_may_contain_throw_map
);
2188 /* If this function needs a language specific EH personality routine
2189 and the frontend didn't already set one do so now. */
2190 if (function_needs_eh_personality (fun
) == eh_personality_lang
2191 && !DECL_FUNCTION_PERSONALITY (current_function_decl
))
2192 DECL_FUNCTION_PERSONALITY (current_function_decl
)
2193 = lang_hooks
.eh_personality ();
2201 make_pass_lower_eh (gcc::context
*ctxt
)
2203 return new pass_lower_eh (ctxt
);
2206 /* Create the multiple edges from an EH_DISPATCH statement to all of
2207 the possible handlers for its EH region. Return true if there's
2208 no fallthru edge; false if there is. */
2211 make_eh_dispatch_edges (gimple_eh_dispatch stmt
)
2215 basic_block src
, dst
;
2217 r
= get_eh_region_from_number (gimple_eh_dispatch_region (stmt
));
2218 src
= gimple_bb (stmt
);
2223 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
2225 dst
= label_to_block (c
->label
);
2226 make_edge (src
, dst
, 0);
2228 /* A catch-all handler doesn't have a fallthru. */
2229 if (c
->type_list
== NULL
)
2234 case ERT_ALLOWED_EXCEPTIONS
:
2235 dst
= label_to_block (r
->u
.allowed
.label
);
2236 make_edge (src
, dst
, 0);
2246 /* Create the single EH edge from STMT to its nearest landing pad,
2247 if there is such a landing pad within the current function. */
2250 make_eh_edges (gimple stmt
)
2252 basic_block src
, dst
;
2256 lp_nr
= lookup_stmt_eh_lp (stmt
);
2260 lp
= get_eh_landing_pad_from_number (lp_nr
);
2261 gcc_assert (lp
!= NULL
);
2263 src
= gimple_bb (stmt
);
2264 dst
= label_to_block (lp
->post_landing_pad
);
2265 make_edge (src
, dst
, EDGE_EH
);
2268 /* Do the work in redirecting EDGE_IN to NEW_BB within the EH region tree;
2269 do not actually perform the final edge redirection.
2271 CHANGE_REGION is true when we're being called from cleanup_empty_eh and
2272 we intend to change the destination EH region as well; this means
2273 EH_LANDING_PAD_NR must already be set on the destination block label.
2274 If false, we're being called from generic cfg manipulation code and we
2275 should preserve our place within the region tree. */
2278 redirect_eh_edge_1 (edge edge_in
, basic_block new_bb
, bool change_region
)
2280 eh_landing_pad old_lp
, new_lp
;
2283 int old_lp_nr
, new_lp_nr
;
2284 tree old_label
, new_label
;
2288 old_bb
= edge_in
->dest
;
2289 old_label
= gimple_block_label (old_bb
);
2290 old_lp_nr
= EH_LANDING_PAD_NR (old_label
);
2291 gcc_assert (old_lp_nr
> 0);
2292 old_lp
= get_eh_landing_pad_from_number (old_lp_nr
);
2294 throw_stmt
= last_stmt (edge_in
->src
);
2295 gcc_assert (lookup_stmt_eh_lp (throw_stmt
) == old_lp_nr
);
2297 new_label
= gimple_block_label (new_bb
);
2299 /* Look for an existing region that might be using NEW_BB already. */
2300 new_lp_nr
= EH_LANDING_PAD_NR (new_label
);
2303 new_lp
= get_eh_landing_pad_from_number (new_lp_nr
);
2304 gcc_assert (new_lp
);
2306 /* Unless CHANGE_REGION is true, the new and old landing pad
2307 had better be associated with the same EH region. */
2308 gcc_assert (change_region
|| new_lp
->region
== old_lp
->region
);
2313 gcc_assert (!change_region
);
2316 /* Notice when we redirect the last EH edge away from OLD_BB. */
2317 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
2318 if (e
!= edge_in
&& (e
->flags
& EDGE_EH
))
2323 /* NEW_LP already exists. If there are still edges into OLD_LP,
2324 there's nothing to do with the EH tree. If there are no more
2325 edges into OLD_LP, then we want to remove OLD_LP as it is unused.
2326 If CHANGE_REGION is true, then our caller is expecting to remove
2328 if (e
== NULL
&& !change_region
)
2329 remove_eh_landing_pad (old_lp
);
2333 /* No correct landing pad exists. If there are no more edges
2334 into OLD_LP, then we can simply re-use the existing landing pad.
2335 Otherwise, we have to create a new landing pad. */
2338 EH_LANDING_PAD_NR (old_lp
->post_landing_pad
) = 0;
2342 new_lp
= gen_eh_landing_pad (old_lp
->region
);
2343 new_lp
->post_landing_pad
= new_label
;
2344 EH_LANDING_PAD_NR (new_label
) = new_lp
->index
;
2347 /* Maybe move the throwing statement to the new region. */
2348 if (old_lp
!= new_lp
)
2350 remove_stmt_from_eh_lp (throw_stmt
);
2351 add_stmt_to_eh_lp (throw_stmt
, new_lp
->index
);
2355 /* Redirect EH edge E to NEW_BB. */
2358 redirect_eh_edge (edge edge_in
, basic_block new_bb
)
2360 redirect_eh_edge_1 (edge_in
, new_bb
, false);
2361 return ssa_redirect_edge (edge_in
, new_bb
);
2364 /* This is a subroutine of gimple_redirect_edge_and_branch. Update the
2365 labels for redirecting a non-fallthru EH_DISPATCH edge E to NEW_BB.
2366 The actual edge update will happen in the caller. */
2369 redirect_eh_dispatch_edge (gimple_eh_dispatch stmt
, edge e
, basic_block new_bb
)
2371 tree new_lab
= gimple_block_label (new_bb
);
2372 bool any_changed
= false;
2377 r
= get_eh_region_from_number (gimple_eh_dispatch_region (stmt
));
2381 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
2383 old_bb
= label_to_block (c
->label
);
2384 if (old_bb
== e
->dest
)
2392 case ERT_ALLOWED_EXCEPTIONS
:
2393 old_bb
= label_to_block (r
->u
.allowed
.label
);
2394 gcc_assert (old_bb
== e
->dest
);
2395 r
->u
.allowed
.label
= new_lab
;
2403 gcc_assert (any_changed
);
2406 /* Helper function for operation_could_trap_p and stmt_could_throw_p. */
2409 operation_could_trap_helper_p (enum tree_code op
,
2420 case TRUNC_DIV_EXPR
:
2422 case FLOOR_DIV_EXPR
:
2423 case ROUND_DIV_EXPR
:
2424 case EXACT_DIV_EXPR
:
2426 case FLOOR_MOD_EXPR
:
2427 case ROUND_MOD_EXPR
:
2428 case TRUNC_MOD_EXPR
:
2430 if (honor_snans
|| honor_trapv
)
2433 return flag_trapping_math
;
2434 if (!TREE_CONSTANT (divisor
) || integer_zerop (divisor
))
2443 /* Some floating point comparisons may trap. */
2448 case UNORDERED_EXPR
:
2458 case FIX_TRUNC_EXPR
:
2459 /* Conversion of floating point might trap. */
2465 /* These operations don't trap with floating point. */
2473 /* Any floating arithmetic may trap. */
2474 if (fp_operation
&& flag_trapping_math
)
2482 /* Constructing an object cannot trap. */
2486 /* Any floating arithmetic may trap. */
2487 if (fp_operation
&& flag_trapping_math
)
2495 /* Return true if operation OP may trap. FP_OPERATION is true if OP is applied
2496 on floating-point values. HONOR_TRAPV is true if OP is applied on integer
2497 type operands that may trap. If OP is a division operator, DIVISOR contains
2498 the value of the divisor. */
2501 operation_could_trap_p (enum tree_code op
, bool fp_operation
, bool honor_trapv
,
2504 bool honor_nans
= (fp_operation
&& flag_trapping_math
2505 && !flag_finite_math_only
);
2506 bool honor_snans
= fp_operation
&& flag_signaling_nans
!= 0;
2509 if (TREE_CODE_CLASS (op
) != tcc_comparison
2510 && TREE_CODE_CLASS (op
) != tcc_unary
2511 && TREE_CODE_CLASS (op
) != tcc_binary
)
2514 return operation_could_trap_helper_p (op
, fp_operation
, honor_trapv
,
2515 honor_nans
, honor_snans
, divisor
,
2520 /* Returns true if it is possible to prove that the index of
2521 an array access REF (an ARRAY_REF expression) falls into the
2525 in_array_bounds_p (tree ref
)
2527 tree idx
= TREE_OPERAND (ref
, 1);
2530 if (TREE_CODE (idx
) != INTEGER_CST
)
2533 min
= array_ref_low_bound (ref
);
2534 max
= array_ref_up_bound (ref
);
2537 || TREE_CODE (min
) != INTEGER_CST
2538 || TREE_CODE (max
) != INTEGER_CST
)
2541 if (tree_int_cst_lt (idx
, min
)
2542 || tree_int_cst_lt (max
, idx
))
2548 /* Returns true if it is possible to prove that the range of
2549 an array access REF (an ARRAY_RANGE_REF expression) falls
2550 into the array bounds. */
2553 range_in_array_bounds_p (tree ref
)
2555 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ref
));
2556 tree range_min
, range_max
, min
, max
;
2558 range_min
= TYPE_MIN_VALUE (domain_type
);
2559 range_max
= TYPE_MAX_VALUE (domain_type
);
2562 || TREE_CODE (range_min
) != INTEGER_CST
2563 || TREE_CODE (range_max
) != INTEGER_CST
)
2566 min
= array_ref_low_bound (ref
);
2567 max
= array_ref_up_bound (ref
);
2570 || TREE_CODE (min
) != INTEGER_CST
2571 || TREE_CODE (max
) != INTEGER_CST
)
2574 if (tree_int_cst_lt (range_min
, min
)
2575 || tree_int_cst_lt (max
, range_max
))
2581 /* Return true if EXPR can trap, as in dereferencing an invalid pointer
2582 location or floating point arithmetic. C.f. the rtl version, may_trap_p.
2583 This routine expects only GIMPLE lhs or rhs input. */
2586 tree_could_trap_p (tree expr
)
2588 enum tree_code code
;
2589 bool fp_operation
= false;
2590 bool honor_trapv
= false;
2591 tree t
, base
, div
= NULL_TREE
;
2596 code
= TREE_CODE (expr
);
2597 t
= TREE_TYPE (expr
);
2601 if (COMPARISON_CLASS_P (expr
))
2602 fp_operation
= FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 0)));
2604 fp_operation
= FLOAT_TYPE_P (t
);
2605 honor_trapv
= INTEGRAL_TYPE_P (t
) && TYPE_OVERFLOW_TRAPS (t
);
2608 if (TREE_CODE_CLASS (code
) == tcc_binary
)
2609 div
= TREE_OPERAND (expr
, 1);
2610 if (operation_could_trap_p (code
, fp_operation
, honor_trapv
, div
))
2620 case VIEW_CONVERT_EXPR
:
2621 case WITH_SIZE_EXPR
:
2622 expr
= TREE_OPERAND (expr
, 0);
2623 code
= TREE_CODE (expr
);
2626 case ARRAY_RANGE_REF
:
2627 base
= TREE_OPERAND (expr
, 0);
2628 if (tree_could_trap_p (base
))
2630 if (TREE_THIS_NOTRAP (expr
))
2632 return !range_in_array_bounds_p (expr
);
2635 base
= TREE_OPERAND (expr
, 0);
2636 if (tree_could_trap_p (base
))
2638 if (TREE_THIS_NOTRAP (expr
))
2640 return !in_array_bounds_p (expr
);
2642 case TARGET_MEM_REF
:
2644 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == ADDR_EXPR
2645 && tree_could_trap_p (TREE_OPERAND (TREE_OPERAND (expr
, 0), 0)))
2647 if (TREE_THIS_NOTRAP (expr
))
2649 /* We cannot prove that the access is in-bounds when we have
2650 variable-index TARGET_MEM_REFs. */
2651 if (code
== TARGET_MEM_REF
2652 && (TMR_INDEX (expr
) || TMR_INDEX2 (expr
)))
2654 if (TREE_CODE (TREE_OPERAND (expr
, 0)) == ADDR_EXPR
)
2656 tree base
= TREE_OPERAND (TREE_OPERAND (expr
, 0), 0);
2657 offset_int off
= mem_ref_offset (expr
);
2658 if (wi::neg_p (off
, SIGNED
))
2660 if (TREE_CODE (base
) == STRING_CST
)
2661 return wi::leu_p (TREE_STRING_LENGTH (base
), off
);
2662 else if (DECL_SIZE_UNIT (base
) == NULL_TREE
2663 || TREE_CODE (DECL_SIZE_UNIT (base
)) != INTEGER_CST
2664 || wi::leu_p (wi::to_offset (DECL_SIZE_UNIT (base
)), off
))
2666 /* Now we are sure the first byte of the access is inside
2673 return !TREE_THIS_NOTRAP (expr
);
2676 return TREE_THIS_VOLATILE (expr
);
2679 t
= get_callee_fndecl (expr
);
2680 /* Assume that calls to weak functions may trap. */
2681 if (!t
|| !DECL_P (t
))
2684 return tree_could_trap_p (t
);
2688 /* Assume that accesses to weak functions may trap, unless we know
2689 they are certainly defined in current TU or in some other
2691 if (DECL_WEAK (expr
) && !DECL_COMDAT (expr
))
2693 struct cgraph_node
*node
;
2694 if (!DECL_EXTERNAL (expr
))
2696 node
= cgraph_node::get (expr
)->function_symbol ();
2697 if (node
&& node
->in_other_partition
)
2704 /* Assume that accesses to weak vars may trap, unless we know
2705 they are certainly defined in current TU or in some other
2707 if (DECL_WEAK (expr
) && !DECL_COMDAT (expr
))
2710 if (!DECL_EXTERNAL (expr
))
2712 node
= varpool_node::get (expr
)->ultimate_alias_target ();
2713 if (node
&& node
->in_other_partition
)
2725 /* Helper for stmt_could_throw_p. Return true if STMT (assumed to be a
2726 an assignment or a conditional) may throw. */
2729 stmt_could_throw_1_p (gimple stmt
)
2731 enum tree_code code
= gimple_expr_code (stmt
);
2732 bool honor_nans
= false;
2733 bool honor_snans
= false;
2734 bool fp_operation
= false;
2735 bool honor_trapv
= false;
2740 if (TREE_CODE_CLASS (code
) == tcc_comparison
2741 || TREE_CODE_CLASS (code
) == tcc_unary
2742 || TREE_CODE_CLASS (code
) == tcc_binary
)
2744 if (is_gimple_assign (stmt
)
2745 && TREE_CODE_CLASS (code
) == tcc_comparison
)
2746 t
= TREE_TYPE (gimple_assign_rhs1 (stmt
));
2747 else if (gimple_code (stmt
) == GIMPLE_COND
)
2748 t
= TREE_TYPE (gimple_cond_lhs (stmt
));
2750 t
= gimple_expr_type (stmt
);
2751 fp_operation
= FLOAT_TYPE_P (t
);
2754 honor_nans
= flag_trapping_math
&& !flag_finite_math_only
;
2755 honor_snans
= flag_signaling_nans
!= 0;
2757 else if (INTEGRAL_TYPE_P (t
) && TYPE_OVERFLOW_TRAPS (t
))
2761 /* Check if the main expression may trap. */
2762 t
= is_gimple_assign (stmt
) ? gimple_assign_rhs2 (stmt
) : NULL
;
2763 ret
= operation_could_trap_helper_p (code
, fp_operation
, honor_trapv
,
2764 honor_nans
, honor_snans
, t
,
2769 /* If the expression does not trap, see if any of the individual operands may
2771 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
2772 if (tree_could_trap_p (gimple_op (stmt
, i
)))
2779 /* Return true if statement STMT could throw an exception. */
2782 stmt_could_throw_p (gimple stmt
)
2784 if (!flag_exceptions
)
2787 /* The only statements that can throw an exception are assignments,
2788 conditionals, calls, resx, and asms. */
2789 switch (gimple_code (stmt
))
2795 return !gimple_call_nothrow_p (stmt
);
2799 if (!cfun
->can_throw_non_call_exceptions
)
2801 return stmt_could_throw_1_p (stmt
);
2804 if (!cfun
->can_throw_non_call_exceptions
)
2806 return gimple_asm_volatile_p (as_a
<gimple_asm
> (stmt
));
2814 /* Return true if expression T could throw an exception. */
2817 tree_could_throw_p (tree t
)
2819 if (!flag_exceptions
)
2821 if (TREE_CODE (t
) == MODIFY_EXPR
)
2823 if (cfun
->can_throw_non_call_exceptions
2824 && tree_could_trap_p (TREE_OPERAND (t
, 0)))
2826 t
= TREE_OPERAND (t
, 1);
2829 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
2830 t
= TREE_OPERAND (t
, 0);
2831 if (TREE_CODE (t
) == CALL_EXPR
)
2832 return (call_expr_flags (t
) & ECF_NOTHROW
) == 0;
2833 if (cfun
->can_throw_non_call_exceptions
)
2834 return tree_could_trap_p (t
);
2838 /* Return true if STMT can throw an exception that is not caught within
2839 the current function (CFUN). */
2842 stmt_can_throw_external (gimple stmt
)
2846 if (!stmt_could_throw_p (stmt
))
2849 lp_nr
= lookup_stmt_eh_lp (stmt
);
2853 /* Return true if STMT can throw an exception that is caught within
2854 the current function (CFUN). */
2857 stmt_can_throw_internal (gimple stmt
)
2861 if (!stmt_could_throw_p (stmt
))
2864 lp_nr
= lookup_stmt_eh_lp (stmt
);
2868 /* Given a statement STMT in IFUN, if STMT can no longer throw, then
2869 remove any entry it might have from the EH table. Return true if
2870 any change was made. */
2873 maybe_clean_eh_stmt_fn (struct function
*ifun
, gimple stmt
)
2875 if (stmt_could_throw_p (stmt
))
2877 return remove_stmt_from_eh_lp_fn (ifun
, stmt
);
2880 /* Likewise, but always use the current function. */
2883 maybe_clean_eh_stmt (gimple stmt
)
2885 return maybe_clean_eh_stmt_fn (cfun
, stmt
);
2888 /* Given a statement OLD_STMT and a new statement NEW_STMT that has replaced
2889 OLD_STMT in the function, remove OLD_STMT from the EH table and put NEW_STMT
2890 in the table if it should be in there. Return TRUE if a replacement was
2891 done that my require an EH edge purge. */
2894 maybe_clean_or_replace_eh_stmt (gimple old_stmt
, gimple new_stmt
)
2896 int lp_nr
= lookup_stmt_eh_lp (old_stmt
);
2900 bool new_stmt_could_throw
= stmt_could_throw_p (new_stmt
);
2902 if (new_stmt
== old_stmt
&& new_stmt_could_throw
)
2905 remove_stmt_from_eh_lp (old_stmt
);
2906 if (new_stmt_could_throw
)
2908 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
2918 /* Given a statement OLD_STMT in OLD_FUN and a duplicate statement NEW_STMT
2919 in NEW_FUN, copy the EH table data from OLD_STMT to NEW_STMT. The MAP
2920 operand is the return value of duplicate_eh_regions. */
2923 maybe_duplicate_eh_stmt_fn (struct function
*new_fun
, gimple new_stmt
,
2924 struct function
*old_fun
, gimple old_stmt
,
2925 hash_map
<void *, void *> *map
,
2928 int old_lp_nr
, new_lp_nr
;
2930 if (!stmt_could_throw_p (new_stmt
))
2933 old_lp_nr
= lookup_stmt_eh_lp_fn (old_fun
, old_stmt
);
2936 if (default_lp_nr
== 0)
2938 new_lp_nr
= default_lp_nr
;
2940 else if (old_lp_nr
> 0)
2942 eh_landing_pad old_lp
, new_lp
;
2944 old_lp
= (*old_fun
->eh
->lp_array
)[old_lp_nr
];
2945 new_lp
= static_cast<eh_landing_pad
> (*map
->get (old_lp
));
2946 new_lp_nr
= new_lp
->index
;
2950 eh_region old_r
, new_r
;
2952 old_r
= (*old_fun
->eh
->region_array
)[-old_lp_nr
];
2953 new_r
= static_cast<eh_region
> (*map
->get (old_r
));
2954 new_lp_nr
= -new_r
->index
;
2957 add_stmt_to_eh_lp_fn (new_fun
, new_stmt
, new_lp_nr
);
2961 /* Similar, but both OLD_STMT and NEW_STMT are within the current function,
2962 and thus no remapping is required. */
2965 maybe_duplicate_eh_stmt (gimple new_stmt
, gimple old_stmt
)
2969 if (!stmt_could_throw_p (new_stmt
))
2972 lp_nr
= lookup_stmt_eh_lp (old_stmt
);
2976 add_stmt_to_eh_lp (new_stmt
, lp_nr
);
2980 /* Returns TRUE if oneh and twoh are exception handlers (gimple_try_cleanup of
2981 GIMPLE_TRY) that are similar enough to be considered the same. Currently
2982 this only handles handlers consisting of a single call, as that's the
2983 important case for C++: a destructor call for a particular object showing
2984 up in multiple handlers. */
2987 same_handler_p (gimple_seq oneh
, gimple_seq twoh
)
2989 gimple_stmt_iterator gsi
;
2993 gsi
= gsi_start (oneh
);
2994 if (!gsi_one_before_end_p (gsi
))
2996 ones
= gsi_stmt (gsi
);
2998 gsi
= gsi_start (twoh
);
2999 if (!gsi_one_before_end_p (gsi
))
3001 twos
= gsi_stmt (gsi
);
3003 if (!is_gimple_call (ones
)
3004 || !is_gimple_call (twos
)
3005 || gimple_call_lhs (ones
)
3006 || gimple_call_lhs (twos
)
3007 || gimple_call_chain (ones
)
3008 || gimple_call_chain (twos
)
3009 || !gimple_call_same_target_p (ones
, twos
)
3010 || gimple_call_num_args (ones
) != gimple_call_num_args (twos
))
3013 for (ai
= 0; ai
< gimple_call_num_args (ones
); ++ai
)
3014 if (!operand_equal_p (gimple_call_arg (ones
, ai
),
3015 gimple_call_arg (twos
, ai
), 0))
3022 try { A() } finally { try { ~B() } catch { ~A() } }
3023 try { ... } finally { ~A() }
3025 try { A() } catch { ~B() }
3026 try { ~B() ... } finally { ~A() }
3028 This occurs frequently in C++, where A is a local variable and B is a
3029 temporary used in the initializer for A. */
3032 optimize_double_finally (gimple_try one
, gimple_try two
)
3035 gimple_stmt_iterator gsi
;
3038 cleanup
= gimple_try_cleanup (one
);
3039 gsi
= gsi_start (cleanup
);
3040 if (!gsi_one_before_end_p (gsi
))
3043 oneh
= gsi_stmt (gsi
);
3044 if (gimple_code (oneh
) != GIMPLE_TRY
3045 || gimple_try_kind (oneh
) != GIMPLE_TRY_CATCH
)
3048 if (same_handler_p (gimple_try_cleanup (oneh
), gimple_try_cleanup (two
)))
3050 gimple_seq seq
= gimple_try_eval (oneh
);
3052 gimple_try_set_cleanup (one
, seq
);
3053 gimple_try_set_kind (one
, GIMPLE_TRY_CATCH
);
3054 seq
= copy_gimple_seq_and_replace_locals (seq
);
3055 gimple_seq_add_seq (&seq
, gimple_try_eval (two
));
3056 gimple_try_set_eval (two
, seq
);
3060 /* Perform EH refactoring optimizations that are simpler to do when code
3061 flow has been lowered but EH structures haven't. */
3064 refactor_eh_r (gimple_seq seq
)
3066 gimple_stmt_iterator gsi
;
3071 gsi
= gsi_start (seq
);
3075 if (gsi_end_p (gsi
))
3078 two
= gsi_stmt (gsi
);
3080 if (gimple_try try_one
= dyn_cast
<gimple_try
> (one
))
3081 if (gimple_try try_two
= dyn_cast
<gimple_try
> (two
))
3082 if (gimple_try_kind (try_one
) == GIMPLE_TRY_FINALLY
3083 && gimple_try_kind (try_two
) == GIMPLE_TRY_FINALLY
)
3084 optimize_double_finally (try_one
, try_two
);
3086 switch (gimple_code (one
))
3089 refactor_eh_r (gimple_try_eval (one
));
3090 refactor_eh_r (gimple_try_cleanup (one
));
3093 refactor_eh_r (gimple_catch_handler (as_a
<gimple_catch
> (one
)));
3095 case GIMPLE_EH_FILTER
:
3096 refactor_eh_r (gimple_eh_filter_failure (one
));
3098 case GIMPLE_EH_ELSE
:
3100 gimple_eh_else eh_else_stmt
= as_a
<gimple_eh_else
> (one
);
3101 refactor_eh_r (gimple_eh_else_n_body (eh_else_stmt
));
3102 refactor_eh_r (gimple_eh_else_e_body (eh_else_stmt
));
3117 const pass_data pass_data_refactor_eh
=
3119 GIMPLE_PASS
, /* type */
3121 OPTGROUP_NONE
, /* optinfo_flags */
3122 TV_TREE_EH
, /* tv_id */
3123 PROP_gimple_lcf
, /* properties_required */
3124 0, /* properties_provided */
3125 0, /* properties_destroyed */
3126 0, /* todo_flags_start */
3127 0, /* todo_flags_finish */
3130 class pass_refactor_eh
: public gimple_opt_pass
3133 pass_refactor_eh (gcc::context
*ctxt
)
3134 : gimple_opt_pass (pass_data_refactor_eh
, ctxt
)
3137 /* opt_pass methods: */
3138 virtual bool gate (function
*) { return flag_exceptions
!= 0; }
3139 virtual unsigned int execute (function
*)
3141 refactor_eh_r (gimple_body (current_function_decl
));
3145 }; // class pass_refactor_eh
3150 make_pass_refactor_eh (gcc::context
*ctxt
)
3152 return new pass_refactor_eh (ctxt
);
3155 /* At the end of gimple optimization, we can lower RESX. */
3158 lower_resx (basic_block bb
, gimple_resx stmt
,
3159 hash_map
<eh_region
, tree
> *mnt_map
)
3162 eh_region src_r
, dst_r
;
3163 gimple_stmt_iterator gsi
;
3168 lp_nr
= lookup_stmt_eh_lp (stmt
);
3170 dst_r
= get_eh_region_from_lp_number (lp_nr
);
3174 src_r
= get_eh_region_from_number (gimple_resx_region (stmt
));
3175 gsi
= gsi_last_bb (bb
);
3179 /* We can wind up with no source region when pass_cleanup_eh shows
3180 that there are no entries into an eh region and deletes it, but
3181 then the block that contains the resx isn't removed. This can
3182 happen without optimization when the switch statement created by
3183 lower_try_finally_switch isn't simplified to remove the eh case.
3185 Resolve this by expanding the resx node to an abort. */
3187 fn
= builtin_decl_implicit (BUILT_IN_TRAP
);
3188 x
= gimple_build_call (fn
, 0);
3189 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3191 while (EDGE_COUNT (bb
->succs
) > 0)
3192 remove_edge (EDGE_SUCC (bb
, 0));
3196 /* When we have a destination region, we resolve this by copying
3197 the excptr and filter values into place, and changing the edge
3198 to immediately after the landing pad. */
3206 /* We are resuming into a MUST_NOT_CALL region. Expand a call to
3207 the failure decl into a new block, if needed. */
3208 gcc_assert (dst_r
->type
== ERT_MUST_NOT_THROW
);
3210 tree
*slot
= mnt_map
->get (dst_r
);
3213 gimple_stmt_iterator gsi2
;
3215 new_bb
= create_empty_bb (bb
);
3216 add_bb_to_loop (new_bb
, bb
->loop_father
);
3217 lab
= gimple_block_label (new_bb
);
3218 gsi2
= gsi_start_bb (new_bb
);
3220 fn
= dst_r
->u
.must_not_throw
.failure_decl
;
3221 x
= gimple_build_call (fn
, 0);
3222 gimple_set_location (x
, dst_r
->u
.must_not_throw
.failure_loc
);
3223 gsi_insert_after (&gsi2
, x
, GSI_CONTINUE_LINKING
);
3225 mnt_map
->put (dst_r
, lab
);
3230 new_bb
= label_to_block (lab
);
3233 gcc_assert (EDGE_COUNT (bb
->succs
) == 0);
3234 e
= make_edge (bb
, new_bb
, EDGE_FALLTHRU
);
3235 e
->count
= bb
->count
;
3236 e
->probability
= REG_BR_PROB_BASE
;
3241 tree dst_nr
= build_int_cst (integer_type_node
, dst_r
->index
);
3243 fn
= builtin_decl_implicit (BUILT_IN_EH_COPY_VALUES
);
3244 src_nr
= build_int_cst (integer_type_node
, src_r
->index
);
3245 x
= gimple_build_call (fn
, 2, dst_nr
, src_nr
);
3246 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3248 /* Update the flags for the outgoing edge. */
3249 e
= single_succ_edge (bb
);
3250 gcc_assert (e
->flags
& EDGE_EH
);
3251 e
->flags
= (e
->flags
& ~EDGE_EH
) | EDGE_FALLTHRU
;
3253 /* If there are no more EH users of the landing pad, delete it. */
3254 FOR_EACH_EDGE (e
, ei
, e
->dest
->preds
)
3255 if (e
->flags
& EDGE_EH
)
3259 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
3260 remove_eh_landing_pad (lp
);
3270 /* When we don't have a destination region, this exception escapes
3271 up the call chain. We resolve this by generating a call to the
3272 _Unwind_Resume library function. */
3274 /* The ARM EABI redefines _Unwind_Resume as __cxa_end_cleanup
3275 with no arguments for C++ and Java. Check for that. */
3276 if (src_r
->use_cxa_end_cleanup
)
3278 fn
= builtin_decl_implicit (BUILT_IN_CXA_END_CLEANUP
);
3279 x
= gimple_build_call (fn
, 0);
3280 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3284 fn
= builtin_decl_implicit (BUILT_IN_EH_POINTER
);
3285 src_nr
= build_int_cst (integer_type_node
, src_r
->index
);
3286 x
= gimple_build_call (fn
, 1, src_nr
);
3287 var
= create_tmp_var (ptr_type_node
, NULL
);
3288 var
= make_ssa_name (var
, x
);
3289 gimple_call_set_lhs (x
, var
);
3290 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3292 fn
= builtin_decl_implicit (BUILT_IN_UNWIND_RESUME
);
3293 x
= gimple_build_call (fn
, 1, var
);
3294 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3297 gcc_assert (EDGE_COUNT (bb
->succs
) == 0);
3300 gsi_remove (&gsi
, true);
3307 const pass_data pass_data_lower_resx
=
3309 GIMPLE_PASS
, /* type */
3311 OPTGROUP_NONE
, /* optinfo_flags */
3312 TV_TREE_EH
, /* tv_id */
3313 PROP_gimple_lcf
, /* properties_required */
3314 0, /* properties_provided */
3315 0, /* properties_destroyed */
3316 0, /* todo_flags_start */
3317 0, /* todo_flags_finish */
3320 class pass_lower_resx
: public gimple_opt_pass
3323 pass_lower_resx (gcc::context
*ctxt
)
3324 : gimple_opt_pass (pass_data_lower_resx
, ctxt
)
3327 /* opt_pass methods: */
3328 virtual bool gate (function
*) { return flag_exceptions
!= 0; }
3329 virtual unsigned int execute (function
*);
3331 }; // class pass_lower_resx
3334 pass_lower_resx::execute (function
*fun
)
3337 bool dominance_invalidated
= false;
3338 bool any_rewritten
= false;
3340 hash_map
<eh_region
, tree
> mnt_map
;
3342 FOR_EACH_BB_FN (bb
, fun
)
3344 gimple last
= last_stmt (bb
);
3345 if (last
&& is_gimple_resx (last
))
3347 dominance_invalidated
|=
3348 lower_resx (bb
, as_a
<gimple_resx
> (last
), &mnt_map
);
3349 any_rewritten
= true;
3353 if (dominance_invalidated
)
3355 free_dominance_info (CDI_DOMINATORS
);
3356 free_dominance_info (CDI_POST_DOMINATORS
);
3359 return any_rewritten
? TODO_update_ssa_only_virtuals
: 0;
3365 make_pass_lower_resx (gcc::context
*ctxt
)
3367 return new pass_lower_resx (ctxt
);
3370 /* Try to optimize var = {v} {CLOBBER} stmts followed just by
3374 optimize_clobbers (basic_block bb
)
3376 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
3377 bool any_clobbers
= false;
3378 bool seen_stack_restore
= false;
3382 /* Only optimize anything if the bb contains at least one clobber,
3383 ends with resx (checked by caller), optionally contains some
3384 debug stmts or labels, or at most one __builtin_stack_restore
3385 call, and has an incoming EH edge. */
3386 for (gsi_prev (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
3388 gimple stmt
= gsi_stmt (gsi
);
3389 if (is_gimple_debug (stmt
))
3391 if (gimple_clobber_p (stmt
))
3393 any_clobbers
= true;
3396 if (!seen_stack_restore
3397 && gimple_call_builtin_p (stmt
, BUILT_IN_STACK_RESTORE
))
3399 seen_stack_restore
= true;
3402 if (gimple_code (stmt
) == GIMPLE_LABEL
)
3408 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
3409 if (e
->flags
& EDGE_EH
)
3413 gsi
= gsi_last_bb (bb
);
3414 for (gsi_prev (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
3416 gimple stmt
= gsi_stmt (gsi
);
3417 if (!gimple_clobber_p (stmt
))
3419 unlink_stmt_vdef (stmt
);
3420 gsi_remove (&gsi
, true);
3421 release_defs (stmt
);
3425 /* Try to sink var = {v} {CLOBBER} stmts followed just by
3426 internal throw to successor BB. */
3429 sink_clobbers (basic_block bb
)
3433 gimple_stmt_iterator gsi
, dgsi
;
3435 bool any_clobbers
= false;
3438 /* Only optimize if BB has a single EH successor and
3439 all predecessor edges are EH too. */
3440 if (!single_succ_p (bb
)
3441 || (single_succ_edge (bb
)->flags
& EDGE_EH
) == 0)
3444 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
3446 if ((e
->flags
& EDGE_EH
) == 0)
3450 /* And BB contains only CLOBBER stmts before the final
3452 gsi
= gsi_last_bb (bb
);
3453 for (gsi_prev (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
3455 gimple stmt
= gsi_stmt (gsi
);
3456 if (is_gimple_debug (stmt
))
3458 if (gimple_code (stmt
) == GIMPLE_LABEL
)
3460 if (!gimple_clobber_p (stmt
))
3462 any_clobbers
= true;
3467 edge succe
= single_succ_edge (bb
);
3468 succbb
= succe
->dest
;
3470 /* See if there is a virtual PHI node to take an updated virtual
3473 tree vuse
= NULL_TREE
;
3474 for (gsi
= gsi_start_phis (succbb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3476 tree res
= gimple_phi_result (gsi_stmt (gsi
));
3477 if (virtual_operand_p (res
))
3479 vphi
= gsi_stmt (gsi
);
3485 dgsi
= gsi_after_labels (succbb
);
3486 gsi
= gsi_last_bb (bb
);
3487 for (gsi_prev (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
3489 gimple stmt
= gsi_stmt (gsi
);
3491 if (is_gimple_debug (stmt
))
3493 if (gimple_code (stmt
) == GIMPLE_LABEL
)
3495 lhs
= gimple_assign_lhs (stmt
);
3496 /* Unfortunately we don't have dominance info updated at this
3497 point, so checking if
3498 dominated_by_p (CDI_DOMINATORS, succbb,
3499 gimple_bb (SSA_NAME_DEF_STMT (TREE_OPERAND (lhs, 0)))
3500 would be too costly. Thus, avoid sinking any clobbers that
3501 refer to non-(D) SSA_NAMEs. */
3502 if (TREE_CODE (lhs
) == MEM_REF
3503 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
3504 && !SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (lhs
, 0)))
3506 unlink_stmt_vdef (stmt
);
3507 gsi_remove (&gsi
, true);
3508 release_defs (stmt
);
3512 /* As we do not change stmt order when sinking across a
3513 forwarder edge we can keep virtual operands in place. */
3514 gsi_remove (&gsi
, false);
3515 gsi_insert_before (&dgsi
, stmt
, GSI_NEW_STMT
);
3517 /* But adjust virtual operands if we sunk across a PHI node. */
3521 imm_use_iterator iter
;
3522 use_operand_p use_p
;
3523 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, vuse
)
3524 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
3525 SET_USE (use_p
, gimple_vdef (stmt
));
3526 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vuse
))
3528 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vdef (stmt
)) = 1;
3529 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vuse
) = 0;
3531 /* Adjust the incoming virtual operand. */
3532 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (vphi
, succe
), gimple_vuse (stmt
));
3533 SET_USE (gimple_vuse_op (stmt
), vuse
);
3535 /* If there isn't a single predecessor but no virtual PHI node
3536 arrange for virtual operands to be renamed. */
3537 else if (gimple_vuse_op (stmt
) != NULL_USE_OPERAND_P
3538 && !single_pred_p (succbb
))
3540 /* In this case there will be no use of the VDEF of this stmt.
3541 ??? Unless this is a secondary opportunity and we have not
3542 removed unreachable blocks yet, so we cannot assert this.
3543 Which also means we will end up renaming too many times. */
3544 SET_USE (gimple_vuse_op (stmt
), gimple_vop (cfun
));
3545 mark_virtual_operands_for_renaming (cfun
);
3546 todo
|= TODO_update_ssa_only_virtuals
;
3553 /* At the end of inlining, we can lower EH_DISPATCH. Return true when
3554 we have found some duplicate labels and removed some edges. */
3557 lower_eh_dispatch (basic_block src
, gimple_eh_dispatch stmt
)
3559 gimple_stmt_iterator gsi
;
3564 bool redirected
= false;
3566 region_nr
= gimple_eh_dispatch_region (stmt
);
3567 r
= get_eh_region_from_number (region_nr
);
3569 gsi
= gsi_last_bb (src
);
3575 auto_vec
<tree
> labels
;
3576 tree default_label
= NULL
;
3580 hash_set
<tree
> seen_values
;
3582 /* Collect the labels for a switch. Zero the post_landing_pad
3583 field becase we'll no longer have anything keeping these labels
3584 in existence and the optimizer will be free to merge these
3586 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3588 tree tp_node
, flt_node
, lab
= c
->label
;
3589 bool have_label
= false;
3592 tp_node
= c
->type_list
;
3593 flt_node
= c
->filter_list
;
3595 if (tp_node
== NULL
)
3597 default_label
= lab
;
3602 /* Filter out duplicate labels that arise when this handler
3603 is shadowed by an earlier one. When no labels are
3604 attached to the handler anymore, we remove
3605 the corresponding edge and then we delete unreachable
3606 blocks at the end of this pass. */
3607 if (! seen_values
.contains (TREE_VALUE (flt_node
)))
3609 tree t
= build_case_label (TREE_VALUE (flt_node
),
3611 labels
.safe_push (t
);
3612 seen_values
.add (TREE_VALUE (flt_node
));
3616 tp_node
= TREE_CHAIN (tp_node
);
3617 flt_node
= TREE_CHAIN (flt_node
);
3622 remove_edge (find_edge (src
, label_to_block (lab
)));
3627 /* Clean up the edge flags. */
3628 FOR_EACH_EDGE (e
, ei
, src
->succs
)
3630 if (e
->flags
& EDGE_FALLTHRU
)
3632 /* If there was no catch-all, use the fallthru edge. */
3633 if (default_label
== NULL
)
3634 default_label
= gimple_block_label (e
->dest
);
3635 e
->flags
&= ~EDGE_FALLTHRU
;
3638 gcc_assert (default_label
!= NULL
);
3640 /* Don't generate a switch if there's only a default case.
3641 This is common in the form of try { A; } catch (...) { B; }. */
3642 if (!labels
.exists ())
3644 e
= single_succ_edge (src
);
3645 e
->flags
|= EDGE_FALLTHRU
;
3649 fn
= builtin_decl_implicit (BUILT_IN_EH_FILTER
);
3650 x
= gimple_build_call (fn
, 1, build_int_cst (integer_type_node
,
3652 filter
= create_tmp_var (TREE_TYPE (TREE_TYPE (fn
)), NULL
);
3653 filter
= make_ssa_name (filter
, x
);
3654 gimple_call_set_lhs (x
, filter
);
3655 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3657 /* Turn the default label into a default case. */
3658 default_label
= build_case_label (NULL
, NULL
, default_label
);
3659 sort_case_labels (labels
);
3661 x
= gimple_build_switch (filter
, default_label
, labels
);
3662 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3667 case ERT_ALLOWED_EXCEPTIONS
:
3669 edge b_e
= BRANCH_EDGE (src
);
3670 edge f_e
= FALLTHRU_EDGE (src
);
3672 fn
= builtin_decl_implicit (BUILT_IN_EH_FILTER
);
3673 x
= gimple_build_call (fn
, 1, build_int_cst (integer_type_node
,
3675 filter
= create_tmp_var (TREE_TYPE (TREE_TYPE (fn
)), NULL
);
3676 filter
= make_ssa_name (filter
, x
);
3677 gimple_call_set_lhs (x
, filter
);
3678 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3680 r
->u
.allowed
.label
= NULL
;
3681 x
= gimple_build_cond (EQ_EXPR
, filter
,
3682 build_int_cst (TREE_TYPE (filter
),
3683 r
->u
.allowed
.filter
),
3684 NULL_TREE
, NULL_TREE
);
3685 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3687 b_e
->flags
= b_e
->flags
| EDGE_TRUE_VALUE
;
3688 f_e
->flags
= (f_e
->flags
& ~EDGE_FALLTHRU
) | EDGE_FALSE_VALUE
;
3696 /* Replace the EH_DISPATCH with the SWITCH or COND generated above. */
3697 gsi_remove (&gsi
, true);
3703 const pass_data pass_data_lower_eh_dispatch
=
3705 GIMPLE_PASS
, /* type */
3706 "ehdisp", /* name */
3707 OPTGROUP_NONE
, /* optinfo_flags */
3708 TV_TREE_EH
, /* tv_id */
3709 PROP_gimple_lcf
, /* properties_required */
3710 0, /* properties_provided */
3711 0, /* properties_destroyed */
3712 0, /* todo_flags_start */
3713 0, /* todo_flags_finish */
3716 class pass_lower_eh_dispatch
: public gimple_opt_pass
3719 pass_lower_eh_dispatch (gcc::context
*ctxt
)
3720 : gimple_opt_pass (pass_data_lower_eh_dispatch
, ctxt
)
3723 /* opt_pass methods: */
3724 virtual bool gate (function
*fun
) { return fun
->eh
->region_tree
!= NULL
; }
3725 virtual unsigned int execute (function
*);
3727 }; // class pass_lower_eh_dispatch
3730 pass_lower_eh_dispatch::execute (function
*fun
)
3734 bool redirected
= false;
3736 assign_filter_values ();
3738 FOR_EACH_BB_FN (bb
, fun
)
3740 gimple last
= last_stmt (bb
);
3743 if (gimple_code (last
) == GIMPLE_EH_DISPATCH
)
3745 redirected
|= lower_eh_dispatch (bb
,
3746 as_a
<gimple_eh_dispatch
> (last
));
3747 flags
|= TODO_update_ssa_only_virtuals
;
3749 else if (gimple_code (last
) == GIMPLE_RESX
)
3751 if (stmt_can_throw_external (last
))
3752 optimize_clobbers (bb
);
3754 flags
|= sink_clobbers (bb
);
3759 delete_unreachable_blocks ();
3766 make_pass_lower_eh_dispatch (gcc::context
*ctxt
)
3768 return new pass_lower_eh_dispatch (ctxt
);
3771 /* Walk statements, see what regions and, optionally, landing pads
3772 are really referenced.
3774 Returns in R_REACHABLEP an sbitmap with bits set for reachable regions,
3775 and in LP_REACHABLE an sbitmap with bits set for reachable landing pads.
3777 Passing NULL for LP_REACHABLE is valid, in this case only reachable
3780 The caller is responsible for freeing the returned sbitmaps. */
3783 mark_reachable_handlers (sbitmap
*r_reachablep
, sbitmap
*lp_reachablep
)
3785 sbitmap r_reachable
, lp_reachable
;
3787 bool mark_landing_pads
= (lp_reachablep
!= NULL
);
3788 gcc_checking_assert (r_reachablep
!= NULL
);
3790 r_reachable
= sbitmap_alloc (cfun
->eh
->region_array
->length ());
3791 bitmap_clear (r_reachable
);
3792 *r_reachablep
= r_reachable
;
3794 if (mark_landing_pads
)
3796 lp_reachable
= sbitmap_alloc (cfun
->eh
->lp_array
->length ());
3797 bitmap_clear (lp_reachable
);
3798 *lp_reachablep
= lp_reachable
;
3801 lp_reachable
= NULL
;
3803 FOR_EACH_BB_FN (bb
, cfun
)
3805 gimple_stmt_iterator gsi
;
3807 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3809 gimple stmt
= gsi_stmt (gsi
);
3811 if (mark_landing_pads
)
3813 int lp_nr
= lookup_stmt_eh_lp (stmt
);
3815 /* Negative LP numbers are MUST_NOT_THROW regions which
3816 are not considered BB enders. */
3818 bitmap_set_bit (r_reachable
, -lp_nr
);
3820 /* Positive LP numbers are real landing pads, and BB enders. */
3823 gcc_assert (gsi_one_before_end_p (gsi
));
3824 eh_region region
= get_eh_region_from_lp_number (lp_nr
);
3825 bitmap_set_bit (r_reachable
, region
->index
);
3826 bitmap_set_bit (lp_reachable
, lp_nr
);
3830 /* Avoid removing regions referenced from RESX/EH_DISPATCH. */
3831 switch (gimple_code (stmt
))
3834 bitmap_set_bit (r_reachable
,
3835 gimple_resx_region (as_a
<gimple_resx
> (stmt
)));
3837 case GIMPLE_EH_DISPATCH
:
3838 bitmap_set_bit (r_reachable
,
3839 gimple_eh_dispatch_region (
3840 as_a
<gimple_eh_dispatch
> (stmt
)));
3849 /* Remove unreachable handlers and unreachable landing pads. */
3852 remove_unreachable_handlers (void)
3854 sbitmap r_reachable
, lp_reachable
;
3859 mark_reachable_handlers (&r_reachable
, &lp_reachable
);
3863 fprintf (dump_file
, "Before removal of unreachable regions:\n");
3864 dump_eh_tree (dump_file
, cfun
);
3865 fprintf (dump_file
, "Reachable regions: ");
3866 dump_bitmap_file (dump_file
, r_reachable
);
3867 fprintf (dump_file
, "Reachable landing pads: ");
3868 dump_bitmap_file (dump_file
, lp_reachable
);
3873 FOR_EACH_VEC_SAFE_ELT (cfun
->eh
->region_array
, i
, region
)
3874 if (region
&& !bitmap_bit_p (r_reachable
, region
->index
))
3876 "Removing unreachable region %d\n",
3880 remove_unreachable_eh_regions (r_reachable
);
3882 FOR_EACH_VEC_SAFE_ELT (cfun
->eh
->lp_array
, i
, lp
)
3883 if (lp
&& !bitmap_bit_p (lp_reachable
, lp
->index
))
3887 "Removing unreachable landing pad %d\n",
3889 remove_eh_landing_pad (lp
);
3894 fprintf (dump_file
, "\n\nAfter removal of unreachable regions:\n");
3895 dump_eh_tree (dump_file
, cfun
);
3896 fprintf (dump_file
, "\n\n");
3899 sbitmap_free (r_reachable
);
3900 sbitmap_free (lp_reachable
);
3902 #ifdef ENABLE_CHECKING
3903 verify_eh_tree (cfun
);
3907 /* Remove unreachable handlers if any landing pads have been removed after
3908 last ehcleanup pass (due to gimple_purge_dead_eh_edges). */
3911 maybe_remove_unreachable_handlers (void)
3916 if (cfun
->eh
== NULL
)
3919 FOR_EACH_VEC_SAFE_ELT (cfun
->eh
->lp_array
, i
, lp
)
3920 if (lp
&& lp
->post_landing_pad
)
3922 if (label_to_block (lp
->post_landing_pad
) == NULL
)
3924 remove_unreachable_handlers ();
3930 /* Remove regions that do not have landing pads. This assumes
3931 that remove_unreachable_handlers has already been run, and
3932 that we've just manipulated the landing pads since then.
3934 Preserve regions with landing pads and regions that prevent
3935 exceptions from propagating further, even if these regions
3936 are not reachable. */
3939 remove_unreachable_handlers_no_lp (void)
3942 sbitmap r_reachable
;
3945 mark_reachable_handlers (&r_reachable
, /*lp_reachablep=*/NULL
);
3947 FOR_EACH_VEC_SAFE_ELT (cfun
->eh
->region_array
, i
, region
)
3952 if (region
->landing_pads
!= NULL
3953 || region
->type
== ERT_MUST_NOT_THROW
)
3954 bitmap_set_bit (r_reachable
, region
->index
);
3957 && !bitmap_bit_p (r_reachable
, region
->index
))
3959 "Removing unreachable region %d\n",
3963 remove_unreachable_eh_regions (r_reachable
);
3965 sbitmap_free (r_reachable
);
3968 /* Undo critical edge splitting on an EH landing pad. Earlier, we
3969 optimisticaly split all sorts of edges, including EH edges. The
3970 optimization passes in between may not have needed them; if not,
3971 we should undo the split.
3973 Recognize this case by having one EH edge incoming to the BB and
3974 one normal edge outgoing; BB should be empty apart from the
3975 post_landing_pad label.
3977 Note that this is slightly different from the empty handler case
3978 handled by cleanup_empty_eh, in that the actual handler may yet
3979 have actual code but the landing pad has been separated from the
3980 handler. As such, cleanup_empty_eh relies on this transformation
3981 having been done first. */
3984 unsplit_eh (eh_landing_pad lp
)
3986 basic_block bb
= label_to_block (lp
->post_landing_pad
);
3987 gimple_stmt_iterator gsi
;
3990 /* Quickly check the edge counts on BB for singularity. */
3991 if (!single_pred_p (bb
) || !single_succ_p (bb
))
3993 e_in
= single_pred_edge (bb
);
3994 e_out
= single_succ_edge (bb
);
3996 /* Input edge must be EH and output edge must be normal. */
3997 if ((e_in
->flags
& EDGE_EH
) == 0 || (e_out
->flags
& EDGE_EH
) != 0)
4000 /* The block must be empty except for the labels and debug insns. */
4001 gsi
= gsi_after_labels (bb
);
4002 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
4003 gsi_next_nondebug (&gsi
);
4004 if (!gsi_end_p (gsi
))
4007 /* The destination block must not already have a landing pad
4008 for a different region. */
4009 for (gsi
= gsi_start_bb (e_out
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4011 gimple_label label_stmt
= dyn_cast
<gimple_label
> (gsi_stmt (gsi
));
4017 lab
= gimple_label_label (label_stmt
);
4018 lp_nr
= EH_LANDING_PAD_NR (lab
);
4019 if (lp_nr
&& get_eh_region_from_lp_number (lp_nr
) != lp
->region
)
4023 /* The new destination block must not already be a destination of
4024 the source block, lest we merge fallthru and eh edges and get
4025 all sorts of confused. */
4026 if (find_edge (e_in
->src
, e_out
->dest
))
4029 /* ??? We can get degenerate phis due to cfg cleanups. I would have
4030 thought this should have been cleaned up by a phicprop pass, but
4031 that doesn't appear to handle virtuals. Propagate by hand. */
4032 if (!gimple_seq_empty_p (phi_nodes (bb
)))
4034 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); )
4036 gimple use_stmt
, phi
= gsi_stmt (gsi
);
4037 tree lhs
= gimple_phi_result (phi
);
4038 tree rhs
= gimple_phi_arg_def (phi
, 0);
4039 use_operand_p use_p
;
4040 imm_use_iterator iter
;
4042 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, lhs
)
4044 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
4045 SET_USE (use_p
, rhs
);
4048 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs
))
4049 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs
) = 1;
4051 remove_phi_node (&gsi
, true);
4055 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4056 fprintf (dump_file
, "Unsplit EH landing pad %d to block %i.\n",
4057 lp
->index
, e_out
->dest
->index
);
4059 /* Redirect the edge. Since redirect_eh_edge_1 expects to be moving
4060 a successor edge, humor it. But do the real CFG change with the
4061 predecessor of E_OUT in order to preserve the ordering of arguments
4062 to the PHI nodes in E_OUT->DEST. */
4063 redirect_eh_edge_1 (e_in
, e_out
->dest
, false);
4064 redirect_edge_pred (e_out
, e_in
->src
);
4065 e_out
->flags
= e_in
->flags
;
4066 e_out
->probability
= e_in
->probability
;
4067 e_out
->count
= e_in
->count
;
4073 /* Examine each landing pad block and see if it matches unsplit_eh. */
4076 unsplit_all_eh (void)
4078 bool changed
= false;
4082 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
4084 changed
|= unsplit_eh (lp
);
4089 /* A subroutine of cleanup_empty_eh. Redirect all EH edges incoming
4090 to OLD_BB to NEW_BB; return true on success, false on failure.
4092 OLD_BB_OUT is the edge into NEW_BB from OLD_BB, so if we miss any
4093 PHI variables from OLD_BB we can pick them up from OLD_BB_OUT.
4094 Virtual PHIs may be deleted and marked for renaming. */
4097 cleanup_empty_eh_merge_phis (basic_block new_bb
, basic_block old_bb
,
4098 edge old_bb_out
, bool change_region
)
4100 gimple_phi_iterator ngsi
, ogsi
;
4103 bitmap ophi_handled
;
4105 /* The destination block must not be a regular successor for any
4106 of the preds of the landing pad. Thus, avoid turning
4116 which CFG verification would choke on. See PR45172 and PR51089. */
4117 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4118 if (find_edge (e
->src
, new_bb
))
4121 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4122 redirect_edge_var_map_clear (e
);
4124 ophi_handled
= BITMAP_ALLOC (NULL
);
4126 /* First, iterate through the PHIs on NEW_BB and set up the edge_var_map
4127 for the edges we're going to move. */
4128 for (ngsi
= gsi_start_phis (new_bb
); !gsi_end_p (ngsi
); gsi_next (&ngsi
))
4130 gimple_phi ophi
, nphi
= ngsi
.phi ();
4133 nresult
= gimple_phi_result (nphi
);
4134 nop
= gimple_phi_arg_def (nphi
, old_bb_out
->dest_idx
);
4136 /* Find the corresponding PHI in OLD_BB so we can forward-propagate
4137 the source ssa_name. */
4139 for (ogsi
= gsi_start_phis (old_bb
); !gsi_end_p (ogsi
); gsi_next (&ogsi
))
4142 if (gimple_phi_result (ophi
) == nop
)
4147 /* If we did find the corresponding PHI, copy those inputs. */
4150 /* If NOP is used somewhere else beyond phis in new_bb, give up. */
4151 if (!has_single_use (nop
))
4153 imm_use_iterator imm_iter
;
4154 use_operand_p use_p
;
4156 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, nop
)
4158 if (!gimple_debug_bind_p (USE_STMT (use_p
))
4159 && (gimple_code (USE_STMT (use_p
)) != GIMPLE_PHI
4160 || gimple_bb (USE_STMT (use_p
)) != new_bb
))
4164 bitmap_set_bit (ophi_handled
, SSA_NAME_VERSION (nop
));
4165 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4170 if ((e
->flags
& EDGE_EH
) == 0)
4172 oop
= gimple_phi_arg_def (ophi
, e
->dest_idx
);
4173 oloc
= gimple_phi_arg_location (ophi
, e
->dest_idx
);
4174 redirect_edge_var_map_add (e
, nresult
, oop
, oloc
);
4177 /* If we didn't find the PHI, if it's a real variable or a VOP, we know
4178 from the fact that OLD_BB is tree_empty_eh_handler_p that the
4179 variable is unchanged from input to the block and we can simply
4180 re-use the input to NEW_BB from the OLD_BB_OUT edge. */
4184 = gimple_phi_arg_location (nphi
, old_bb_out
->dest_idx
);
4185 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4186 redirect_edge_var_map_add (e
, nresult
, nop
, nloc
);
4190 /* Second, verify that all PHIs from OLD_BB have been handled. If not,
4191 we don't know what values from the other edges into NEW_BB to use. */
4192 for (ogsi
= gsi_start_phis (old_bb
); !gsi_end_p (ogsi
); gsi_next (&ogsi
))
4194 gimple ophi
= gsi_stmt (ogsi
);
4195 tree oresult
= gimple_phi_result (ophi
);
4196 if (!bitmap_bit_p (ophi_handled
, SSA_NAME_VERSION (oresult
)))
4200 /* Finally, move the edges and update the PHIs. */
4201 for (ei
= ei_start (old_bb
->preds
); (e
= ei_safe_edge (ei
)); )
4202 if (e
->flags
& EDGE_EH
)
4204 /* ??? CFG manipluation routines do not try to update loop
4205 form on edge redirection. Do so manually here for now. */
4206 /* If we redirect a loop entry or latch edge that will either create
4207 a multiple entry loop or rotate the loop. If the loops merge
4208 we may have created a loop with multiple latches.
4209 All of this isn't easily fixed thus cancel the affected loop
4210 and mark the other loop as possibly having multiple latches. */
4211 if (e
->dest
== e
->dest
->loop_father
->header
)
4213 mark_loop_for_removal (e
->dest
->loop_father
);
4214 new_bb
->loop_father
->latch
= NULL
;
4215 loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES
);
4217 redirect_eh_edge_1 (e
, new_bb
, change_region
);
4218 redirect_edge_succ (e
, new_bb
);
4219 flush_pending_stmts (e
);
4224 BITMAP_FREE (ophi_handled
);
4228 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4229 redirect_edge_var_map_clear (e
);
4230 BITMAP_FREE (ophi_handled
);
4234 /* A subroutine of cleanup_empty_eh. Move a landing pad LP from its
4235 old region to NEW_REGION at BB. */
4238 cleanup_empty_eh_move_lp (basic_block bb
, edge e_out
,
4239 eh_landing_pad lp
, eh_region new_region
)
4241 gimple_stmt_iterator gsi
;
4244 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
4248 lp
->region
= new_region
;
4249 lp
->next_lp
= new_region
->landing_pads
;
4250 new_region
->landing_pads
= lp
;
4252 /* Delete the RESX that was matched within the empty handler block. */
4253 gsi
= gsi_last_bb (bb
);
4254 unlink_stmt_vdef (gsi_stmt (gsi
));
4255 gsi_remove (&gsi
, true);
4257 /* Clean up E_OUT for the fallthru. */
4258 e_out
->flags
= (e_out
->flags
& ~EDGE_EH
) | EDGE_FALLTHRU
;
4259 e_out
->probability
= REG_BR_PROB_BASE
;
4262 /* A subroutine of cleanup_empty_eh. Handle more complex cases of
4263 unsplitting than unsplit_eh was prepared to handle, e.g. when
4264 multiple incoming edges and phis are involved. */
4267 cleanup_empty_eh_unsplit (basic_block bb
, edge e_out
, eh_landing_pad lp
)
4269 gimple_stmt_iterator gsi
;
4272 /* We really ought not have totally lost everything following
4273 a landing pad label. Given that BB is empty, there had better
4275 gcc_assert (e_out
!= NULL
);
4277 /* The destination block must not already have a landing pad
4278 for a different region. */
4280 for (gsi
= gsi_start_bb (e_out
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4282 gimple_label stmt
= dyn_cast
<gimple_label
> (gsi_stmt (gsi
));
4287 lab
= gimple_label_label (stmt
);
4288 lp_nr
= EH_LANDING_PAD_NR (lab
);
4289 if (lp_nr
&& get_eh_region_from_lp_number (lp_nr
) != lp
->region
)
4293 /* Attempt to move the PHIs into the successor block. */
4294 if (cleanup_empty_eh_merge_phis (e_out
->dest
, bb
, e_out
, false))
4296 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4298 "Unsplit EH landing pad %d to block %i "
4299 "(via cleanup_empty_eh).\n",
4300 lp
->index
, e_out
->dest
->index
);
4307 /* Return true if edge E_FIRST is part of an empty infinite loop
4308 or leads to such a loop through a series of single successor
4312 infinite_empty_loop_p (edge e_first
)
4314 bool inf_loop
= false;
4317 if (e_first
->dest
== e_first
->src
)
4320 e_first
->src
->aux
= (void *) 1;
4321 for (e
= e_first
; single_succ_p (e
->dest
); e
= single_succ_edge (e
->dest
))
4323 gimple_stmt_iterator gsi
;
4329 e
->dest
->aux
= (void *) 1;
4330 gsi
= gsi_after_labels (e
->dest
);
4331 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
4332 gsi_next_nondebug (&gsi
);
4333 if (!gsi_end_p (gsi
))
4336 e_first
->src
->aux
= NULL
;
4337 for (e
= e_first
; e
->dest
->aux
; e
= single_succ_edge (e
->dest
))
4338 e
->dest
->aux
= NULL
;
4343 /* Examine the block associated with LP to determine if it's an empty
4344 handler for its EH region. If so, attempt to redirect EH edges to
4345 an outer region. Return true the CFG was updated in any way. This
4346 is similar to jump forwarding, just across EH edges. */
4349 cleanup_empty_eh (eh_landing_pad lp
)
4351 basic_block bb
= label_to_block (lp
->post_landing_pad
);
4352 gimple_stmt_iterator gsi
;
4354 eh_region new_region
;
4357 bool has_non_eh_pred
;
4361 /* There can be zero or one edges out of BB. This is the quickest test. */
4362 switch (EDGE_COUNT (bb
->succs
))
4368 e_out
= single_succ_edge (bb
);
4374 resx
= last_stmt (bb
);
4375 if (resx
&& is_gimple_resx (resx
))
4377 if (stmt_can_throw_external (resx
))
4378 optimize_clobbers (bb
);
4379 else if (sink_clobbers (bb
))
4383 gsi
= gsi_after_labels (bb
);
4385 /* Make sure to skip debug statements. */
4386 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
4387 gsi_next_nondebug (&gsi
);
4389 /* If the block is totally empty, look for more unsplitting cases. */
4390 if (gsi_end_p (gsi
))
4392 /* For the degenerate case of an infinite loop bail out.
4393 If bb has no successors and is totally empty, which can happen e.g.
4394 because of incorrect noreturn attribute, bail out too. */
4396 || infinite_empty_loop_p (e_out
))
4399 return ret
| cleanup_empty_eh_unsplit (bb
, e_out
, lp
);
4402 /* The block should consist only of a single RESX statement, modulo a
4403 preceding call to __builtin_stack_restore if there is no outgoing
4404 edge, since the call can be eliminated in this case. */
4405 resx
= gsi_stmt (gsi
);
4406 if (!e_out
&& gimple_call_builtin_p (resx
, BUILT_IN_STACK_RESTORE
))
4409 resx
= gsi_stmt (gsi
);
4411 if (!is_gimple_resx (resx
))
4413 gcc_assert (gsi_one_before_end_p (gsi
));
4415 /* Determine if there are non-EH edges, or resx edges into the handler. */
4416 has_non_eh_pred
= false;
4417 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
4418 if (!(e
->flags
& EDGE_EH
))
4419 has_non_eh_pred
= true;
4421 /* Find the handler that's outer of the empty handler by looking at
4422 where the RESX instruction was vectored. */
4423 new_lp_nr
= lookup_stmt_eh_lp (resx
);
4424 new_region
= get_eh_region_from_lp_number (new_lp_nr
);
4426 /* If there's no destination region within the current function,
4427 redirection is trivial via removing the throwing statements from
4428 the EH region, removing the EH edges, and allowing the block
4429 to go unreachable. */
4430 if (new_region
== NULL
)
4432 gcc_assert (e_out
== NULL
);
4433 for (ei
= ei_start (bb
->preds
); (e
= ei_safe_edge (ei
)); )
4434 if (e
->flags
& EDGE_EH
)
4436 gimple stmt
= last_stmt (e
->src
);
4437 remove_stmt_from_eh_lp (stmt
);
4445 /* If the destination region is a MUST_NOT_THROW, allow the runtime
4446 to handle the abort and allow the blocks to go unreachable. */
4447 if (new_region
->type
== ERT_MUST_NOT_THROW
)
4449 for (ei
= ei_start (bb
->preds
); (e
= ei_safe_edge (ei
)); )
4450 if (e
->flags
& EDGE_EH
)
4452 gimple stmt
= last_stmt (e
->src
);
4453 remove_stmt_from_eh_lp (stmt
);
4454 add_stmt_to_eh_lp (stmt
, new_lp_nr
);
4462 /* Try to redirect the EH edges and merge the PHIs into the destination
4463 landing pad block. If the merge succeeds, we'll already have redirected
4464 all the EH edges. The handler itself will go unreachable if there were
4466 if (cleanup_empty_eh_merge_phis (e_out
->dest
, bb
, e_out
, true))
4469 /* Finally, if all input edges are EH edges, then we can (potentially)
4470 reduce the number of transfers from the runtime by moving the landing
4471 pad from the original region to the new region. This is a win when
4472 we remove the last CLEANUP region along a particular exception
4473 propagation path. Since nothing changes except for the region with
4474 which the landing pad is associated, the PHI nodes do not need to be
4476 if (!has_non_eh_pred
)
4478 cleanup_empty_eh_move_lp (bb
, e_out
, lp
, new_region
);
4479 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4480 fprintf (dump_file
, "Empty EH handler %i moved to EH region %i.\n",
4481 lp
->index
, new_region
->index
);
4483 /* ??? The CFG didn't change, but we may have rendered the
4484 old EH region unreachable. Trigger a cleanup there. */
4491 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4492 fprintf (dump_file
, "Empty EH handler %i removed.\n", lp
->index
);
4493 remove_eh_landing_pad (lp
);
4497 /* Do a post-order traversal of the EH region tree. Examine each
4498 post_landing_pad block and see if we can eliminate it as empty. */
4501 cleanup_all_empty_eh (void)
4503 bool changed
= false;
4507 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
4509 changed
|= cleanup_empty_eh (lp
);
4514 /* Perform cleanups and lowering of exception handling
4515 1) cleanups regions with handlers doing nothing are optimized out
4516 2) MUST_NOT_THROW regions that became dead because of 1) are optimized out
4517 3) Info about regions that are containing instructions, and regions
4518 reachable via local EH edges is collected
4519 4) Eh tree is pruned for regions no longer necessary.
4521 TODO: Push MUST_NOT_THROW regions to the root of the EH tree.
4522 Unify those that have the same failure decl and locus.
4526 execute_cleanup_eh_1 (void)
4528 /* Do this first: unsplit_all_eh and cleanup_all_empty_eh can die
4529 looking up unreachable landing pads. */
4530 remove_unreachable_handlers ();
4532 /* Watch out for the region tree vanishing due to all unreachable. */
4533 if (cfun
->eh
->region_tree
)
4535 bool changed
= false;
4538 changed
|= unsplit_all_eh ();
4539 changed
|= cleanup_all_empty_eh ();
4543 free_dominance_info (CDI_DOMINATORS
);
4544 free_dominance_info (CDI_POST_DOMINATORS
);
4546 /* We delayed all basic block deletion, as we may have performed
4547 cleanups on EH edges while non-EH edges were still present. */
4548 delete_unreachable_blocks ();
4550 /* We manipulated the landing pads. Remove any region that no
4551 longer has a landing pad. */
4552 remove_unreachable_handlers_no_lp ();
4554 return TODO_cleanup_cfg
| TODO_update_ssa_only_virtuals
;
4563 const pass_data pass_data_cleanup_eh
=
4565 GIMPLE_PASS
, /* type */
4566 "ehcleanup", /* name */
4567 OPTGROUP_NONE
, /* optinfo_flags */
4568 TV_TREE_EH
, /* tv_id */
4569 PROP_gimple_lcf
, /* properties_required */
4570 0, /* properties_provided */
4571 0, /* properties_destroyed */
4572 0, /* todo_flags_start */
4573 0, /* todo_flags_finish */
4576 class pass_cleanup_eh
: public gimple_opt_pass
4579 pass_cleanup_eh (gcc::context
*ctxt
)
4580 : gimple_opt_pass (pass_data_cleanup_eh
, ctxt
)
4583 /* opt_pass methods: */
4584 opt_pass
* clone () { return new pass_cleanup_eh (m_ctxt
); }
4585 virtual bool gate (function
*fun
)
4587 return fun
->eh
!= NULL
&& fun
->eh
->region_tree
!= NULL
;
4590 virtual unsigned int execute (function
*);
4592 }; // class pass_cleanup_eh
4595 pass_cleanup_eh::execute (function
*fun
)
4597 int ret
= execute_cleanup_eh_1 ();
4599 /* If the function no longer needs an EH personality routine
4600 clear it. This exposes cross-language inlining opportunities
4601 and avoids references to a never defined personality routine. */
4602 if (DECL_FUNCTION_PERSONALITY (current_function_decl
)
4603 && function_needs_eh_personality (fun
) != eh_personality_lang
)
4604 DECL_FUNCTION_PERSONALITY (current_function_decl
) = NULL_TREE
;
4612 make_pass_cleanup_eh (gcc::context
*ctxt
)
4614 return new pass_cleanup_eh (ctxt
);
4617 /* Verify that BB containing STMT as the last statement, has precisely the
4618 edge that make_eh_edges would create. */
4621 verify_eh_edges (gimple stmt
)
4623 basic_block bb
= gimple_bb (stmt
);
4624 eh_landing_pad lp
= NULL
;
4629 lp_nr
= lookup_stmt_eh_lp (stmt
);
4631 lp
= get_eh_landing_pad_from_number (lp_nr
);
4634 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4636 if (e
->flags
& EDGE_EH
)
4640 error ("BB %i has multiple EH edges", bb
->index
);
4652 error ("BB %i can not throw but has an EH edge", bb
->index
);
4658 if (!stmt_could_throw_p (stmt
))
4660 error ("BB %i last statement has incorrectly set lp", bb
->index
);
4664 if (eh_edge
== NULL
)
4666 error ("BB %i is missing an EH edge", bb
->index
);
4670 if (eh_edge
->dest
!= label_to_block (lp
->post_landing_pad
))
4672 error ("Incorrect EH edge %i->%i", bb
->index
, eh_edge
->dest
->index
);
4679 /* Similarly, but handle GIMPLE_EH_DISPATCH specifically. */
4682 verify_eh_dispatch_edge (gimple_eh_dispatch stmt
)
4686 basic_block src
, dst
;
4687 bool want_fallthru
= true;
4691 r
= get_eh_region_from_number (gimple_eh_dispatch_region (stmt
));
4692 src
= gimple_bb (stmt
);
4694 FOR_EACH_EDGE (e
, ei
, src
->succs
)
4695 gcc_assert (e
->aux
== NULL
);
4700 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
4702 dst
= label_to_block (c
->label
);
4703 e
= find_edge (src
, dst
);
4706 error ("BB %i is missing an edge", src
->index
);
4711 /* A catch-all handler doesn't have a fallthru. */
4712 if (c
->type_list
== NULL
)
4714 want_fallthru
= false;
4720 case ERT_ALLOWED_EXCEPTIONS
:
4721 dst
= label_to_block (r
->u
.allowed
.label
);
4722 e
= find_edge (src
, dst
);
4725 error ("BB %i is missing an edge", src
->index
);
4736 FOR_EACH_EDGE (e
, ei
, src
->succs
)
4738 if (e
->flags
& EDGE_FALLTHRU
)
4740 if (fall_edge
!= NULL
)
4742 error ("BB %i too many fallthru edges", src
->index
);
4751 error ("BB %i has incorrect edge", src
->index
);
4755 if ((fall_edge
!= NULL
) ^ want_fallthru
)
4757 error ("BB %i has incorrect fallthru edge", src
->index
);