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
, gtry
*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
, gtry
*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
, gtry
*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
, gtry
*region
)
243 switch (gimple_code (stmt
))
246 temp
.t
= gimple_label_label (as_a
<glabel
*> (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
<gtry
*> (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
<gcatch
*> (stmt
)),
272 case GIMPLE_EH_FILTER
:
273 collect_finally_tree_1 (gimple_eh_filter_failure (stmt
), region
);
278 geh_else
*eh_else_stmt
= as_a
<geh_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 gtry
*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
*, gtry
*);
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
<gcatch
*> (stmt
)),
532 case GIMPLE_EH_FILTER
:
533 replace_goto_queue_stmt_list (gimple_eh_filter_failure_ptr (stmt
), tf
);
537 geh_else
*eh_else_stmt
= as_a
<geh_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 gcond
*cond_stmt
= as_a
<gcond
*> (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 gswitch
*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 gresx
*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 geh_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 (gtry
*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
,
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 geh_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
<geh_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
;
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
)
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
;
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
;
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
;
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
;
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
, gtry
*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
, gtry
*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
);
1796 catch_stmt
= as_a
<gcatch
*> (gsi_stmt (gsi
));
1797 c
= gen_eh_region_catch (try_region
, gimple_catch_types (catch_stmt
));
1799 handler
= gimple_catch_handler (catch_stmt
);
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
, gtry
*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
, gtry
*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
<geh_mnt
*> (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
, gtry
*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
<gswitch
*> (stmt
));
2064 gtry
*try_stmt
= as_a
<gtry
*> (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 (geh_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 (geh_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 (as_a
<gcall
*> (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
<gasm
*> (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 (gtry
*one
, gtry
*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 (gtry
*try_one
= dyn_cast
<gtry
*> (one
))
3081 if (gtry
*try_two
= dyn_cast
<gtry
*> (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
<gcatch
*> (one
)));
3095 case GIMPLE_EH_FILTER
:
3096 refactor_eh_r (gimple_eh_filter_failure (one
));
3098 case GIMPLE_EH_ELSE
:
3100 geh_else
*eh_else_stmt
= as_a
<geh_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
, gresx
*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
<gresx
*> (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 (gphi_iterator gpi
= gsi_start_phis (succbb
);
3475 !gsi_end_p (gpi
); gsi_next (&gpi
))
3477 tree res
= gimple_phi_result (gpi
.phi ());
3478 if (virtual_operand_p (res
))
3486 dgsi
= gsi_after_labels (succbb
);
3487 gsi
= gsi_last_bb (bb
);
3488 for (gsi_prev (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
3490 gimple stmt
= gsi_stmt (gsi
);
3492 if (is_gimple_debug (stmt
))
3494 if (gimple_code (stmt
) == GIMPLE_LABEL
)
3496 lhs
= gimple_assign_lhs (stmt
);
3497 /* Unfortunately we don't have dominance info updated at this
3498 point, so checking if
3499 dominated_by_p (CDI_DOMINATORS, succbb,
3500 gimple_bb (SSA_NAME_DEF_STMT (TREE_OPERAND (lhs, 0)))
3501 would be too costly. Thus, avoid sinking any clobbers that
3502 refer to non-(D) SSA_NAMEs. */
3503 if (TREE_CODE (lhs
) == MEM_REF
3504 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == SSA_NAME
3505 && !SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (lhs
, 0)))
3507 unlink_stmt_vdef (stmt
);
3508 gsi_remove (&gsi
, true);
3509 release_defs (stmt
);
3513 /* As we do not change stmt order when sinking across a
3514 forwarder edge we can keep virtual operands in place. */
3515 gsi_remove (&gsi
, false);
3516 gsi_insert_before (&dgsi
, stmt
, GSI_NEW_STMT
);
3518 /* But adjust virtual operands if we sunk across a PHI node. */
3522 imm_use_iterator iter
;
3523 use_operand_p use_p
;
3524 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, vuse
)
3525 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
3526 SET_USE (use_p
, gimple_vdef (stmt
));
3527 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vuse
))
3529 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vdef (stmt
)) = 1;
3530 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vuse
) = 0;
3532 /* Adjust the incoming virtual operand. */
3533 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (vphi
, succe
), gimple_vuse (stmt
));
3534 SET_USE (gimple_vuse_op (stmt
), vuse
);
3536 /* If there isn't a single predecessor but no virtual PHI node
3537 arrange for virtual operands to be renamed. */
3538 else if (gimple_vuse_op (stmt
) != NULL_USE_OPERAND_P
3539 && !single_pred_p (succbb
))
3541 /* In this case there will be no use of the VDEF of this stmt.
3542 ??? Unless this is a secondary opportunity and we have not
3543 removed unreachable blocks yet, so we cannot assert this.
3544 Which also means we will end up renaming too many times. */
3545 SET_USE (gimple_vuse_op (stmt
), gimple_vop (cfun
));
3546 mark_virtual_operands_for_renaming (cfun
);
3547 todo
|= TODO_update_ssa_only_virtuals
;
3554 /* At the end of inlining, we can lower EH_DISPATCH. Return true when
3555 we have found some duplicate labels and removed some edges. */
3558 lower_eh_dispatch (basic_block src
, geh_dispatch
*stmt
)
3560 gimple_stmt_iterator gsi
;
3565 bool redirected
= false;
3567 region_nr
= gimple_eh_dispatch_region (stmt
);
3568 r
= get_eh_region_from_number (region_nr
);
3570 gsi
= gsi_last_bb (src
);
3576 auto_vec
<tree
> labels
;
3577 tree default_label
= NULL
;
3581 hash_set
<tree
> seen_values
;
3583 /* Collect the labels for a switch. Zero the post_landing_pad
3584 field becase we'll no longer have anything keeping these labels
3585 in existence and the optimizer will be free to merge these
3587 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
3589 tree tp_node
, flt_node
, lab
= c
->label
;
3590 bool have_label
= false;
3593 tp_node
= c
->type_list
;
3594 flt_node
= c
->filter_list
;
3596 if (tp_node
== NULL
)
3598 default_label
= lab
;
3603 /* Filter out duplicate labels that arise when this handler
3604 is shadowed by an earlier one. When no labels are
3605 attached to the handler anymore, we remove
3606 the corresponding edge and then we delete unreachable
3607 blocks at the end of this pass. */
3608 if (! seen_values
.contains (TREE_VALUE (flt_node
)))
3610 tree t
= build_case_label (TREE_VALUE (flt_node
),
3612 labels
.safe_push (t
);
3613 seen_values
.add (TREE_VALUE (flt_node
));
3617 tp_node
= TREE_CHAIN (tp_node
);
3618 flt_node
= TREE_CHAIN (flt_node
);
3623 remove_edge (find_edge (src
, label_to_block (lab
)));
3628 /* Clean up the edge flags. */
3629 FOR_EACH_EDGE (e
, ei
, src
->succs
)
3631 if (e
->flags
& EDGE_FALLTHRU
)
3633 /* If there was no catch-all, use the fallthru edge. */
3634 if (default_label
== NULL
)
3635 default_label
= gimple_block_label (e
->dest
);
3636 e
->flags
&= ~EDGE_FALLTHRU
;
3639 gcc_assert (default_label
!= NULL
);
3641 /* Don't generate a switch if there's only a default case.
3642 This is common in the form of try { A; } catch (...) { B; }. */
3643 if (!labels
.exists ())
3645 e
= single_succ_edge (src
);
3646 e
->flags
|= EDGE_FALLTHRU
;
3650 fn
= builtin_decl_implicit (BUILT_IN_EH_FILTER
);
3651 x
= gimple_build_call (fn
, 1, build_int_cst (integer_type_node
,
3653 filter
= create_tmp_var (TREE_TYPE (TREE_TYPE (fn
)), NULL
);
3654 filter
= make_ssa_name (filter
, x
);
3655 gimple_call_set_lhs (x
, filter
);
3656 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3658 /* Turn the default label into a default case. */
3659 default_label
= build_case_label (NULL
, NULL
, default_label
);
3660 sort_case_labels (labels
);
3662 x
= gimple_build_switch (filter
, default_label
, labels
);
3663 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3668 case ERT_ALLOWED_EXCEPTIONS
:
3670 edge b_e
= BRANCH_EDGE (src
);
3671 edge f_e
= FALLTHRU_EDGE (src
);
3673 fn
= builtin_decl_implicit (BUILT_IN_EH_FILTER
);
3674 x
= gimple_build_call (fn
, 1, build_int_cst (integer_type_node
,
3676 filter
= create_tmp_var (TREE_TYPE (TREE_TYPE (fn
)), NULL
);
3677 filter
= make_ssa_name (filter
, x
);
3678 gimple_call_set_lhs (x
, filter
);
3679 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3681 r
->u
.allowed
.label
= NULL
;
3682 x
= gimple_build_cond (EQ_EXPR
, filter
,
3683 build_int_cst (TREE_TYPE (filter
),
3684 r
->u
.allowed
.filter
),
3685 NULL_TREE
, NULL_TREE
);
3686 gsi_insert_before (&gsi
, x
, GSI_SAME_STMT
);
3688 b_e
->flags
= b_e
->flags
| EDGE_TRUE_VALUE
;
3689 f_e
->flags
= (f_e
->flags
& ~EDGE_FALLTHRU
) | EDGE_FALSE_VALUE
;
3697 /* Replace the EH_DISPATCH with the SWITCH or COND generated above. */
3698 gsi_remove (&gsi
, true);
3704 const pass_data pass_data_lower_eh_dispatch
=
3706 GIMPLE_PASS
, /* type */
3707 "ehdisp", /* name */
3708 OPTGROUP_NONE
, /* optinfo_flags */
3709 TV_TREE_EH
, /* tv_id */
3710 PROP_gimple_lcf
, /* properties_required */
3711 0, /* properties_provided */
3712 0, /* properties_destroyed */
3713 0, /* todo_flags_start */
3714 0, /* todo_flags_finish */
3717 class pass_lower_eh_dispatch
: public gimple_opt_pass
3720 pass_lower_eh_dispatch (gcc::context
*ctxt
)
3721 : gimple_opt_pass (pass_data_lower_eh_dispatch
, ctxt
)
3724 /* opt_pass methods: */
3725 virtual bool gate (function
*fun
) { return fun
->eh
->region_tree
!= NULL
; }
3726 virtual unsigned int execute (function
*);
3728 }; // class pass_lower_eh_dispatch
3731 pass_lower_eh_dispatch::execute (function
*fun
)
3735 bool redirected
= false;
3737 assign_filter_values ();
3739 FOR_EACH_BB_FN (bb
, fun
)
3741 gimple last
= last_stmt (bb
);
3744 if (gimple_code (last
) == GIMPLE_EH_DISPATCH
)
3746 redirected
|= lower_eh_dispatch (bb
,
3747 as_a
<geh_dispatch
*> (last
));
3748 flags
|= TODO_update_ssa_only_virtuals
;
3750 else if (gimple_code (last
) == GIMPLE_RESX
)
3752 if (stmt_can_throw_external (last
))
3753 optimize_clobbers (bb
);
3755 flags
|= sink_clobbers (bb
);
3760 delete_unreachable_blocks ();
3767 make_pass_lower_eh_dispatch (gcc::context
*ctxt
)
3769 return new pass_lower_eh_dispatch (ctxt
);
3772 /* Walk statements, see what regions and, optionally, landing pads
3773 are really referenced.
3775 Returns in R_REACHABLEP an sbitmap with bits set for reachable regions,
3776 and in LP_REACHABLE an sbitmap with bits set for reachable landing pads.
3778 Passing NULL for LP_REACHABLE is valid, in this case only reachable
3781 The caller is responsible for freeing the returned sbitmaps. */
3784 mark_reachable_handlers (sbitmap
*r_reachablep
, sbitmap
*lp_reachablep
)
3786 sbitmap r_reachable
, lp_reachable
;
3788 bool mark_landing_pads
= (lp_reachablep
!= NULL
);
3789 gcc_checking_assert (r_reachablep
!= NULL
);
3791 r_reachable
= sbitmap_alloc (cfun
->eh
->region_array
->length ());
3792 bitmap_clear (r_reachable
);
3793 *r_reachablep
= r_reachable
;
3795 if (mark_landing_pads
)
3797 lp_reachable
= sbitmap_alloc (cfun
->eh
->lp_array
->length ());
3798 bitmap_clear (lp_reachable
);
3799 *lp_reachablep
= lp_reachable
;
3802 lp_reachable
= NULL
;
3804 FOR_EACH_BB_FN (bb
, cfun
)
3806 gimple_stmt_iterator gsi
;
3808 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
3810 gimple stmt
= gsi_stmt (gsi
);
3812 if (mark_landing_pads
)
3814 int lp_nr
= lookup_stmt_eh_lp (stmt
);
3816 /* Negative LP numbers are MUST_NOT_THROW regions which
3817 are not considered BB enders. */
3819 bitmap_set_bit (r_reachable
, -lp_nr
);
3821 /* Positive LP numbers are real landing pads, and BB enders. */
3824 gcc_assert (gsi_one_before_end_p (gsi
));
3825 eh_region region
= get_eh_region_from_lp_number (lp_nr
);
3826 bitmap_set_bit (r_reachable
, region
->index
);
3827 bitmap_set_bit (lp_reachable
, lp_nr
);
3831 /* Avoid removing regions referenced from RESX/EH_DISPATCH. */
3832 switch (gimple_code (stmt
))
3835 bitmap_set_bit (r_reachable
,
3836 gimple_resx_region (as_a
<gresx
*> (stmt
)));
3838 case GIMPLE_EH_DISPATCH
:
3839 bitmap_set_bit (r_reachable
,
3840 gimple_eh_dispatch_region (
3841 as_a
<geh_dispatch
*> (stmt
)));
3850 /* Remove unreachable handlers and unreachable landing pads. */
3853 remove_unreachable_handlers (void)
3855 sbitmap r_reachable
, lp_reachable
;
3860 mark_reachable_handlers (&r_reachable
, &lp_reachable
);
3864 fprintf (dump_file
, "Before removal of unreachable regions:\n");
3865 dump_eh_tree (dump_file
, cfun
);
3866 fprintf (dump_file
, "Reachable regions: ");
3867 dump_bitmap_file (dump_file
, r_reachable
);
3868 fprintf (dump_file
, "Reachable landing pads: ");
3869 dump_bitmap_file (dump_file
, lp_reachable
);
3874 FOR_EACH_VEC_SAFE_ELT (cfun
->eh
->region_array
, i
, region
)
3875 if (region
&& !bitmap_bit_p (r_reachable
, region
->index
))
3877 "Removing unreachable region %d\n",
3881 remove_unreachable_eh_regions (r_reachable
);
3883 FOR_EACH_VEC_SAFE_ELT (cfun
->eh
->lp_array
, i
, lp
)
3884 if (lp
&& !bitmap_bit_p (lp_reachable
, lp
->index
))
3888 "Removing unreachable landing pad %d\n",
3890 remove_eh_landing_pad (lp
);
3895 fprintf (dump_file
, "\n\nAfter removal of unreachable regions:\n");
3896 dump_eh_tree (dump_file
, cfun
);
3897 fprintf (dump_file
, "\n\n");
3900 sbitmap_free (r_reachable
);
3901 sbitmap_free (lp_reachable
);
3903 #ifdef ENABLE_CHECKING
3904 verify_eh_tree (cfun
);
3908 /* Remove unreachable handlers if any landing pads have been removed after
3909 last ehcleanup pass (due to gimple_purge_dead_eh_edges). */
3912 maybe_remove_unreachable_handlers (void)
3917 if (cfun
->eh
== NULL
)
3920 FOR_EACH_VEC_SAFE_ELT (cfun
->eh
->lp_array
, i
, lp
)
3921 if (lp
&& lp
->post_landing_pad
)
3923 if (label_to_block (lp
->post_landing_pad
) == NULL
)
3925 remove_unreachable_handlers ();
3931 /* Remove regions that do not have landing pads. This assumes
3932 that remove_unreachable_handlers has already been run, and
3933 that we've just manipulated the landing pads since then.
3935 Preserve regions with landing pads and regions that prevent
3936 exceptions from propagating further, even if these regions
3937 are not reachable. */
3940 remove_unreachable_handlers_no_lp (void)
3943 sbitmap r_reachable
;
3946 mark_reachable_handlers (&r_reachable
, /*lp_reachablep=*/NULL
);
3948 FOR_EACH_VEC_SAFE_ELT (cfun
->eh
->region_array
, i
, region
)
3953 if (region
->landing_pads
!= NULL
3954 || region
->type
== ERT_MUST_NOT_THROW
)
3955 bitmap_set_bit (r_reachable
, region
->index
);
3958 && !bitmap_bit_p (r_reachable
, region
->index
))
3960 "Removing unreachable region %d\n",
3964 remove_unreachable_eh_regions (r_reachable
);
3966 sbitmap_free (r_reachable
);
3969 /* Undo critical edge splitting on an EH landing pad. Earlier, we
3970 optimisticaly split all sorts of edges, including EH edges. The
3971 optimization passes in between may not have needed them; if not,
3972 we should undo the split.
3974 Recognize this case by having one EH edge incoming to the BB and
3975 one normal edge outgoing; BB should be empty apart from the
3976 post_landing_pad label.
3978 Note that this is slightly different from the empty handler case
3979 handled by cleanup_empty_eh, in that the actual handler may yet
3980 have actual code but the landing pad has been separated from the
3981 handler. As such, cleanup_empty_eh relies on this transformation
3982 having been done first. */
3985 unsplit_eh (eh_landing_pad lp
)
3987 basic_block bb
= label_to_block (lp
->post_landing_pad
);
3988 gimple_stmt_iterator gsi
;
3991 /* Quickly check the edge counts on BB for singularity. */
3992 if (!single_pred_p (bb
) || !single_succ_p (bb
))
3994 e_in
= single_pred_edge (bb
);
3995 e_out
= single_succ_edge (bb
);
3997 /* Input edge must be EH and output edge must be normal. */
3998 if ((e_in
->flags
& EDGE_EH
) == 0 || (e_out
->flags
& EDGE_EH
) != 0)
4001 /* The block must be empty except for the labels and debug insns. */
4002 gsi
= gsi_after_labels (bb
);
4003 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
4004 gsi_next_nondebug (&gsi
);
4005 if (!gsi_end_p (gsi
))
4008 /* The destination block must not already have a landing pad
4009 for a different region. */
4010 for (gsi
= gsi_start_bb (e_out
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4012 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
4018 lab
= gimple_label_label (label_stmt
);
4019 lp_nr
= EH_LANDING_PAD_NR (lab
);
4020 if (lp_nr
&& get_eh_region_from_lp_number (lp_nr
) != lp
->region
)
4024 /* The new destination block must not already be a destination of
4025 the source block, lest we merge fallthru and eh edges and get
4026 all sorts of confused. */
4027 if (find_edge (e_in
->src
, e_out
->dest
))
4030 /* ??? We can get degenerate phis due to cfg cleanups. I would have
4031 thought this should have been cleaned up by a phicprop pass, but
4032 that doesn't appear to handle virtuals. Propagate by hand. */
4033 if (!gimple_seq_empty_p (phi_nodes (bb
)))
4035 for (gphi_iterator gpi
= gsi_start_phis (bb
); !gsi_end_p (gpi
); )
4038 gphi
*phi
= gpi
.phi ();
4039 tree lhs
= gimple_phi_result (phi
);
4040 tree rhs
= gimple_phi_arg_def (phi
, 0);
4041 use_operand_p use_p
;
4042 imm_use_iterator iter
;
4044 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, lhs
)
4046 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
4047 SET_USE (use_p
, rhs
);
4050 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs
))
4051 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs
) = 1;
4053 remove_phi_node (&gpi
, true);
4057 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4058 fprintf (dump_file
, "Unsplit EH landing pad %d to block %i.\n",
4059 lp
->index
, e_out
->dest
->index
);
4061 /* Redirect the edge. Since redirect_eh_edge_1 expects to be moving
4062 a successor edge, humor it. But do the real CFG change with the
4063 predecessor of E_OUT in order to preserve the ordering of arguments
4064 to the PHI nodes in E_OUT->DEST. */
4065 redirect_eh_edge_1 (e_in
, e_out
->dest
, false);
4066 redirect_edge_pred (e_out
, e_in
->src
);
4067 e_out
->flags
= e_in
->flags
;
4068 e_out
->probability
= e_in
->probability
;
4069 e_out
->count
= e_in
->count
;
4075 /* Examine each landing pad block and see if it matches unsplit_eh. */
4078 unsplit_all_eh (void)
4080 bool changed
= false;
4084 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
4086 changed
|= unsplit_eh (lp
);
4091 /* A subroutine of cleanup_empty_eh. Redirect all EH edges incoming
4092 to OLD_BB to NEW_BB; return true on success, false on failure.
4094 OLD_BB_OUT is the edge into NEW_BB from OLD_BB, so if we miss any
4095 PHI variables from OLD_BB we can pick them up from OLD_BB_OUT.
4096 Virtual PHIs may be deleted and marked for renaming. */
4099 cleanup_empty_eh_merge_phis (basic_block new_bb
, basic_block old_bb
,
4100 edge old_bb_out
, bool change_region
)
4102 gphi_iterator ngsi
, ogsi
;
4105 bitmap ophi_handled
;
4107 /* The destination block must not be a regular successor for any
4108 of the preds of the landing pad. Thus, avoid turning
4118 which CFG verification would choke on. See PR45172 and PR51089. */
4119 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4120 if (find_edge (e
->src
, new_bb
))
4123 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4124 redirect_edge_var_map_clear (e
);
4126 ophi_handled
= BITMAP_ALLOC (NULL
);
4128 /* First, iterate through the PHIs on NEW_BB and set up the edge_var_map
4129 for the edges we're going to move. */
4130 for (ngsi
= gsi_start_phis (new_bb
); !gsi_end_p (ngsi
); gsi_next (&ngsi
))
4132 gphi
*ophi
, *nphi
= ngsi
.phi ();
4135 nresult
= gimple_phi_result (nphi
);
4136 nop
= gimple_phi_arg_def (nphi
, old_bb_out
->dest_idx
);
4138 /* Find the corresponding PHI in OLD_BB so we can forward-propagate
4139 the source ssa_name. */
4141 for (ogsi
= gsi_start_phis (old_bb
); !gsi_end_p (ogsi
); gsi_next (&ogsi
))
4144 if (gimple_phi_result (ophi
) == nop
)
4149 /* If we did find the corresponding PHI, copy those inputs. */
4152 /* If NOP is used somewhere else beyond phis in new_bb, give up. */
4153 if (!has_single_use (nop
))
4155 imm_use_iterator imm_iter
;
4156 use_operand_p use_p
;
4158 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, nop
)
4160 if (!gimple_debug_bind_p (USE_STMT (use_p
))
4161 && (gimple_code (USE_STMT (use_p
)) != GIMPLE_PHI
4162 || gimple_bb (USE_STMT (use_p
)) != new_bb
))
4166 bitmap_set_bit (ophi_handled
, SSA_NAME_VERSION (nop
));
4167 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4172 if ((e
->flags
& EDGE_EH
) == 0)
4174 oop
= gimple_phi_arg_def (ophi
, e
->dest_idx
);
4175 oloc
= gimple_phi_arg_location (ophi
, e
->dest_idx
);
4176 redirect_edge_var_map_add (e
, nresult
, oop
, oloc
);
4179 /* If we didn't find the PHI, if it's a real variable or a VOP, we know
4180 from the fact that OLD_BB is tree_empty_eh_handler_p that the
4181 variable is unchanged from input to the block and we can simply
4182 re-use the input to NEW_BB from the OLD_BB_OUT edge. */
4186 = gimple_phi_arg_location (nphi
, old_bb_out
->dest_idx
);
4187 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4188 redirect_edge_var_map_add (e
, nresult
, nop
, nloc
);
4192 /* Second, verify that all PHIs from OLD_BB have been handled. If not,
4193 we don't know what values from the other edges into NEW_BB to use. */
4194 for (ogsi
= gsi_start_phis (old_bb
); !gsi_end_p (ogsi
); gsi_next (&ogsi
))
4196 gphi
*ophi
= ogsi
.phi ();
4197 tree oresult
= gimple_phi_result (ophi
);
4198 if (!bitmap_bit_p (ophi_handled
, SSA_NAME_VERSION (oresult
)))
4202 /* Finally, move the edges and update the PHIs. */
4203 for (ei
= ei_start (old_bb
->preds
); (e
= ei_safe_edge (ei
)); )
4204 if (e
->flags
& EDGE_EH
)
4206 /* ??? CFG manipluation routines do not try to update loop
4207 form on edge redirection. Do so manually here for now. */
4208 /* If we redirect a loop entry or latch edge that will either create
4209 a multiple entry loop or rotate the loop. If the loops merge
4210 we may have created a loop with multiple latches.
4211 All of this isn't easily fixed thus cancel the affected loop
4212 and mark the other loop as possibly having multiple latches. */
4213 if (e
->dest
== e
->dest
->loop_father
->header
)
4215 mark_loop_for_removal (e
->dest
->loop_father
);
4216 new_bb
->loop_father
->latch
= NULL
;
4217 loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES
);
4219 redirect_eh_edge_1 (e
, new_bb
, change_region
);
4220 redirect_edge_succ (e
, new_bb
);
4221 flush_pending_stmts (e
);
4226 BITMAP_FREE (ophi_handled
);
4230 FOR_EACH_EDGE (e
, ei
, old_bb
->preds
)
4231 redirect_edge_var_map_clear (e
);
4232 BITMAP_FREE (ophi_handled
);
4236 /* A subroutine of cleanup_empty_eh. Move a landing pad LP from its
4237 old region to NEW_REGION at BB. */
4240 cleanup_empty_eh_move_lp (basic_block bb
, edge e_out
,
4241 eh_landing_pad lp
, eh_region new_region
)
4243 gimple_stmt_iterator gsi
;
4246 for (pp
= &lp
->region
->landing_pads
; *pp
!= lp
; pp
= &(*pp
)->next_lp
)
4250 lp
->region
= new_region
;
4251 lp
->next_lp
= new_region
->landing_pads
;
4252 new_region
->landing_pads
= lp
;
4254 /* Delete the RESX that was matched within the empty handler block. */
4255 gsi
= gsi_last_bb (bb
);
4256 unlink_stmt_vdef (gsi_stmt (gsi
));
4257 gsi_remove (&gsi
, true);
4259 /* Clean up E_OUT for the fallthru. */
4260 e_out
->flags
= (e_out
->flags
& ~EDGE_EH
) | EDGE_FALLTHRU
;
4261 e_out
->probability
= REG_BR_PROB_BASE
;
4264 /* A subroutine of cleanup_empty_eh. Handle more complex cases of
4265 unsplitting than unsplit_eh was prepared to handle, e.g. when
4266 multiple incoming edges and phis are involved. */
4269 cleanup_empty_eh_unsplit (basic_block bb
, edge e_out
, eh_landing_pad lp
)
4271 gimple_stmt_iterator gsi
;
4274 /* We really ought not have totally lost everything following
4275 a landing pad label. Given that BB is empty, there had better
4277 gcc_assert (e_out
!= NULL
);
4279 /* The destination block must not already have a landing pad
4280 for a different region. */
4282 for (gsi
= gsi_start_bb (e_out
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4284 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
4289 lab
= gimple_label_label (stmt
);
4290 lp_nr
= EH_LANDING_PAD_NR (lab
);
4291 if (lp_nr
&& get_eh_region_from_lp_number (lp_nr
) != lp
->region
)
4295 /* Attempt to move the PHIs into the successor block. */
4296 if (cleanup_empty_eh_merge_phis (e_out
->dest
, bb
, e_out
, false))
4298 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4300 "Unsplit EH landing pad %d to block %i "
4301 "(via cleanup_empty_eh).\n",
4302 lp
->index
, e_out
->dest
->index
);
4309 /* Return true if edge E_FIRST is part of an empty infinite loop
4310 or leads to such a loop through a series of single successor
4314 infinite_empty_loop_p (edge e_first
)
4316 bool inf_loop
= false;
4319 if (e_first
->dest
== e_first
->src
)
4322 e_first
->src
->aux
= (void *) 1;
4323 for (e
= e_first
; single_succ_p (e
->dest
); e
= single_succ_edge (e
->dest
))
4325 gimple_stmt_iterator gsi
;
4331 e
->dest
->aux
= (void *) 1;
4332 gsi
= gsi_after_labels (e
->dest
);
4333 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
4334 gsi_next_nondebug (&gsi
);
4335 if (!gsi_end_p (gsi
))
4338 e_first
->src
->aux
= NULL
;
4339 for (e
= e_first
; e
->dest
->aux
; e
= single_succ_edge (e
->dest
))
4340 e
->dest
->aux
= NULL
;
4345 /* Examine the block associated with LP to determine if it's an empty
4346 handler for its EH region. If so, attempt to redirect EH edges to
4347 an outer region. Return true the CFG was updated in any way. This
4348 is similar to jump forwarding, just across EH edges. */
4351 cleanup_empty_eh (eh_landing_pad lp
)
4353 basic_block bb
= label_to_block (lp
->post_landing_pad
);
4354 gimple_stmt_iterator gsi
;
4356 eh_region new_region
;
4359 bool has_non_eh_pred
;
4363 /* There can be zero or one edges out of BB. This is the quickest test. */
4364 switch (EDGE_COUNT (bb
->succs
))
4370 e_out
= single_succ_edge (bb
);
4376 resx
= last_stmt (bb
);
4377 if (resx
&& is_gimple_resx (resx
))
4379 if (stmt_can_throw_external (resx
))
4380 optimize_clobbers (bb
);
4381 else if (sink_clobbers (bb
))
4385 gsi
= gsi_after_labels (bb
);
4387 /* Make sure to skip debug statements. */
4388 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
4389 gsi_next_nondebug (&gsi
);
4391 /* If the block is totally empty, look for more unsplitting cases. */
4392 if (gsi_end_p (gsi
))
4394 /* For the degenerate case of an infinite loop bail out.
4395 If bb has no successors and is totally empty, which can happen e.g.
4396 because of incorrect noreturn attribute, bail out too. */
4398 || infinite_empty_loop_p (e_out
))
4401 return ret
| cleanup_empty_eh_unsplit (bb
, e_out
, lp
);
4404 /* The block should consist only of a single RESX statement, modulo a
4405 preceding call to __builtin_stack_restore if there is no outgoing
4406 edge, since the call can be eliminated in this case. */
4407 resx
= gsi_stmt (gsi
);
4408 if (!e_out
&& gimple_call_builtin_p (resx
, BUILT_IN_STACK_RESTORE
))
4411 resx
= gsi_stmt (gsi
);
4413 if (!is_gimple_resx (resx
))
4415 gcc_assert (gsi_one_before_end_p (gsi
));
4417 /* Determine if there are non-EH edges, or resx edges into the handler. */
4418 has_non_eh_pred
= false;
4419 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
4420 if (!(e
->flags
& EDGE_EH
))
4421 has_non_eh_pred
= true;
4423 /* Find the handler that's outer of the empty handler by looking at
4424 where the RESX instruction was vectored. */
4425 new_lp_nr
= lookup_stmt_eh_lp (resx
);
4426 new_region
= get_eh_region_from_lp_number (new_lp_nr
);
4428 /* If there's no destination region within the current function,
4429 redirection is trivial via removing the throwing statements from
4430 the EH region, removing the EH edges, and allowing the block
4431 to go unreachable. */
4432 if (new_region
== NULL
)
4434 gcc_assert (e_out
== NULL
);
4435 for (ei
= ei_start (bb
->preds
); (e
= ei_safe_edge (ei
)); )
4436 if (e
->flags
& EDGE_EH
)
4438 gimple stmt
= last_stmt (e
->src
);
4439 remove_stmt_from_eh_lp (stmt
);
4447 /* If the destination region is a MUST_NOT_THROW, allow the runtime
4448 to handle the abort and allow the blocks to go unreachable. */
4449 if (new_region
->type
== ERT_MUST_NOT_THROW
)
4451 for (ei
= ei_start (bb
->preds
); (e
= ei_safe_edge (ei
)); )
4452 if (e
->flags
& EDGE_EH
)
4454 gimple stmt
= last_stmt (e
->src
);
4455 remove_stmt_from_eh_lp (stmt
);
4456 add_stmt_to_eh_lp (stmt
, new_lp_nr
);
4464 /* Try to redirect the EH edges and merge the PHIs into the destination
4465 landing pad block. If the merge succeeds, we'll already have redirected
4466 all the EH edges. The handler itself will go unreachable if there were
4468 if (cleanup_empty_eh_merge_phis (e_out
->dest
, bb
, e_out
, true))
4471 /* Finally, if all input edges are EH edges, then we can (potentially)
4472 reduce the number of transfers from the runtime by moving the landing
4473 pad from the original region to the new region. This is a win when
4474 we remove the last CLEANUP region along a particular exception
4475 propagation path. Since nothing changes except for the region with
4476 which the landing pad is associated, the PHI nodes do not need to be
4478 if (!has_non_eh_pred
)
4480 cleanup_empty_eh_move_lp (bb
, e_out
, lp
, new_region
);
4481 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4482 fprintf (dump_file
, "Empty EH handler %i moved to EH region %i.\n",
4483 lp
->index
, new_region
->index
);
4485 /* ??? The CFG didn't change, but we may have rendered the
4486 old EH region unreachable. Trigger a cleanup there. */
4493 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4494 fprintf (dump_file
, "Empty EH handler %i removed.\n", lp
->index
);
4495 remove_eh_landing_pad (lp
);
4499 /* Do a post-order traversal of the EH region tree. Examine each
4500 post_landing_pad block and see if we can eliminate it as empty. */
4503 cleanup_all_empty_eh (void)
4505 bool changed
= false;
4509 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
4511 changed
|= cleanup_empty_eh (lp
);
4516 /* Perform cleanups and lowering of exception handling
4517 1) cleanups regions with handlers doing nothing are optimized out
4518 2) MUST_NOT_THROW regions that became dead because of 1) are optimized out
4519 3) Info about regions that are containing instructions, and regions
4520 reachable via local EH edges is collected
4521 4) Eh tree is pruned for regions no longer necessary.
4523 TODO: Push MUST_NOT_THROW regions to the root of the EH tree.
4524 Unify those that have the same failure decl and locus.
4528 execute_cleanup_eh_1 (void)
4530 /* Do this first: unsplit_all_eh and cleanup_all_empty_eh can die
4531 looking up unreachable landing pads. */
4532 remove_unreachable_handlers ();
4534 /* Watch out for the region tree vanishing due to all unreachable. */
4535 if (cfun
->eh
->region_tree
)
4537 bool changed
= false;
4540 changed
|= unsplit_all_eh ();
4541 changed
|= cleanup_all_empty_eh ();
4545 free_dominance_info (CDI_DOMINATORS
);
4546 free_dominance_info (CDI_POST_DOMINATORS
);
4548 /* We delayed all basic block deletion, as we may have performed
4549 cleanups on EH edges while non-EH edges were still present. */
4550 delete_unreachable_blocks ();
4552 /* We manipulated the landing pads. Remove any region that no
4553 longer has a landing pad. */
4554 remove_unreachable_handlers_no_lp ();
4556 return TODO_cleanup_cfg
| TODO_update_ssa_only_virtuals
;
4565 const pass_data pass_data_cleanup_eh
=
4567 GIMPLE_PASS
, /* type */
4568 "ehcleanup", /* name */
4569 OPTGROUP_NONE
, /* optinfo_flags */
4570 TV_TREE_EH
, /* tv_id */
4571 PROP_gimple_lcf
, /* properties_required */
4572 0, /* properties_provided */
4573 0, /* properties_destroyed */
4574 0, /* todo_flags_start */
4575 0, /* todo_flags_finish */
4578 class pass_cleanup_eh
: public gimple_opt_pass
4581 pass_cleanup_eh (gcc::context
*ctxt
)
4582 : gimple_opt_pass (pass_data_cleanup_eh
, ctxt
)
4585 /* opt_pass methods: */
4586 opt_pass
* clone () { return new pass_cleanup_eh (m_ctxt
); }
4587 virtual bool gate (function
*fun
)
4589 return fun
->eh
!= NULL
&& fun
->eh
->region_tree
!= NULL
;
4592 virtual unsigned int execute (function
*);
4594 }; // class pass_cleanup_eh
4597 pass_cleanup_eh::execute (function
*fun
)
4599 int ret
= execute_cleanup_eh_1 ();
4601 /* If the function no longer needs an EH personality routine
4602 clear it. This exposes cross-language inlining opportunities
4603 and avoids references to a never defined personality routine. */
4604 if (DECL_FUNCTION_PERSONALITY (current_function_decl
)
4605 && function_needs_eh_personality (fun
) != eh_personality_lang
)
4606 DECL_FUNCTION_PERSONALITY (current_function_decl
) = NULL_TREE
;
4614 make_pass_cleanup_eh (gcc::context
*ctxt
)
4616 return new pass_cleanup_eh (ctxt
);
4619 /* Verify that BB containing STMT as the last statement, has precisely the
4620 edge that make_eh_edges would create. */
4623 verify_eh_edges (gimple stmt
)
4625 basic_block bb
= gimple_bb (stmt
);
4626 eh_landing_pad lp
= NULL
;
4631 lp_nr
= lookup_stmt_eh_lp (stmt
);
4633 lp
= get_eh_landing_pad_from_number (lp_nr
);
4636 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4638 if (e
->flags
& EDGE_EH
)
4642 error ("BB %i has multiple EH edges", bb
->index
);
4654 error ("BB %i can not throw but has an EH edge", bb
->index
);
4660 if (!stmt_could_throw_p (stmt
))
4662 error ("BB %i last statement has incorrectly set lp", bb
->index
);
4666 if (eh_edge
== NULL
)
4668 error ("BB %i is missing an EH edge", bb
->index
);
4672 if (eh_edge
->dest
!= label_to_block (lp
->post_landing_pad
))
4674 error ("Incorrect EH edge %i->%i", bb
->index
, eh_edge
->dest
->index
);
4681 /* Similarly, but handle GIMPLE_EH_DISPATCH specifically. */
4684 verify_eh_dispatch_edge (geh_dispatch
*stmt
)
4688 basic_block src
, dst
;
4689 bool want_fallthru
= true;
4693 r
= get_eh_region_from_number (gimple_eh_dispatch_region (stmt
));
4694 src
= gimple_bb (stmt
);
4696 FOR_EACH_EDGE (e
, ei
, src
->succs
)
4697 gcc_assert (e
->aux
== NULL
);
4702 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
4704 dst
= label_to_block (c
->label
);
4705 e
= find_edge (src
, dst
);
4708 error ("BB %i is missing an edge", src
->index
);
4713 /* A catch-all handler doesn't have a fallthru. */
4714 if (c
->type_list
== NULL
)
4716 want_fallthru
= false;
4722 case ERT_ALLOWED_EXCEPTIONS
:
4723 dst
= label_to_block (r
->u
.allowed
.label
);
4724 e
= find_edge (src
, dst
);
4727 error ("BB %i is missing an edge", src
->index
);
4738 FOR_EACH_EDGE (e
, ei
, src
->succs
)
4740 if (e
->flags
& EDGE_FALLTHRU
)
4742 if (fall_edge
!= NULL
)
4744 error ("BB %i too many fallthru edges", src
->index
);
4753 error ("BB %i has incorrect edge", src
->index
);
4757 if ((fall_edge
!= NULL
) ^ want_fallthru
)
4759 error ("BB %i has incorrect fallthru edge", src
->index
);