1 /* CFG cleanup for trees.
2 Copyright (C) 2001-2022 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"
28 #include "tree-pass.h"
30 #include "diagnostic-core.h"
31 #include "fold-const.h"
33 #include "cfgcleanup.h"
36 #include "gimple-iterator.h"
38 #include "tree-ssa-loop-manip.h"
42 #include "tree-scalar-evolution.h"
43 #include "gimple-match.h"
44 #include "gimple-fold.h"
45 #include "tree-ssa-loop-niter.h"
47 #include "tree-into-ssa.h"
48 #include "tree-cfgcleanup.h"
51 /* The set of blocks in that at least one of the following changes happened:
52 -- the statement at the end of the block was changed
53 -- the block was newly created
54 -- the set of the predecessors of the block changed
55 -- the set of the successors of the block changed
56 ??? Maybe we could track these changes separately, since they determine
57 what cleanups it makes sense to try on the block. */
58 bitmap cfgcleanup_altered_bbs
;
60 /* Remove any fallthru edge from EV. Return true if an edge was removed. */
63 remove_fallthru_edge (vec
<edge
, va_gc
> *ev
)
68 FOR_EACH_EDGE (e
, ei
, ev
)
69 if ((e
->flags
& EDGE_FALLTHRU
) != 0)
71 if (e
->flags
& EDGE_COMPLEX
)
72 e
->flags
&= ~EDGE_FALLTHRU
;
74 remove_edge_and_dominated_blocks (e
);
80 /* Convert a SWTCH with single non-default case to gcond and replace it
84 convert_single_case_switch (gswitch
*swtch
, gimple_stmt_iterator
&gsi
)
86 if (gimple_switch_num_labels (swtch
) != 2)
89 tree index
= gimple_switch_index (swtch
);
90 tree label
= gimple_switch_label (swtch
, 1);
91 tree low
= CASE_LOW (label
);
92 tree high
= CASE_HIGH (label
);
94 basic_block default_bb
= gimple_switch_default_bb (cfun
, swtch
);
95 basic_block case_bb
= label_to_block (cfun
, CASE_LABEL (label
));
97 basic_block bb
= gimple_bb (swtch
);
100 /* Replace switch statement with condition statement. */
104 if (range_check_type (TREE_TYPE (index
)) == NULL_TREE
)
106 generate_range_test (bb
, index
, low
, high
, &lhs
, &rhs
);
107 cond
= gimple_build_cond (LE_EXPR
, lhs
, rhs
, NULL_TREE
, NULL_TREE
);
110 cond
= gimple_build_cond (EQ_EXPR
, index
,
111 fold_convert (TREE_TYPE (index
), low
),
112 NULL_TREE
, NULL_TREE
);
114 gsi_replace (&gsi
, cond
, true);
117 edge case_edge
= find_edge (bb
, case_bb
);
118 edge default_edge
= find_edge (bb
, default_bb
);
120 case_edge
->flags
|= EDGE_TRUE_VALUE
;
121 default_edge
->flags
|= EDGE_FALSE_VALUE
;
125 /* Disconnect an unreachable block in the control expression starting
129 cleanup_control_expr_graph (basic_block bb
, gimple_stmt_iterator gsi
)
133 gimple
*stmt
= gsi_stmt (gsi
);
135 if (!single_succ_p (bb
))
140 tree val
= NULL_TREE
;
142 /* Try to convert a switch with just a single non-default case to
144 if (gimple_code (stmt
) == GIMPLE_SWITCH
145 && convert_single_case_switch (as_a
<gswitch
*> (stmt
), gsi
))
146 stmt
= gsi_stmt (gsi
);
148 fold_defer_overflow_warnings ();
149 switch (gimple_code (stmt
))
153 gimple_match_op res_op
;
154 if (gimple_simplify (stmt
, &res_op
, NULL
, no_follow_ssa_edges
,
156 && res_op
.code
== INTEGER_CST
)
162 val
= gimple_switch_index (as_a
<gswitch
*> (stmt
));
168 taken_edge
= find_taken_edge (bb
, val
);
171 fold_undefer_and_ignore_overflow_warnings ();
175 /* Remove all the edges except the one that is always executed. */
177 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
183 fold_undefer_overflow_warnings
184 (true, stmt
, WARN_STRICT_OVERFLOW_CONDITIONAL
);
188 taken_edge
->probability
+= e
->probability
;
189 remove_edge_and_dominated_blocks (e
);
196 fold_undefer_and_ignore_overflow_warnings ();
199 taken_edge
= single_succ_edge (bb
);
201 bitmap_set_bit (cfgcleanup_altered_bbs
, bb
->index
);
202 gsi_remove (&gsi
, true);
203 taken_edge
->flags
= EDGE_FALLTHRU
;
208 /* Cleanup the GF_CALL_CTRL_ALTERING flag according to
209 to updated gimple_call_flags. */
212 cleanup_call_ctrl_altering_flag (basic_block bb
, gimple
*bb_end
)
214 if (!is_gimple_call (bb_end
)
215 || !gimple_call_ctrl_altering_p (bb_end
)
216 || (/* IFN_UNIQUE should be the last insn, to make checking for it
217 as cheap as possible. */
218 gimple_call_internal_p (bb_end
)
219 && gimple_call_internal_unique_p (bb_end
)))
222 int flags
= gimple_call_flags (bb_end
);
223 if (((flags
& (ECF_CONST
| ECF_PURE
))
224 && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
225 || (flags
& ECF_LEAF
))
226 gimple_call_set_ctrl_altering (bb_end
, false);
232 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
233 if (e
->flags
& EDGE_FALLTHRU
)
235 else if (e
->flags
& EDGE_ABNORMAL
)
240 /* If there's no abnormal edge and a fallthru edge the call
241 isn't control-altering anymore. */
243 gimple_call_set_ctrl_altering (bb_end
, false);
247 /* Try to remove superfluous control structures in basic block BB. Returns
248 true if anything changes. */
251 cleanup_control_flow_bb (basic_block bb
)
253 gimple_stmt_iterator gsi
;
257 /* If the last statement of the block could throw and now cannot,
258 we need to prune cfg. */
259 retval
|= gimple_purge_dead_eh_edges (bb
);
261 gsi
= gsi_last_nondebug_bb (bb
);
265 stmt
= gsi_stmt (gsi
);
267 /* Try to cleanup ctrl altering flag for call which ends bb. */
268 cleanup_call_ctrl_altering_flag (bb
, stmt
);
270 if (gimple_code (stmt
) == GIMPLE_COND
271 || gimple_code (stmt
) == GIMPLE_SWITCH
)
273 gcc_checking_assert (gsi_stmt (gsi_last_bb (bb
)) == stmt
);
274 retval
|= cleanup_control_expr_graph (bb
, gsi
);
276 else if (gimple_code (stmt
) == GIMPLE_GOTO
277 && TREE_CODE (gimple_goto_dest (stmt
)) == ADDR_EXPR
278 && (TREE_CODE (TREE_OPERAND (gimple_goto_dest (stmt
), 0))
281 /* If we had a computed goto which has a compile-time determinable
282 destination, then we can eliminate the goto. */
286 basic_block target_block
;
288 gcc_checking_assert (gsi_stmt (gsi_last_bb (bb
)) == stmt
);
289 /* First look at all the outgoing edges. Delete any outgoing
290 edges which do not go to the right block. For the one
291 edge which goes to the right block, fix up its flags. */
292 label
= TREE_OPERAND (gimple_goto_dest (stmt
), 0);
293 if (DECL_CONTEXT (label
) != cfun
->decl
)
295 target_block
= label_to_block (cfun
, label
);
296 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
298 if (e
->dest
!= target_block
)
299 remove_edge_and_dominated_blocks (e
);
302 /* Turn off the EDGE_ABNORMAL flag. */
303 e
->flags
&= ~EDGE_ABNORMAL
;
305 /* And set EDGE_FALLTHRU. */
306 e
->flags
|= EDGE_FALLTHRU
;
311 bitmap_set_bit (cfgcleanup_altered_bbs
, bb
->index
);
312 bitmap_set_bit (cfgcleanup_altered_bbs
, target_block
->index
);
314 /* Remove the GOTO_EXPR as it is not needed. The CFG has all the
315 relevant information we need. */
316 gsi_remove (&gsi
, true);
320 /* Check for indirect calls that have been turned into
322 else if (is_gimple_call (stmt
)
323 && gimple_call_noreturn_p (stmt
))
325 /* If there are debug stmts after the noreturn call, remove them
326 now, they should be all unreachable anyway. */
327 for (gsi_next (&gsi
); !gsi_end_p (gsi
); )
328 gsi_remove (&gsi
, true);
329 if (remove_fallthru_edge (bb
->succs
))
336 /* Return true if basic block BB does nothing except pass control
337 flow to another block and that we can safely insert a label at
338 the start of the successor block.
340 As a precondition, we require that BB be not equal to
344 tree_forwarder_block_p (basic_block bb
, bool phi_wanted
)
346 gimple_stmt_iterator gsi
;
349 /* BB must have a single outgoing edge. */
350 if (single_succ_p (bb
) != 1
351 /* If PHI_WANTED is false, BB must not have any PHI nodes.
352 Otherwise, BB must have PHI nodes. */
353 || gimple_seq_empty_p (phi_nodes (bb
)) == phi_wanted
354 /* BB may not be a predecessor of the exit block. */
355 || single_succ (bb
) == EXIT_BLOCK_PTR_FOR_FN (cfun
)
356 /* Nor should this be an infinite loop. */
357 || single_succ (bb
) == bb
358 /* BB may not have an abnormal outgoing edge. */
359 || (single_succ_edge (bb
)->flags
& EDGE_ABNORMAL
))
362 gcc_checking_assert (bb
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
));
364 locus
= single_succ_edge (bb
)->goto_locus
;
366 /* There should not be an edge coming from entry, or an EH edge. */
371 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
372 if (e
->src
== ENTRY_BLOCK_PTR_FOR_FN (cfun
) || (e
->flags
& EDGE_EH
))
374 /* If goto_locus of any of the edges differs, prevent removing
375 the forwarder block when not optimizing. */
377 && (LOCATION_LOCUS (e
->goto_locus
) != UNKNOWN_LOCATION
378 || LOCATION_LOCUS (locus
) != UNKNOWN_LOCATION
)
379 && e
->goto_locus
!= locus
)
383 /* Now walk through the statements backward. We can ignore labels,
384 anything else means this is not a forwarder block. */
385 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
387 gimple
*stmt
= gsi_stmt (gsi
);
389 switch (gimple_code (stmt
))
392 if (DECL_NONLOCAL (gimple_label_label (as_a
<glabel
*> (stmt
))))
395 && (gimple_has_location (stmt
)
396 || LOCATION_LOCUS (locus
) != UNKNOWN_LOCATION
)
397 && gimple_location (stmt
) != locus
)
401 /* ??? For now, hope there's a corresponding debug
402 assignment at the destination. */
414 /* Protect loop headers. */
415 if (bb_loop_header_p (bb
))
418 dest
= EDGE_SUCC (bb
, 0)->dest
;
419 /* Protect loop preheaders and latches if requested. */
420 if (dest
->loop_father
->header
== dest
)
422 if (bb
->loop_father
== dest
->loop_father
)
424 if (loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES
))
426 /* If bb doesn't have a single predecessor we'd make this
427 loop have multiple latches. Don't do that if that
428 would in turn require disambiguating them. */
429 return (single_pred_p (bb
)
430 || loops_state_satisfies_p
431 (LOOPS_MAY_HAVE_MULTIPLE_LATCHES
));
433 else if (bb
->loop_father
== loop_outer (dest
->loop_father
))
434 return !loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS
);
435 /* Always preserve other edges into loop headers that are
436 not simple latches or preheaders. */
444 /* If all the PHI nodes in DEST have alternatives for E1 and E2 and
445 those alternatives are equal in each of the PHI nodes, then return
446 true, else return false. */
449 phi_alternatives_equal (basic_block dest
, edge e1
, edge e2
)
451 int n1
= e1
->dest_idx
;
452 int n2
= e2
->dest_idx
;
455 for (gsi
= gsi_start_phis (dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
457 gphi
*phi
= gsi
.phi ();
458 tree val1
= gimple_phi_arg_def (phi
, n1
);
459 tree val2
= gimple_phi_arg_def (phi
, n2
);
461 gcc_assert (val1
!= NULL_TREE
);
462 gcc_assert (val2
!= NULL_TREE
);
464 if (!operand_equal_for_phi_arg_p (val1
, val2
))
471 /* Move debug stmts from the forwarder block SRC to DEST or PRED. */
474 move_debug_stmts_from_forwarder (basic_block src
,
475 basic_block dest
, bool dest_single_pred_p
,
476 basic_block pred
, bool pred_single_succ_p
)
478 if (!MAY_HAVE_DEBUG_STMTS
)
481 /* If we cannot move to the destination but to the predecessor do that. */
482 if (!dest_single_pred_p
&& pred_single_succ_p
)
484 gimple_stmt_iterator gsi_to
= gsi_last_bb (pred
);
485 if (gsi_end_p (gsi_to
) || !stmt_ends_bb_p (gsi_stmt (gsi_to
)))
487 for (gimple_stmt_iterator gsi
= gsi_after_labels (src
);
490 gimple
*debug
= gsi_stmt (gsi
);
491 gcc_assert (is_gimple_debug (debug
));
492 gsi_move_after (&gsi
, &gsi_to
);
498 /* Else move to DEST or drop/reset them. */
499 gimple_stmt_iterator gsi_to
= gsi_after_labels (dest
);
500 for (gimple_stmt_iterator gsi
= gsi_after_labels (src
); !gsi_end_p (gsi
);)
502 gimple
*debug
= gsi_stmt (gsi
);
503 gcc_assert (is_gimple_debug (debug
));
504 /* Move debug binds anyway, but not anything else like begin-stmt
505 markers unless they are always valid at the destination. */
506 if (dest_single_pred_p
507 || gimple_debug_bind_p (debug
))
509 gsi_move_before (&gsi
, &gsi_to
);
510 /* Reset debug-binds that are not always valid at the destination.
511 Simply dropping them can cause earlier values to become live,
512 generating wrong debug information.
513 ??? There are several things we could improve here. For
514 one we might be able to move stmts to the predecessor.
515 For anther, if the debug stmt is immediately followed by a
516 (debug) definition in the destination (on a post-dominated path?)
517 we can elide it without any bad effects. */
518 if (!dest_single_pred_p
)
520 gimple_debug_bind_reset_value (debug
);
529 /* Removes forwarder block BB. Returns false if this failed. */
532 remove_forwarder_block (basic_block bb
)
534 edge succ
= single_succ_edge (bb
), e
, s
;
535 basic_block dest
= succ
->dest
;
538 gimple_stmt_iterator gsi
, gsi_to
;
540 /* We check for infinite loops already in tree_forwarder_block_p.
541 However it may happen that the infinite loop is created
542 afterwards due to removal of forwarders. */
546 /* If the destination block consists of a nonlocal label or is a
547 EH landing pad, do not merge it. */
548 stmt
= first_stmt (dest
);
550 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
551 if (DECL_NONLOCAL (gimple_label_label (label_stmt
))
552 || EH_LANDING_PAD_NR (gimple_label_label (label_stmt
)) != 0)
555 /* If there is an abnormal edge to basic block BB, but not into
556 dest, problems might occur during removal of the phi node at out
557 of ssa due to overlapping live ranges of registers.
559 If there is an abnormal edge in DEST, the problems would occur
560 anyway since cleanup_dead_labels would then merge the labels for
561 two different eh regions, and rest of exception handling code
564 So if there is an abnormal edge to BB, proceed only if there is
565 no abnormal edge to DEST and there are no phi nodes in DEST. */
566 if (bb_has_abnormal_pred (bb
)
567 && (bb_has_abnormal_pred (dest
)
568 || !gimple_seq_empty_p (phi_nodes (dest
))))
571 /* If there are phi nodes in DEST, and some of the blocks that are
572 predecessors of BB are also predecessors of DEST, check that the
573 phi node arguments match. */
574 if (!gimple_seq_empty_p (phi_nodes (dest
)))
576 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
578 s
= find_edge (e
->src
, dest
);
582 if (!phi_alternatives_equal (dest
, succ
, s
))
587 basic_block pred
= NULL
;
588 if (single_pred_p (bb
))
589 pred
= single_pred (bb
);
590 bool dest_single_pred_p
= single_pred_p (dest
);
592 /* Redirect the edges. */
593 for (ei
= ei_start (bb
->preds
); (e
= ei_safe_edge (ei
)); )
595 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
597 if (e
->flags
& EDGE_ABNORMAL
)
599 /* If there is an abnormal edge, redirect it anyway, and
600 move the labels to the new block to make it legal. */
601 s
= redirect_edge_succ_nodup (e
, dest
);
604 s
= redirect_edge_and_branch (e
, dest
);
608 /* Create arguments for the phi nodes, since the edge was not
610 for (gphi_iterator psi
= gsi_start_phis (dest
);
614 gphi
*phi
= psi
.phi ();
615 location_t l
= gimple_phi_arg_location_from_edge (phi
, succ
);
616 tree def
= gimple_phi_arg_def (phi
, succ
->dest_idx
);
617 add_phi_arg (phi
, unshare_expr (def
), s
, l
);
622 /* Move nonlocal labels and computed goto targets as well as user
623 defined labels and labels with an EH landing pad number to the
624 new block, so that the redirection of the abnormal edges works,
625 jump targets end up in a sane place and debug information for
626 labels is retained. */
627 gsi_to
= gsi_start_bb (dest
);
628 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); )
630 stmt
= gsi_stmt (gsi
);
631 if (is_gimple_debug (stmt
))
634 /* Forwarder blocks can only contain labels and debug stmts, and
635 labels must come first, so if we get to this point, we know
636 we're looking at a label. */
637 tree decl
= gimple_label_label (as_a
<glabel
*> (stmt
));
638 if (EH_LANDING_PAD_NR (decl
) != 0
639 || DECL_NONLOCAL (decl
)
640 || FORCED_LABEL (decl
)
641 || !DECL_ARTIFICIAL (decl
))
642 gsi_move_before (&gsi
, &gsi_to
);
647 /* Move debug statements. Reset them if the destination does not
648 have a single predecessor. */
649 move_debug_stmts_from_forwarder (bb
, dest
, dest_single_pred_p
,
650 pred
, pred
&& single_succ_p (pred
));
652 bitmap_set_bit (cfgcleanup_altered_bbs
, dest
->index
);
654 /* Update the dominators. */
655 if (dom_info_available_p (CDI_DOMINATORS
))
657 basic_block dom
, dombb
, domdest
;
659 dombb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
660 domdest
= get_immediate_dominator (CDI_DOMINATORS
, dest
);
663 /* Shortcut to avoid calling (relatively expensive)
664 nearest_common_dominator unless necessary. */
668 dom
= nearest_common_dominator (CDI_DOMINATORS
, domdest
, dombb
);
670 set_immediate_dominator (CDI_DOMINATORS
, dest
, dom
);
673 /* Adjust latch infomation of BB's parent loop as otherwise
674 the cfg hook has a hard time not to kill the loop. */
675 if (current_loops
&& bb
->loop_father
->latch
== bb
)
676 bb
->loop_father
->latch
= pred
;
678 /* And kill the forwarder block. */
679 delete_basic_block (bb
);
684 /* STMT is a call that has been discovered noreturn. Split the
685 block to prepare fixing up the CFG and remove LHS.
686 Return true if cleanup-cfg needs to run. */
689 fixup_noreturn_call (gimple
*stmt
)
691 basic_block bb
= gimple_bb (stmt
);
692 bool changed
= false;
694 if (gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
697 /* First split basic block if stmt is not last. */
698 if (stmt
!= gsi_stmt (gsi_last_bb (bb
)))
700 if (stmt
== gsi_stmt (gsi_last_nondebug_bb (bb
)))
702 /* Don't split if there are only debug stmts
703 after stmt, that can result in -fcompare-debug
704 failures. Remove the debug stmts instead,
705 they should be all unreachable anyway. */
706 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
707 for (gsi_next (&gsi
); !gsi_end_p (gsi
); )
708 gsi_remove (&gsi
, true);
712 split_block (bb
, stmt
);
717 /* If there is an LHS, remove it, but only if its type has fixed size.
718 The LHS will need to be recreated during RTL expansion and creating
719 temporaries of variable-sized types is not supported. Also don't
720 do this with TREE_ADDRESSABLE types, as assign_temp will abort.
721 Drop LHS regardless of TREE_ADDRESSABLE, if the function call
722 has been changed into a call that does not return a value, like
723 __builtin_unreachable or __cxa_pure_virtual. */
724 tree lhs
= gimple_call_lhs (stmt
);
726 && (should_remove_lhs_p (lhs
)
727 || VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (stmt
)))))
729 gimple_call_set_lhs (stmt
, NULL_TREE
);
731 /* We need to fix up the SSA name to avoid checking errors. */
732 if (TREE_CODE (lhs
) == SSA_NAME
)
734 tree new_var
= create_tmp_reg (TREE_TYPE (lhs
));
735 SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs
, new_var
);
736 SSA_NAME_DEF_STMT (lhs
) = gimple_build_nop ();
737 set_ssa_default_def (cfun
, new_var
, lhs
);
743 /* Mark the call as altering control flow. */
744 if (!gimple_call_ctrl_altering_p (stmt
))
746 gimple_call_set_ctrl_altering (stmt
, true);
753 /* Return true if we want to merge BB1 and BB2 into a single block. */
756 want_merge_blocks_p (basic_block bb1
, basic_block bb2
)
758 if (!can_merge_blocks_p (bb1
, bb2
))
760 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb1
);
761 if (gsi_end_p (gsi
) || !stmt_can_terminate_bb_p (gsi_stmt (gsi
)))
763 return bb1
->count
.ok_for_merging (bb2
->count
);
767 /* Tries to cleanup cfg in basic block BB by merging blocks. Returns
768 true if anything changes. */
771 cleanup_tree_cfg_bb (basic_block bb
)
773 if (tree_forwarder_block_p (bb
, false)
774 && remove_forwarder_block (bb
))
777 /* If there is a merge opportunity with the predecessor
778 do nothing now but wait until we process the predecessor.
779 This happens when we visit BBs in a non-optimal order and
780 avoids quadratic behavior with adjusting stmts BB pointer. */
781 if (single_pred_p (bb
)
782 && want_merge_blocks_p (single_pred (bb
), bb
))
783 /* But make sure we _do_ visit it. When we remove unreachable paths
784 ending in a backedge we fail to mark the destinations predecessors
786 bitmap_set_bit (cfgcleanup_altered_bbs
, single_pred (bb
)->index
);
788 /* Merging the blocks may create new opportunities for folding
789 conditional branches (due to the elimination of single-valued PHI
791 else if (single_succ_p (bb
)
792 && want_merge_blocks_p (bb
, single_succ (bb
)))
794 merge_blocks (bb
, single_succ (bb
));
801 /* Return true if E is an EDGE_ABNORMAL edge for returns_twice calls,
802 i.e. one going from .ABNORMAL_DISPATCHER to basic block which doesn't
803 start with a forced or nonlocal label. Calls which return twice can return
804 the second time only if they are called normally the first time, so basic
805 blocks which can be only entered through these abnormal edges but not
806 normally are effectively unreachable as well. Additionally ignore
807 __builtin_setjmp_receiver starting blocks, which have one FORCED_LABEL
808 and which are always only reachable through EDGE_ABNORMAL edge. They are
809 handled in cleanup_control_flow_pre. */
812 maybe_dead_abnormal_edge_p (edge e
)
814 if ((e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)) != EDGE_ABNORMAL
)
817 gimple_stmt_iterator gsi
= gsi_start_nondebug_after_labels_bb (e
->src
);
818 gimple
*g
= gsi_stmt (gsi
);
819 if (!g
|| !gimple_call_internal_p (g
, IFN_ABNORMAL_DISPATCHER
))
822 tree target
= NULL_TREE
;
823 for (gsi
= gsi_start_bb (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
824 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
)))
826 tree this_target
= gimple_label_label (label_stmt
);
827 if (DECL_NONLOCAL (this_target
))
829 if (FORCED_LABEL (this_target
))
833 target
= this_target
;
841 /* If there was a single FORCED_LABEL, check for
842 __builtin_setjmp_receiver with address of that label. */
843 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
844 gsi_next_nondebug (&gsi
);
847 if (!gimple_call_builtin_p (gsi_stmt (gsi
), BUILT_IN_SETJMP_RECEIVER
))
850 tree arg
= gimple_call_arg (gsi_stmt (gsi
), 0);
851 if (TREE_CODE (arg
) != ADDR_EXPR
|| TREE_OPERAND (arg
, 0) != target
)
857 /* If BB is a basic block ending with __builtin_setjmp_setup, return edge
858 from .ABNORMAL_DISPATCHER basic block to corresponding
859 __builtin_setjmp_receiver basic block, otherwise return NULL. */
861 builtin_setjmp_setup_bb (basic_block bb
)
863 if (EDGE_COUNT (bb
->succs
) != 2
864 || ((EDGE_SUCC (bb
, 0)->flags
865 & (EDGE_ABNORMAL
| EDGE_EH
)) != EDGE_ABNORMAL
866 && (EDGE_SUCC (bb
, 1)->flags
867 & (EDGE_ABNORMAL
| EDGE_EH
)) != EDGE_ABNORMAL
))
870 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
872 || !gimple_call_builtin_p (gsi_stmt (gsi
), BUILT_IN_SETJMP_SETUP
))
875 tree arg
= gimple_call_arg (gsi_stmt (gsi
), 1);
876 if (TREE_CODE (arg
) != ADDR_EXPR
877 || TREE_CODE (TREE_OPERAND (arg
, 0)) != LABEL_DECL
)
880 basic_block recv_bb
= label_to_block (cfun
, TREE_OPERAND (arg
, 0));
881 if (EDGE_COUNT (recv_bb
->preds
) != 1
882 || (EDGE_PRED (recv_bb
, 0)->flags
883 & (EDGE_ABNORMAL
| EDGE_EH
)) != EDGE_ABNORMAL
884 || (EDGE_SUCC (bb
, 0)->dest
!= EDGE_PRED (recv_bb
, 0)->src
885 && EDGE_SUCC (bb
, 1)->dest
!= EDGE_PRED (recv_bb
, 0)->src
))
888 /* EDGE_PRED (recv_bb, 0)->src should be the .ABNORMAL_DISPATCHER bb. */
889 return EDGE_PRED (recv_bb
, 0);
892 /* Do cleanup_control_flow_bb in PRE order. */
895 cleanup_control_flow_pre ()
899 /* We want remove_edge_and_dominated_blocks to only remove edges,
900 not dominated blocks which it does when dom info isn't available.
902 dom_state saved_state
= dom_info_state (CDI_DOMINATORS
);
903 set_dom_info_availability (CDI_DOMINATORS
, DOM_NONE
);
905 auto_vec
<edge_iterator
, 20> stack (n_basic_blocks_for_fn (cfun
) + 2);
906 auto_sbitmap
visited (last_basic_block_for_fn (cfun
));
907 bitmap_clear (visited
);
909 vec
<edge
, va_gc
> *setjmp_vec
= NULL
;
910 auto_vec
<basic_block
, 4> abnormal_dispatchers
;
912 stack
.quick_push (ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
));
914 while (! stack
.is_empty ())
916 /* Look at the edge on the top of the stack. */
917 edge_iterator ei
= stack
.last ();
918 basic_block dest
= ei_edge (ei
)->dest
;
920 if (dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
)
921 && !bitmap_bit_p (visited
, dest
->index
)
922 && (ei_container (ei
) == setjmp_vec
923 || !maybe_dead_abnormal_edge_p (ei_edge (ei
))))
925 bitmap_set_bit (visited
, dest
->index
);
926 /* We only possibly remove edges from DEST here, leaving
927 possibly unreachable code in the IL. */
928 retval
|= cleanup_control_flow_bb (dest
);
930 /* Check for __builtin_setjmp_setup. Edges from .ABNORMAL_DISPATCH
931 to __builtin_setjmp_receiver will be normally ignored by
932 maybe_dead_abnormal_edge_p. If DEST is a visited
933 __builtin_setjmp_setup, queue edge from .ABNORMAL_DISPATCH
934 to __builtin_setjmp_receiver, so that it will be visited too. */
935 if (edge e
= builtin_setjmp_setup_bb (dest
))
937 vec_safe_push (setjmp_vec
, e
);
938 if (vec_safe_length (setjmp_vec
) == 1)
939 stack
.quick_push (ei_start (setjmp_vec
));
942 if ((ei_edge (ei
)->flags
943 & (EDGE_ABNORMAL
| EDGE_EH
)) == EDGE_ABNORMAL
)
945 gimple_stmt_iterator gsi
946 = gsi_start_nondebug_after_labels_bb (dest
);
947 gimple
*g
= gsi_stmt (gsi
);
948 if (g
&& gimple_call_internal_p (g
, IFN_ABNORMAL_DISPATCHER
))
949 abnormal_dispatchers
.safe_push (dest
);
952 if (EDGE_COUNT (dest
->succs
) > 0)
953 stack
.quick_push (ei_start (dest
->succs
));
957 if (!ei_one_before_end_p (ei
))
958 ei_next (&stack
.last ());
961 if (ei_container (ei
) == setjmp_vec
)
962 vec_safe_truncate (setjmp_vec
, 0);
968 vec_free (setjmp_vec
);
970 /* If we've marked .ABNORMAL_DISPATCHER basic block(s) as visited
971 above, but haven't marked any of their successors as visited,
972 unmark them now, so that they can be removed as useless. */
973 for (basic_block dispatcher_bb
: abnormal_dispatchers
)
977 FOR_EACH_EDGE (e
, ei
, dispatcher_bb
->succs
)
978 if (bitmap_bit_p (visited
, e
->dest
->index
))
981 bitmap_clear_bit (visited
, dispatcher_bb
->index
);
984 set_dom_info_availability (CDI_DOMINATORS
, saved_state
);
986 /* We are deleting BBs in non-reverse dominator order, make sure
987 insert_debug_temps_for_defs is prepared for that. */
989 free_dominance_info (CDI_DOMINATORS
);
991 /* Remove all now (and previously) unreachable blocks. */
992 for (int i
= NUM_FIXED_BLOCKS
; i
< last_basic_block_for_fn (cfun
); ++i
)
994 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
995 if (bb
&& !bitmap_bit_p (visited
, bb
->index
))
998 free_dominance_info (CDI_DOMINATORS
);
999 delete_basic_block (bb
);
1008 mfb_keep_latches (edge e
)
1010 return !((dom_info_available_p (CDI_DOMINATORS
)
1011 && dominated_by_p (CDI_DOMINATORS
, e
->src
, e
->dest
))
1012 || (e
->flags
& EDGE_DFS_BACK
));
1015 /* Remove unreachable blocks and other miscellaneous clean up work.
1016 Return true if the flowgraph was modified, false otherwise. */
1019 cleanup_tree_cfg_noloop (unsigned ssa_update_flags
)
1021 timevar_push (TV_TREE_CLEANUP_CFG
);
1023 /* Ensure that we have single entries into loop headers. Otherwise
1024 if one of the entries is becoming a latch due to CFG cleanup
1025 (from formerly being part of an irreducible region) then we mess
1026 up loop fixup and associate the old loop with a different region
1027 which makes niter upper bounds invalid. See for example PR80549.
1028 This needs to be done before we remove trivially dead edges as
1029 we need to capture the dominance state before the pending transform. */
1032 /* This needs backedges or dominators. */
1033 if (!dom_info_available_p (CDI_DOMINATORS
))
1034 mark_dfs_back_edges ();
1036 for (loop_p loop
: *get_loops (cfun
))
1037 if (loop
&& loop
->header
)
1039 basic_block bb
= loop
->header
;
1042 bool found_latch
= false;
1043 bool any_abnormal
= false;
1045 /* We are only interested in preserving existing loops, but
1046 we need to check whether they are still real and of course
1047 if we need to add a preheader at all. */
1048 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1050 if (e
->flags
& EDGE_ABNORMAL
)
1052 any_abnormal
= true;
1055 if ((dom_info_available_p (CDI_DOMINATORS
)
1056 && dominated_by_p (CDI_DOMINATORS
, e
->src
, bb
))
1057 || (e
->flags
& EDGE_DFS_BACK
))
1064 /* If we have more than one entry to the loop header
1065 create a forwarder. */
1066 if (found_latch
&& ! any_abnormal
&& n
> 1)
1068 edge fallthru
= make_forwarder_block (bb
, mfb_keep_latches
,
1070 loop
->header
= fallthru
->dest
;
1071 if (! loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
1073 /* The loop updating from the CFG hook is incomplete
1074 when we have multiple latches, fixup manually. */
1075 remove_bb_from_loops (fallthru
->src
);
1076 loop_p cloop
= loop
;
1077 FOR_EACH_EDGE (e
, ei
, fallthru
->src
->preds
)
1078 cloop
= find_common_loop (cloop
, e
->src
->loop_father
);
1079 add_bb_to_loop (fallthru
->src
, cloop
);
1085 /* Prepare the worklists of altered blocks. */
1086 cfgcleanup_altered_bbs
= BITMAP_ALLOC (NULL
);
1088 /* Start by iterating over all basic blocks in PRE order looking for
1089 edge removal opportunities. Do this first because incoming SSA form
1090 may be invalid and we want to avoid performing SSA related tasks such
1091 as propgating out a PHI node during BB merging in that state. This
1092 also gets rid of unreachable blocks. */
1093 bool changed
= cleanup_control_flow_pre ();
1095 /* After doing the above SSA form should be valid (or an update SSA
1096 should be required). */
1097 if (ssa_update_flags
)
1099 timevar_pop (TV_TREE_CLEANUP_CFG
);
1100 update_ssa (ssa_update_flags
);
1101 timevar_push (TV_TREE_CLEANUP_CFG
);
1104 /* Compute dominator info which we need for the iterative process below. */
1105 if (!dom_info_available_p (CDI_DOMINATORS
))
1106 calculate_dominance_info (CDI_DOMINATORS
);
1108 checking_verify_dominators (CDI_DOMINATORS
);
1110 /* During forwarder block cleanup, we may redirect edges out of
1111 SWITCH_EXPRs, which can get expensive. So we want to enable
1112 recording of edge to CASE_LABEL_EXPR. */
1113 start_recording_case_labels ();
1115 /* Continue by iterating over all basic blocks looking for BB merging
1116 opportunities. We cannot use FOR_EACH_BB_FN for the BB iteration
1117 since the basic blocks may get removed. */
1118 unsigned n
= last_basic_block_for_fn (cfun
);
1119 for (unsigned i
= NUM_FIXED_BLOCKS
; i
< n
; i
++)
1121 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
1123 changed
|= cleanup_tree_cfg_bb (bb
);
1126 /* Now process the altered blocks, as long as any are available. */
1127 while (!bitmap_empty_p (cfgcleanup_altered_bbs
))
1129 unsigned i
= bitmap_first_set_bit (cfgcleanup_altered_bbs
);
1130 bitmap_clear_bit (cfgcleanup_altered_bbs
, i
);
1131 if (i
< NUM_FIXED_BLOCKS
)
1134 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
1138 /* BB merging done by cleanup_tree_cfg_bb can end up propagating
1139 out single-argument PHIs which in turn can expose
1140 cleanup_control_flow_bb opportunities so we have to repeat
1142 changed
|= cleanup_control_flow_bb (bb
);
1143 changed
|= cleanup_tree_cfg_bb (bb
);
1146 end_recording_case_labels ();
1147 BITMAP_FREE (cfgcleanup_altered_bbs
);
1149 gcc_assert (dom_info_available_p (CDI_DOMINATORS
));
1151 /* Do not renumber blocks if the SCEV cache is active, it is indexed by
1152 basic-block numbers. */
1153 if (! scev_initialized_p ())
1156 checking_verify_flow_info ();
1158 timevar_pop (TV_TREE_CLEANUP_CFG
);
1160 if (changed
&& current_loops
)
1162 /* Removing edges and/or blocks may make recorded bounds refer
1163 to stale GIMPLE stmts now, so clear them. */
1164 free_numbers_of_iterations_estimates (cfun
);
1165 loops_state_set (LOOPS_NEED_FIXUP
);
1171 /* Repairs loop structures. */
1174 repair_loop_structures (void)
1177 unsigned n_new_or_deleted_loops
;
1179 calculate_dominance_info (CDI_DOMINATORS
);
1181 timevar_push (TV_REPAIR_LOOPS
);
1182 changed_bbs
= BITMAP_ALLOC (NULL
);
1183 n_new_or_deleted_loops
= fix_loop_structure (changed_bbs
);
1185 /* This usually does nothing. But sometimes parts of cfg that originally
1186 were inside a loop get out of it due to edge removal (since they
1187 become unreachable by back edges from latch). Also a former
1188 irreducible loop can become reducible - in this case force a full
1189 rewrite into loop-closed SSA form. */
1190 if (loops_state_satisfies_p (LOOP_CLOSED_SSA
)
1191 && (!bitmap_empty_p (changed_bbs
) || n_new_or_deleted_loops
))
1192 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
1194 BITMAP_FREE (changed_bbs
);
1196 checking_verify_loop_structure ();
1199 timevar_pop (TV_REPAIR_LOOPS
);
1202 /* Cleanup cfg and repair loop structures. */
1205 cleanup_tree_cfg (unsigned ssa_update_flags
)
1207 bool changed
= cleanup_tree_cfg_noloop (ssa_update_flags
);
1209 if (current_loops
!= NULL
1210 && loops_state_satisfies_p (LOOPS_NEED_FIXUP
))
1211 repair_loop_structures ();
1216 /* Tries to merge the PHI nodes at BB into those at BB's sole successor.
1217 Returns true if successful. */
1220 remove_forwarder_block_with_phi (basic_block bb
)
1222 edge succ
= single_succ_edge (bb
);
1223 basic_block dest
= succ
->dest
;
1225 basic_block dombb
, domdest
, dom
;
1227 /* We check for infinite loops already in tree_forwarder_block_p.
1228 However it may happen that the infinite loop is created
1229 afterwards due to removal of forwarders. */
1233 /* Removal of forwarders may expose new natural loops and thus
1234 a block may turn into a loop header. */
1235 if (current_loops
&& bb_loop_header_p (bb
))
1238 /* If the destination block consists of a nonlocal label, do not
1240 label
= first_stmt (dest
);
1242 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (label
))
1243 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
1246 /* Record BB's single pred in case we need to update the father
1247 loop's latch information later. */
1248 basic_block pred
= NULL
;
1249 if (single_pred_p (bb
))
1250 pred
= single_pred (bb
);
1251 bool dest_single_pred_p
= single_pred_p (dest
);
1253 /* Redirect each incoming edge to BB to DEST. */
1254 while (EDGE_COUNT (bb
->preds
) > 0)
1256 edge e
= EDGE_PRED (bb
, 0), s
;
1259 s
= find_edge (e
->src
, dest
);
1262 /* We already have an edge S from E->src to DEST. If S and
1263 E->dest's sole successor edge have the same PHI arguments
1264 at DEST, redirect S to DEST. */
1265 if (phi_alternatives_equal (dest
, s
, succ
))
1267 e
= redirect_edge_and_branch (e
, dest
);
1268 redirect_edge_var_map_clear (e
);
1272 /* PHI arguments are different. Create a forwarder block by
1273 splitting E so that we can merge PHI arguments on E to
1275 e
= single_succ_edge (split_edge (e
));
1279 /* If we merge the forwarder into a loop header verify if we
1280 are creating another loop latch edge. If so, reset
1281 number of iteration information of the loop. */
1282 if (dest
->loop_father
->header
== dest
1283 && dominated_by_p (CDI_DOMINATORS
, e
->src
, dest
))
1285 dest
->loop_father
->any_upper_bound
= false;
1286 dest
->loop_father
->any_likely_upper_bound
= false;
1287 free_numbers_of_iterations_estimates (dest
->loop_father
);
1291 s
= redirect_edge_and_branch (e
, dest
);
1293 /* redirect_edge_and_branch must not create a new edge. */
1294 gcc_assert (s
== e
);
1296 /* Add to the PHI nodes at DEST each PHI argument removed at the
1297 destination of E. */
1298 for (gsi
= gsi_start_phis (dest
);
1302 gphi
*phi
= gsi
.phi ();
1303 tree def
= gimple_phi_arg_def (phi
, succ
->dest_idx
);
1304 location_t locus
= gimple_phi_arg_location_from_edge (phi
, succ
);
1306 if (TREE_CODE (def
) == SSA_NAME
)
1308 /* If DEF is one of the results of PHI nodes removed during
1309 redirection, replace it with the PHI argument that used
1311 vec
<edge_var_map
> *head
= redirect_edge_var_map_vector (e
);
1312 size_t length
= head
? head
->length () : 0;
1313 for (size_t i
= 0; i
< length
; i
++)
1315 edge_var_map
*vm
= &(*head
)[i
];
1316 tree old_arg
= redirect_edge_var_map_result (vm
);
1317 tree new_arg
= redirect_edge_var_map_def (vm
);
1322 locus
= redirect_edge_var_map_location (vm
);
1328 add_phi_arg (phi
, def
, s
, locus
);
1331 redirect_edge_var_map_clear (e
);
1334 /* Move debug statements. Reset them if the destination does not
1335 have a single predecessor. */
1336 move_debug_stmts_from_forwarder (bb
, dest
, dest_single_pred_p
,
1337 pred
, pred
&& single_succ_p (pred
));
1339 /* Update the dominators. */
1340 dombb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
1341 domdest
= get_immediate_dominator (CDI_DOMINATORS
, dest
);
1344 /* Shortcut to avoid calling (relatively expensive)
1345 nearest_common_dominator unless necessary. */
1349 dom
= nearest_common_dominator (CDI_DOMINATORS
, domdest
, dombb
);
1351 set_immediate_dominator (CDI_DOMINATORS
, dest
, dom
);
1353 /* Adjust latch infomation of BB's parent loop as otherwise
1354 the cfg hook has a hard time not to kill the loop. */
1355 if (current_loops
&& bb
->loop_father
->latch
== bb
)
1356 bb
->loop_father
->latch
= pred
;
1358 /* Remove BB since all of BB's incoming edges have been redirected
1360 delete_basic_block (bb
);
1365 /* This pass merges PHI nodes if one feeds into another. For example,
1366 suppose we have the following:
1373 # tem_6 = PHI <tem_17(8), tem_23(7)>;
1376 # tem_3 = PHI <tem_6(9), tem_2(5)>;
1379 Then we merge the first PHI node into the second one like so:
1381 goto <bb 9> (<L10>);
1386 # tem_3 = PHI <tem_23(7), tem_2(5), tem_17(8)>;
1392 const pass_data pass_data_merge_phi
=
1394 GIMPLE_PASS
, /* type */
1395 "mergephi", /* name */
1396 OPTGROUP_NONE
, /* optinfo_flags */
1397 TV_TREE_MERGE_PHI
, /* tv_id */
1398 ( PROP_cfg
| PROP_ssa
), /* properties_required */
1399 0, /* properties_provided */
1400 0, /* properties_destroyed */
1401 0, /* todo_flags_start */
1402 0, /* todo_flags_finish */
1405 class pass_merge_phi
: public gimple_opt_pass
1408 pass_merge_phi (gcc::context
*ctxt
)
1409 : gimple_opt_pass (pass_data_merge_phi
, ctxt
)
1412 /* opt_pass methods: */
1413 opt_pass
* clone () final override
{ return new pass_merge_phi (m_ctxt
); }
1414 unsigned int execute (function
*) final override
;
1416 }; // class pass_merge_phi
1419 pass_merge_phi::execute (function
*fun
)
1421 basic_block
*worklist
= XNEWVEC (basic_block
, n_basic_blocks_for_fn (fun
));
1422 basic_block
*current
= worklist
;
1425 calculate_dominance_info (CDI_DOMINATORS
);
1427 /* Find all PHI nodes that we may be able to merge. */
1428 FOR_EACH_BB_FN (bb
, fun
)
1432 /* Look for a forwarder block with PHI nodes. */
1433 if (!tree_forwarder_block_p (bb
, true))
1436 dest
= single_succ (bb
);
1438 /* We have to feed into another basic block with PHI
1440 if (gimple_seq_empty_p (phi_nodes (dest
))
1441 /* We don't want to deal with a basic block with
1443 || bb_has_abnormal_pred (bb
))
1446 if (!dominated_by_p (CDI_DOMINATORS
, dest
, bb
))
1448 /* If BB does not dominate DEST, then the PHI nodes at
1449 DEST must be the only users of the results of the PHI
1456 unsigned int dest_idx
= single_succ_edge (bb
)->dest_idx
;
1458 /* BB dominates DEST. There may be many users of the PHI
1459 nodes in BB. However, there is still a trivial case we
1460 can handle. If the result of every PHI in BB is used
1461 only by a PHI in DEST, then we can trivially merge the
1462 PHI nodes from BB into DEST. */
1463 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
1466 gphi
*phi
= gsi
.phi ();
1467 tree result
= gimple_phi_result (phi
);
1468 use_operand_p imm_use
;
1471 /* If the PHI's result is never used, then we can just
1473 if (has_zero_uses (result
))
1476 /* Get the single use of the result of this PHI node. */
1477 if (!single_imm_use (result
, &imm_use
, &use_stmt
)
1478 || gimple_code (use_stmt
) != GIMPLE_PHI
1479 || gimple_bb (use_stmt
) != dest
1480 || gimple_phi_arg_def (use_stmt
, dest_idx
) != result
)
1484 /* If the loop above iterated through all the PHI nodes
1485 in BB, then we can merge the PHIs from BB into DEST. */
1486 if (gsi_end_p (gsi
))
1491 /* Now let's drain WORKLIST. */
1492 bool changed
= false;
1493 while (current
!= worklist
)
1496 changed
|= remove_forwarder_block_with_phi (bb
);
1500 /* Removing forwarder blocks can cause formerly irreducible loops
1501 to become reducible if we merged two entry blocks. */
1504 loops_state_set (LOOPS_NEED_FIXUP
);
1512 make_pass_merge_phi (gcc::context
*ctxt
)
1514 return new pass_merge_phi (ctxt
);
1517 /* Pass: cleanup the CFG just before expanding trees to RTL.
1518 This is just a round of label cleanups and case node grouping
1519 because after the tree optimizers have run such cleanups may
1523 execute_cleanup_cfg_post_optimizing (void)
1525 unsigned int todo
= execute_fixup_cfg ();
1526 if (cleanup_tree_cfg ())
1528 todo
&= ~TODO_cleanup_cfg
;
1529 todo
|= TODO_update_ssa
;
1531 maybe_remove_unreachable_handlers ();
1532 cleanup_dead_labels ();
1533 if (group_case_labels ())
1534 todo
|= TODO_cleanup_cfg
;
1535 if ((flag_compare_debug_opt
|| flag_compare_debug
)
1536 && flag_dump_final_insns
)
1538 FILE *final_output
= fopen (flag_dump_final_insns
, "a");
1542 error ("could not open final insn dump file %qs: %m",
1543 flag_dump_final_insns
);
1544 flag_dump_final_insns
= NULL
;
1548 int save_unnumbered
= flag_dump_unnumbered
;
1549 int save_noaddr
= flag_dump_noaddr
;
1551 flag_dump_noaddr
= flag_dump_unnumbered
= 1;
1552 fprintf (final_output
, "\n");
1553 dump_enumerated_decls (final_output
,
1554 dump_flags
| TDF_SLIM
| TDF_NOUID
);
1555 flag_dump_noaddr
= save_noaddr
;
1556 flag_dump_unnumbered
= save_unnumbered
;
1557 if (fclose (final_output
))
1559 error ("could not close final insn dump file %qs: %m",
1560 flag_dump_final_insns
);
1561 flag_dump_final_insns
= NULL
;
1570 const pass_data pass_data_cleanup_cfg_post_optimizing
=
1572 GIMPLE_PASS
, /* type */
1573 "optimized", /* name */
1574 OPTGROUP_NONE
, /* optinfo_flags */
1575 TV_TREE_CLEANUP_CFG
, /* tv_id */
1576 PROP_cfg
, /* properties_required */
1577 0, /* properties_provided */
1578 0, /* properties_destroyed */
1579 0, /* todo_flags_start */
1580 TODO_remove_unused_locals
, /* todo_flags_finish */
1583 class pass_cleanup_cfg_post_optimizing
: public gimple_opt_pass
1586 pass_cleanup_cfg_post_optimizing (gcc::context
*ctxt
)
1587 : gimple_opt_pass (pass_data_cleanup_cfg_post_optimizing
, ctxt
)
1590 /* opt_pass methods: */
1591 unsigned int execute (function
*) final override
1593 return execute_cleanup_cfg_post_optimizing ();
1596 }; // class pass_cleanup_cfg_post_optimizing
1601 make_pass_cleanup_cfg_post_optimizing (gcc::context
*ctxt
)
1603 return new pass_cleanup_cfg_post_optimizing (ctxt
);
1607 /* Delete all unreachable basic blocks and update callgraph.
1608 Doing so is somewhat nontrivial because we need to update all clones and
1609 remove inline function that become unreachable. */
1612 delete_unreachable_blocks_update_callgraph (cgraph_node
*dst_node
,
1615 bool changed
= false;
1616 basic_block b
, next_bb
;
1618 find_unreachable_blocks ();
1620 /* Delete all unreachable basic blocks. */
1622 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
1623 != EXIT_BLOCK_PTR_FOR_FN (cfun
); b
= next_bb
)
1625 next_bb
= b
->next_bb
;
1627 if (!(b
->flags
& BB_REACHABLE
))
1629 gimple_stmt_iterator bsi
;
1631 for (bsi
= gsi_start_bb (b
); !gsi_end_p (bsi
); gsi_next (&bsi
))
1633 struct cgraph_edge
*e
;
1634 struct cgraph_node
*node
;
1636 dst_node
->remove_stmt_references (gsi_stmt (bsi
));
1638 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
1639 &&(e
= dst_node
->get_edge (gsi_stmt (bsi
))) != NULL
)
1641 if (!e
->inline_failed
)
1642 e
->callee
->remove_symbol_and_inline_clones (dst_node
);
1644 cgraph_edge::remove (e
);
1646 if (update_clones
&& dst_node
->clones
)
1647 for (node
= dst_node
->clones
; node
!= dst_node
;)
1649 node
->remove_stmt_references (gsi_stmt (bsi
));
1650 if (gimple_code (gsi_stmt (bsi
)) == GIMPLE_CALL
1651 && (e
= node
->get_edge (gsi_stmt (bsi
))) != NULL
)
1653 if (!e
->inline_failed
)
1654 e
->callee
->remove_symbol_and_inline_clones (dst_node
);
1656 cgraph_edge::remove (e
);
1660 node
= node
->clones
;
1661 else if (node
->next_sibling_clone
)
1662 node
= node
->next_sibling_clone
;
1665 while (node
!= dst_node
&& !node
->next_sibling_clone
)
1666 node
= node
->clone_of
;
1667 if (node
!= dst_node
)
1668 node
= node
->next_sibling_clone
;
1672 delete_basic_block (b
);