1 /* Control flow optimization code for GNU compiler.
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
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/>. */
20 /* This file contains optimizer of the control flow. The main entry point is
21 cleanup_cfg. Following optimizations are performed:
23 - Unreachable blocks removal
24 - Edge forwarding (edge to the forwarder block is forwarded to its
25 successor. Simplification of the branch instruction is performed by
26 underlying infrastructure so branch can be converted to simplejump or
28 - Cross jumping (tail merging)
29 - Conditional jump-around-simplejump simplification
30 - Basic block merging. */
34 #include "coretypes.h"
38 #include "hard-reg-set.h"
40 #include "insn-config.h"
43 #include "diagnostic-core.h"
48 #include "function.h" /* For inline functions in emit-rtl.h they need crtl. */
50 #include "tree-pass.h"
58 #define FORWARDER_BLOCK_P(BB) ((BB)->flags & BB_FORWARDER_BLOCK)
60 /* Set to true when we are running first pass of try_optimize_cfg loop. */
61 static bool first_pass
;
63 /* Set to true if crossjumps occurred in the latest run of try_optimize_cfg. */
64 static bool crossjumps_occured
;
66 /* Set to true if we couldn't run an optimization due to stale liveness
67 information; we should run df_analyze to enable more opportunities. */
68 static bool block_was_dirty
;
70 static bool try_crossjump_to_edge (int, edge
, edge
, enum replace_direction
);
71 static bool try_crossjump_bb (int, basic_block
);
72 static bool outgoing_edges_match (int, basic_block
, basic_block
);
73 static enum replace_direction
old_insns_match_p (int, rtx
, rtx
);
75 static void merge_blocks_move_predecessor_nojumps (basic_block
, basic_block
);
76 static void merge_blocks_move_successor_nojumps (basic_block
, basic_block
);
77 static bool try_optimize_cfg (int);
78 static bool try_simplify_condjump (basic_block
);
79 static bool try_forward_edges (int, basic_block
);
80 static edge
thread_jump (edge
, basic_block
);
81 static bool mark_effect (rtx
, bitmap
);
82 static void notice_new_block (basic_block
);
83 static void update_forwarder_flag (basic_block
);
84 static int mentions_nonequal_regs (rtx
*, void *);
85 static void merge_memattrs (rtx
, rtx
);
87 /* Set flags for newly created block. */
90 notice_new_block (basic_block bb
)
95 if (forwarder_block_p (bb
))
96 bb
->flags
|= BB_FORWARDER_BLOCK
;
99 /* Recompute forwarder flag after block has been modified. */
102 update_forwarder_flag (basic_block bb
)
104 if (forwarder_block_p (bb
))
105 bb
->flags
|= BB_FORWARDER_BLOCK
;
107 bb
->flags
&= ~BB_FORWARDER_BLOCK
;
110 /* Simplify a conditional jump around an unconditional jump.
111 Return true if something changed. */
114 try_simplify_condjump (basic_block cbranch_block
)
116 basic_block jump_block
, jump_dest_block
, cbranch_dest_block
;
117 edge cbranch_jump_edge
, cbranch_fallthru_edge
;
120 /* Verify that there are exactly two successors. */
121 if (EDGE_COUNT (cbranch_block
->succs
) != 2)
124 /* Verify that we've got a normal conditional branch at the end
126 cbranch_insn
= BB_END (cbranch_block
);
127 if (!any_condjump_p (cbranch_insn
))
130 cbranch_fallthru_edge
= FALLTHRU_EDGE (cbranch_block
);
131 cbranch_jump_edge
= BRANCH_EDGE (cbranch_block
);
133 /* The next block must not have multiple predecessors, must not
134 be the last block in the function, and must contain just the
135 unconditional jump. */
136 jump_block
= cbranch_fallthru_edge
->dest
;
137 if (!single_pred_p (jump_block
)
138 || jump_block
->next_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
139 || !FORWARDER_BLOCK_P (jump_block
))
141 jump_dest_block
= single_succ (jump_block
);
143 /* If we are partitioning hot/cold basic blocks, we don't want to
144 mess up unconditional or indirect jumps that cross between hot
147 Basic block partitioning may result in some jumps that appear to
148 be optimizable (or blocks that appear to be mergeable), but which really
149 must be left untouched (they are required to make it safely across
150 partition boundaries). See the comments at the top of
151 bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
153 if (BB_PARTITION (jump_block
) != BB_PARTITION (jump_dest_block
)
154 || (cbranch_jump_edge
->flags
& EDGE_CROSSING
))
157 /* The conditional branch must target the block after the
158 unconditional branch. */
159 cbranch_dest_block
= cbranch_jump_edge
->dest
;
161 if (cbranch_dest_block
== EXIT_BLOCK_PTR_FOR_FN (cfun
)
162 || !can_fallthru (jump_block
, cbranch_dest_block
))
165 /* Invert the conditional branch. */
166 if (!invert_jump (cbranch_insn
, block_label (jump_dest_block
), 0))
170 fprintf (dump_file
, "Simplifying condjump %i around jump %i\n",
171 INSN_UID (cbranch_insn
), INSN_UID (BB_END (jump_block
)));
173 /* Success. Update the CFG to match. Note that after this point
174 the edge variable names appear backwards; the redirection is done
175 this way to preserve edge profile data. */
176 cbranch_jump_edge
= redirect_edge_succ_nodup (cbranch_jump_edge
,
178 cbranch_fallthru_edge
= redirect_edge_succ_nodup (cbranch_fallthru_edge
,
180 cbranch_jump_edge
->flags
|= EDGE_FALLTHRU
;
181 cbranch_fallthru_edge
->flags
&= ~EDGE_FALLTHRU
;
182 update_br_prob_note (cbranch_block
);
184 /* Delete the block with the unconditional jump, and clean up the mess. */
185 delete_basic_block (jump_block
);
186 tidy_fallthru_edge (cbranch_jump_edge
);
187 update_forwarder_flag (cbranch_block
);
192 /* Attempt to prove that operation is NOOP using CSElib or mark the effect
193 on register. Used by jump threading. */
196 mark_effect (rtx exp
, regset nonequal
)
200 switch (GET_CODE (exp
))
202 /* In case we do clobber the register, mark it as equal, as we know the
203 value is dead so it don't have to match. */
205 if (REG_P (XEXP (exp
, 0)))
207 dest
= XEXP (exp
, 0);
208 regno
= REGNO (dest
);
209 if (HARD_REGISTER_NUM_P (regno
))
210 bitmap_clear_range (nonequal
, regno
,
211 hard_regno_nregs
[regno
][GET_MODE (dest
)]);
213 bitmap_clear_bit (nonequal
, regno
);
218 if (rtx_equal_for_cselib_p (SET_DEST (exp
), SET_SRC (exp
)))
220 dest
= SET_DEST (exp
);
225 regno
= REGNO (dest
);
226 if (HARD_REGISTER_NUM_P (regno
))
227 bitmap_set_range (nonequal
, regno
,
228 hard_regno_nregs
[regno
][GET_MODE (dest
)]);
230 bitmap_set_bit (nonequal
, regno
);
238 /* Return nonzero if X is a register set in regset DATA.
239 Called via for_each_rtx. */
241 mentions_nonequal_regs (rtx
*x
, void *data
)
243 regset nonequal
= (regset
) data
;
249 if (REGNO_REG_SET_P (nonequal
, regno
))
251 if (regno
< FIRST_PSEUDO_REGISTER
)
253 int n
= hard_regno_nregs
[regno
][GET_MODE (*x
)];
255 if (REGNO_REG_SET_P (nonequal
, regno
+ n
))
261 /* Attempt to prove that the basic block B will have no side effects and
262 always continues in the same edge if reached via E. Return the edge
263 if exist, NULL otherwise. */
266 thread_jump (edge e
, basic_block b
)
268 rtx set1
, set2
, cond1
, cond2
, insn
;
269 enum rtx_code code1
, code2
, reversed_code2
;
270 bool reverse1
= false;
274 reg_set_iterator rsi
;
276 if (b
->flags
& BB_NONTHREADABLE_BLOCK
)
279 /* At the moment, we do handle only conditional jumps, but later we may
280 want to extend this code to tablejumps and others. */
281 if (EDGE_COUNT (e
->src
->succs
) != 2)
283 if (EDGE_COUNT (b
->succs
) != 2)
285 b
->flags
|= BB_NONTHREADABLE_BLOCK
;
289 /* Second branch must end with onlyjump, as we will eliminate the jump. */
290 if (!any_condjump_p (BB_END (e
->src
)))
293 if (!any_condjump_p (BB_END (b
)) || !onlyjump_p (BB_END (b
)))
295 b
->flags
|= BB_NONTHREADABLE_BLOCK
;
299 set1
= pc_set (BB_END (e
->src
));
300 set2
= pc_set (BB_END (b
));
301 if (((e
->flags
& EDGE_FALLTHRU
) != 0)
302 != (XEXP (SET_SRC (set1
), 1) == pc_rtx
))
305 cond1
= XEXP (SET_SRC (set1
), 0);
306 cond2
= XEXP (SET_SRC (set2
), 0);
308 code1
= reversed_comparison_code (cond1
, BB_END (e
->src
));
310 code1
= GET_CODE (cond1
);
312 code2
= GET_CODE (cond2
);
313 reversed_code2
= reversed_comparison_code (cond2
, BB_END (b
));
315 if (!comparison_dominates_p (code1
, code2
)
316 && !comparison_dominates_p (code1
, reversed_code2
))
319 /* Ensure that the comparison operators are equivalent.
320 ??? This is far too pessimistic. We should allow swapped operands,
321 different CCmodes, or for example comparisons for interval, that
322 dominate even when operands are not equivalent. */
323 if (!rtx_equal_p (XEXP (cond1
, 0), XEXP (cond2
, 0))
324 || !rtx_equal_p (XEXP (cond1
, 1), XEXP (cond2
, 1)))
327 /* Short circuit cases where block B contains some side effects, as we can't
329 for (insn
= NEXT_INSN (BB_HEAD (b
)); insn
!= NEXT_INSN (BB_END (b
));
330 insn
= NEXT_INSN (insn
))
331 if (INSN_P (insn
) && side_effects_p (PATTERN (insn
)))
333 b
->flags
|= BB_NONTHREADABLE_BLOCK
;
339 /* First process all values computed in the source basic block. */
340 for (insn
= NEXT_INSN (BB_HEAD (e
->src
));
341 insn
!= NEXT_INSN (BB_END (e
->src
));
342 insn
= NEXT_INSN (insn
))
344 cselib_process_insn (insn
);
346 nonequal
= BITMAP_ALLOC (NULL
);
347 CLEAR_REG_SET (nonequal
);
349 /* Now assume that we've continued by the edge E to B and continue
350 processing as if it were same basic block.
351 Our goal is to prove that whole block is an NOOP. */
353 for (insn
= NEXT_INSN (BB_HEAD (b
));
354 insn
!= NEXT_INSN (BB_END (b
)) && !failed
;
355 insn
= NEXT_INSN (insn
))
359 rtx pat
= PATTERN (insn
);
361 if (GET_CODE (pat
) == PARALLEL
)
363 for (i
= 0; i
< (unsigned)XVECLEN (pat
, 0); i
++)
364 failed
|= mark_effect (XVECEXP (pat
, 0, i
), nonequal
);
367 failed
|= mark_effect (pat
, nonequal
);
370 cselib_process_insn (insn
);
373 /* Later we should clear nonequal of dead registers. So far we don't
374 have life information in cfg_cleanup. */
377 b
->flags
|= BB_NONTHREADABLE_BLOCK
;
381 /* cond2 must not mention any register that is not equal to the
383 if (for_each_rtx (&cond2
, mentions_nonequal_regs
, nonequal
))
386 EXECUTE_IF_SET_IN_REG_SET (nonequal
, 0, i
, rsi
)
389 BITMAP_FREE (nonequal
);
391 if ((comparison_dominates_p (code1
, code2
) != 0)
392 != (XEXP (SET_SRC (set2
), 1) == pc_rtx
))
393 return BRANCH_EDGE (b
);
395 return FALLTHRU_EDGE (b
);
398 BITMAP_FREE (nonequal
);
403 /* Attempt to forward edges leaving basic block B.
404 Return true if successful. */
407 try_forward_edges (int mode
, basic_block b
)
409 bool changed
= false;
411 edge e
, *threaded_edges
= NULL
;
413 /* If we are partitioning hot/cold basic blocks, we don't want to
414 mess up unconditional or indirect jumps that cross between hot
417 Basic block partitioning may result in some jumps that appear to
418 be optimizable (or blocks that appear to be mergeable), but which really
419 must be left untouched (they are required to make it safely across
420 partition boundaries). See the comments at the top of
421 bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
423 if (JUMP_P (BB_END (b
)) && CROSSING_JUMP_P (BB_END (b
)))
426 for (ei
= ei_start (b
->succs
); (e
= ei_safe_edge (ei
)); )
428 basic_block target
, first
;
429 location_t goto_locus
;
431 bool threaded
= false;
432 int nthreaded_edges
= 0;
433 bool may_thread
= first_pass
|| (b
->flags
& BB_MODIFIED
) != 0;
435 /* Skip complex edges because we don't know how to update them.
437 Still handle fallthru edges, as we can succeed to forward fallthru
438 edge to the same place as the branch edge of conditional branch
439 and turn conditional branch to an unconditional branch. */
440 if (e
->flags
& EDGE_COMPLEX
)
446 target
= first
= e
->dest
;
447 counter
= NUM_FIXED_BLOCKS
;
448 goto_locus
= e
->goto_locus
;
450 /* If we are partitioning hot/cold basic_blocks, we don't want to mess
451 up jumps that cross between hot/cold sections.
453 Basic block partitioning may result in some jumps that appear
454 to be optimizable (or blocks that appear to be mergeable), but which
455 really must be left untouched (they are required to make it safely
456 across partition boundaries). See the comments at the top of
457 bb-reorder.c:partition_hot_cold_basic_blocks for complete
460 if (first
!= EXIT_BLOCK_PTR_FOR_FN (cfun
)
461 && JUMP_P (BB_END (first
))
462 && CROSSING_JUMP_P (BB_END (first
)))
465 while (counter
< n_basic_blocks_for_fn (cfun
))
467 basic_block new_target
= NULL
;
468 bool new_target_threaded
= false;
469 may_thread
|= (target
->flags
& BB_MODIFIED
) != 0;
471 if (FORWARDER_BLOCK_P (target
)
472 && !(single_succ_edge (target
)->flags
& EDGE_CROSSING
)
473 && single_succ (target
) != EXIT_BLOCK_PTR_FOR_FN (cfun
))
475 /* Bypass trivial infinite loops. */
476 new_target
= single_succ (target
);
477 if (target
== new_target
)
478 counter
= n_basic_blocks_for_fn (cfun
);
481 /* When not optimizing, ensure that edges or forwarder
482 blocks with different locus are not optimized out. */
483 location_t new_locus
= single_succ_edge (target
)->goto_locus
;
484 location_t locus
= goto_locus
;
486 if (LOCATION_LOCUS (new_locus
) != UNKNOWN_LOCATION
487 && LOCATION_LOCUS (locus
) != UNKNOWN_LOCATION
488 && new_locus
!= locus
)
492 if (LOCATION_LOCUS (new_locus
) != UNKNOWN_LOCATION
)
495 rtx last
= BB_END (target
);
496 if (DEBUG_INSN_P (last
))
497 last
= prev_nondebug_insn (last
);
498 if (last
&& INSN_P (last
))
499 new_locus
= INSN_LOCATION (last
);
501 new_locus
= UNKNOWN_LOCATION
;
503 if (LOCATION_LOCUS (new_locus
) != UNKNOWN_LOCATION
504 && LOCATION_LOCUS (locus
) != UNKNOWN_LOCATION
505 && new_locus
!= locus
)
509 if (LOCATION_LOCUS (new_locus
) != UNKNOWN_LOCATION
)
518 /* Allow to thread only over one edge at time to simplify updating
520 else if ((mode
& CLEANUP_THREADING
) && may_thread
)
522 edge t
= thread_jump (e
, target
);
526 threaded_edges
= XNEWVEC (edge
,
527 n_basic_blocks_for_fn (cfun
));
532 /* Detect an infinite loop across blocks not
533 including the start block. */
534 for (i
= 0; i
< nthreaded_edges
; ++i
)
535 if (threaded_edges
[i
] == t
)
537 if (i
< nthreaded_edges
)
539 counter
= n_basic_blocks_for_fn (cfun
);
544 /* Detect an infinite loop across the start block. */
548 gcc_assert (nthreaded_edges
549 < (n_basic_blocks_for_fn (cfun
)
550 - NUM_FIXED_BLOCKS
));
551 threaded_edges
[nthreaded_edges
++] = t
;
553 new_target
= t
->dest
;
554 new_target_threaded
= true;
563 threaded
|= new_target_threaded
;
566 if (counter
>= n_basic_blocks_for_fn (cfun
))
569 fprintf (dump_file
, "Infinite loop in BB %i.\n",
572 else if (target
== first
)
573 ; /* We didn't do anything. */
576 /* Save the values now, as the edge may get removed. */
577 gcov_type edge_count
= e
->count
;
578 int edge_probability
= e
->probability
;
582 e
->goto_locus
= goto_locus
;
584 /* Don't force if target is exit block. */
585 if (threaded
&& target
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
587 notice_new_block (redirect_edge_and_branch_force (e
, target
));
589 fprintf (dump_file
, "Conditionals threaded.\n");
591 else if (!redirect_edge_and_branch (e
, target
))
595 "Forwarding edge %i->%i to %i failed.\n",
596 b
->index
, e
->dest
->index
, target
->index
);
601 /* We successfully forwarded the edge. Now update profile
602 data: for each edge we traversed in the chain, remove
603 the original edge's execution count. */
604 edge_frequency
= apply_probability (b
->frequency
, edge_probability
);
610 if (!single_succ_p (first
))
612 gcc_assert (n
< nthreaded_edges
);
613 t
= threaded_edges
[n
++];
614 gcc_assert (t
->src
== first
);
615 update_bb_profile_for_threading (first
, edge_frequency
,
617 update_br_prob_note (first
);
621 first
->count
-= edge_count
;
622 if (first
->count
< 0)
624 first
->frequency
-= edge_frequency
;
625 if (first
->frequency
< 0)
626 first
->frequency
= 0;
627 /* It is possible that as the result of
628 threading we've removed edge as it is
629 threaded to the fallthru edge. Avoid
630 getting out of sync. */
631 if (n
< nthreaded_edges
632 && first
== threaded_edges
[n
]->src
)
634 t
= single_succ_edge (first
);
637 t
->count
-= edge_count
;
642 while (first
!= target
);
650 free (threaded_edges
);
655 /* Blocks A and B are to be merged into a single block. A has no incoming
656 fallthru edge, so it can be moved before B without adding or modifying
657 any jumps (aside from the jump from A to B). */
660 merge_blocks_move_predecessor_nojumps (basic_block a
, basic_block b
)
664 /* If we are partitioning hot/cold basic blocks, we don't want to
665 mess up unconditional or indirect jumps that cross between hot
668 Basic block partitioning may result in some jumps that appear to
669 be optimizable (or blocks that appear to be mergeable), but which really
670 must be left untouched (they are required to make it safely across
671 partition boundaries). See the comments at the top of
672 bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
674 if (BB_PARTITION (a
) != BB_PARTITION (b
))
677 barrier
= next_nonnote_insn (BB_END (a
));
678 gcc_assert (BARRIER_P (barrier
));
679 delete_insn (barrier
);
681 /* Scramble the insn chain. */
682 if (BB_END (a
) != PREV_INSN (BB_HEAD (b
)))
683 reorder_insns_nobb (BB_HEAD (a
), BB_END (a
), PREV_INSN (BB_HEAD (b
)));
687 fprintf (dump_file
, "Moved block %d before %d and merged.\n",
690 /* Swap the records for the two blocks around. */
693 link_block (a
, b
->prev_bb
);
695 /* Now blocks A and B are contiguous. Merge them. */
699 /* Blocks A and B are to be merged into a single block. B has no outgoing
700 fallthru edge, so it can be moved after A without adding or modifying
701 any jumps (aside from the jump from A to B). */
704 merge_blocks_move_successor_nojumps (basic_block a
, basic_block b
)
706 rtx barrier
, real_b_end
;
708 rtx_jump_table_data
*table
;
710 /* If we are partitioning hot/cold basic blocks, we don't want to
711 mess up unconditional or indirect jumps that cross between hot
714 Basic block partitioning may result in some jumps that appear to
715 be optimizable (or blocks that appear to be mergeable), but which really
716 must be left untouched (they are required to make it safely across
717 partition boundaries). See the comments at the top of
718 bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
720 if (BB_PARTITION (a
) != BB_PARTITION (b
))
723 real_b_end
= BB_END (b
);
725 /* If there is a jump table following block B temporarily add the jump table
726 to block B so that it will also be moved to the correct location. */
727 if (tablejump_p (BB_END (b
), &label
, &table
)
728 && prev_active_insn (label
) == BB_END (b
))
730 SET_BB_END (b
) = table
;
733 /* There had better have been a barrier there. Delete it. */
734 barrier
= NEXT_INSN (BB_END (b
));
735 if (barrier
&& BARRIER_P (barrier
))
736 delete_insn (barrier
);
739 /* Scramble the insn chain. */
740 reorder_insns_nobb (BB_HEAD (b
), BB_END (b
), BB_END (a
));
742 /* Restore the real end of b. */
743 SET_BB_END (b
) = real_b_end
;
746 fprintf (dump_file
, "Moved block %d after %d and merged.\n",
749 /* Now blocks A and B are contiguous. Merge them. */
753 /* Attempt to merge basic blocks that are potentially non-adjacent.
754 Return NULL iff the attempt failed, otherwise return basic block
755 where cleanup_cfg should continue. Because the merging commonly
756 moves basic block away or introduces another optimization
757 possibility, return basic block just before B so cleanup_cfg don't
760 It may be good idea to return basic block before C in the case
761 C has been moved after B and originally appeared earlier in the
762 insn sequence, but we have no information available about the
763 relative ordering of these two. Hopefully it is not too common. */
766 merge_blocks_move (edge e
, basic_block b
, basic_block c
, int mode
)
770 /* If we are partitioning hot/cold basic blocks, we don't want to
771 mess up unconditional or indirect jumps that cross between hot
774 Basic block partitioning may result in some jumps that appear to
775 be optimizable (or blocks that appear to be mergeable), but which really
776 must be left untouched (they are required to make it safely across
777 partition boundaries). See the comments at the top of
778 bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
780 if (BB_PARTITION (b
) != BB_PARTITION (c
))
783 /* If B has a fallthru edge to C, no need to move anything. */
784 if (e
->flags
& EDGE_FALLTHRU
)
786 int b_index
= b
->index
, c_index
= c
->index
;
788 /* Protect the loop latches. */
789 if (current_loops
&& c
->loop_father
->latch
== c
)
793 update_forwarder_flag (b
);
796 fprintf (dump_file
, "Merged %d and %d without moving.\n",
799 return b
->prev_bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
) ? b
: b
->prev_bb
;
802 /* Otherwise we will need to move code around. Do that only if expensive
803 transformations are allowed. */
804 else if (mode
& CLEANUP_EXPENSIVE
)
806 edge tmp_edge
, b_fallthru_edge
;
807 bool c_has_outgoing_fallthru
;
808 bool b_has_incoming_fallthru
;
810 /* Avoid overactive code motion, as the forwarder blocks should be
811 eliminated by edge redirection instead. One exception might have
812 been if B is a forwarder block and C has no fallthru edge, but
813 that should be cleaned up by bb-reorder instead. */
814 if (FORWARDER_BLOCK_P (b
) || FORWARDER_BLOCK_P (c
))
817 /* We must make sure to not munge nesting of lexical blocks,
818 and loop notes. This is done by squeezing out all the notes
819 and leaving them there to lie. Not ideal, but functional. */
821 tmp_edge
= find_fallthru_edge (c
->succs
);
822 c_has_outgoing_fallthru
= (tmp_edge
!= NULL
);
824 tmp_edge
= find_fallthru_edge (b
->preds
);
825 b_has_incoming_fallthru
= (tmp_edge
!= NULL
);
826 b_fallthru_edge
= tmp_edge
;
829 next
= next
->prev_bb
;
831 /* Otherwise, we're going to try to move C after B. If C does
832 not have an outgoing fallthru, then it can be moved
833 immediately after B without introducing or modifying jumps. */
834 if (! c_has_outgoing_fallthru
)
836 merge_blocks_move_successor_nojumps (b
, c
);
837 return next
== ENTRY_BLOCK_PTR_FOR_FN (cfun
) ? next
->next_bb
: next
;
840 /* If B does not have an incoming fallthru, then it can be moved
841 immediately before C without introducing or modifying jumps.
842 C cannot be the first block, so we do not have to worry about
843 accessing a non-existent block. */
845 if (b_has_incoming_fallthru
)
849 if (b_fallthru_edge
->src
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
851 bb
= force_nonfallthru (b_fallthru_edge
);
853 notice_new_block (bb
);
856 merge_blocks_move_predecessor_nojumps (b
, c
);
857 return next
== ENTRY_BLOCK_PTR_FOR_FN (cfun
) ? next
->next_bb
: next
;
864 /* Removes the memory attributes of MEM expression
865 if they are not equal. */
868 merge_memattrs (rtx x
, rtx y
)
877 if (x
== 0 || y
== 0)
882 if (code
!= GET_CODE (y
))
885 if (GET_MODE (x
) != GET_MODE (y
))
888 if (code
== MEM
&& !mem_attrs_eq_p (MEM_ATTRS (x
), MEM_ATTRS (y
)))
892 else if (! MEM_ATTRS (y
))
896 HOST_WIDE_INT mem_size
;
898 if (MEM_ALIAS_SET (x
) != MEM_ALIAS_SET (y
))
900 set_mem_alias_set (x
, 0);
901 set_mem_alias_set (y
, 0);
904 if (! mem_expr_equal_p (MEM_EXPR (x
), MEM_EXPR (y
)))
908 clear_mem_offset (x
);
909 clear_mem_offset (y
);
911 else if (MEM_OFFSET_KNOWN_P (x
) != MEM_OFFSET_KNOWN_P (y
)
912 || (MEM_OFFSET_KNOWN_P (x
)
913 && MEM_OFFSET (x
) != MEM_OFFSET (y
)))
915 clear_mem_offset (x
);
916 clear_mem_offset (y
);
919 if (MEM_SIZE_KNOWN_P (x
) && MEM_SIZE_KNOWN_P (y
))
921 mem_size
= MAX (MEM_SIZE (x
), MEM_SIZE (y
));
922 set_mem_size (x
, mem_size
);
923 set_mem_size (y
, mem_size
);
931 set_mem_align (x
, MIN (MEM_ALIGN (x
), MEM_ALIGN (y
)));
932 set_mem_align (y
, MEM_ALIGN (x
));
937 if (MEM_READONLY_P (x
) != MEM_READONLY_P (y
))
939 MEM_READONLY_P (x
) = 0;
940 MEM_READONLY_P (y
) = 0;
942 if (MEM_NOTRAP_P (x
) != MEM_NOTRAP_P (y
))
944 MEM_NOTRAP_P (x
) = 0;
945 MEM_NOTRAP_P (y
) = 0;
947 if (MEM_VOLATILE_P (x
) != MEM_VOLATILE_P (y
))
949 MEM_VOLATILE_P (x
) = 1;
950 MEM_VOLATILE_P (y
) = 1;
954 fmt
= GET_RTX_FORMAT (code
);
955 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
960 /* Two vectors must have the same length. */
961 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
964 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
965 merge_memattrs (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
));
970 merge_memattrs (XEXP (x
, i
), XEXP (y
, i
));
977 /* Checks if patterns P1 and P2 are equivalent, apart from the possibly
978 different single sets S1 and S2. */
981 equal_different_set_p (rtx p1
, rtx s1
, rtx p2
, rtx s2
)
986 if (p1
== s1
&& p2
== s2
)
989 if (GET_CODE (p1
) != PARALLEL
|| GET_CODE (p2
) != PARALLEL
)
992 if (XVECLEN (p1
, 0) != XVECLEN (p2
, 0))
995 for (i
= 0; i
< XVECLEN (p1
, 0); i
++)
997 e1
= XVECEXP (p1
, 0, i
);
998 e2
= XVECEXP (p2
, 0, i
);
999 if (e1
== s1
&& e2
== s2
)
1001 if (reload_completed
1002 ? rtx_renumbered_equal_p (e1
, e2
) : rtx_equal_p (e1
, e2
))
1011 /* Examine register notes on I1 and I2 and return:
1012 - dir_forward if I1 can be replaced by I2, or
1013 - dir_backward if I2 can be replaced by I1, or
1014 - dir_both if both are the case. */
1016 static enum replace_direction
1017 can_replace_by (rtx i1
, rtx i2
)
1019 rtx s1
, s2
, d1
, d2
, src1
, src2
, note1
, note2
;
1022 /* Check for 2 sets. */
1023 s1
= single_set (i1
);
1024 s2
= single_set (i2
);
1025 if (s1
== NULL_RTX
|| s2
== NULL_RTX
)
1028 /* Check that the 2 sets set the same dest. */
1031 if (!(reload_completed
1032 ? rtx_renumbered_equal_p (d1
, d2
) : rtx_equal_p (d1
, d2
)))
1035 /* Find identical req_equiv or reg_equal note, which implies that the 2 sets
1036 set dest to the same value. */
1037 note1
= find_reg_equal_equiv_note (i1
);
1038 note2
= find_reg_equal_equiv_note (i2
);
1039 if (!note1
|| !note2
|| !rtx_equal_p (XEXP (note1
, 0), XEXP (note2
, 0))
1040 || !CONST_INT_P (XEXP (note1
, 0)))
1043 if (!equal_different_set_p (PATTERN (i1
), s1
, PATTERN (i2
), s2
))
1046 /* Although the 2 sets set dest to the same value, we cannot replace
1047 (set (dest) (const_int))
1050 because we don't know if the reg is live and has the same value at the
1051 location of replacement. */
1052 src1
= SET_SRC (s1
);
1053 src2
= SET_SRC (s2
);
1054 c1
= CONST_INT_P (src1
);
1055 c2
= CONST_INT_P (src2
);
1061 return dir_backward
;
1066 /* Merges directions A and B. */
1068 static enum replace_direction
1069 merge_dir (enum replace_direction a
, enum replace_direction b
)
1071 /* Implements the following table:
1090 /* Examine I1 and I2 and return:
1091 - dir_forward if I1 can be replaced by I2, or
1092 - dir_backward if I2 can be replaced by I1, or
1093 - dir_both if both are the case. */
1095 static enum replace_direction
1096 old_insns_match_p (int mode ATTRIBUTE_UNUSED
, rtx i1
, rtx i2
)
1100 /* Verify that I1 and I2 are equivalent. */
1101 if (GET_CODE (i1
) != GET_CODE (i2
))
1104 /* __builtin_unreachable() may lead to empty blocks (ending with
1105 NOTE_INSN_BASIC_BLOCK). They may be crossjumped. */
1106 if (NOTE_INSN_BASIC_BLOCK_P (i1
) && NOTE_INSN_BASIC_BLOCK_P (i2
))
1109 /* ??? Do not allow cross-jumping between different stack levels. */
1110 p1
= find_reg_note (i1
, REG_ARGS_SIZE
, NULL
);
1111 p2
= find_reg_note (i2
, REG_ARGS_SIZE
, NULL
);
1116 if (!rtx_equal_p (p1
, p2
))
1119 /* ??? Worse, this adjustment had better be constant lest we
1120 have differing incoming stack levels. */
1121 if (!frame_pointer_needed
1122 && find_args_size_adjust (i1
) == HOST_WIDE_INT_MIN
)
1131 if (GET_CODE (p1
) != GET_CODE (p2
))
1134 /* If this is a CALL_INSN, compare register usage information.
1135 If we don't check this on stack register machines, the two
1136 CALL_INSNs might be merged leaving reg-stack.c with mismatching
1137 numbers of stack registers in the same basic block.
1138 If we don't check this on machines with delay slots, a delay slot may
1139 be filled that clobbers a parameter expected by the subroutine.
1141 ??? We take the simple route for now and assume that if they're
1142 equal, they were constructed identically.
1144 Also check for identical exception regions. */
1148 /* Ensure the same EH region. */
1149 rtx n1
= find_reg_note (i1
, REG_EH_REGION
, 0);
1150 rtx n2
= find_reg_note (i2
, REG_EH_REGION
, 0);
1155 if (n1
&& (!n2
|| XEXP (n1
, 0) != XEXP (n2
, 0)))
1158 if (!rtx_equal_p (CALL_INSN_FUNCTION_USAGE (i1
),
1159 CALL_INSN_FUNCTION_USAGE (i2
))
1160 || SIBLING_CALL_P (i1
) != SIBLING_CALL_P (i2
))
1163 /* For address sanitizer, never crossjump __asan_report_* builtins,
1164 otherwise errors might be reported on incorrect lines. */
1165 if (flag_sanitize
& SANITIZE_ADDRESS
)
1167 rtx call
= get_call_rtx_from (i1
);
1168 if (call
&& GET_CODE (XEXP (XEXP (call
, 0), 0)) == SYMBOL_REF
)
1170 rtx symbol
= XEXP (XEXP (call
, 0), 0);
1171 if (SYMBOL_REF_DECL (symbol
)
1172 && TREE_CODE (SYMBOL_REF_DECL (symbol
)) == FUNCTION_DECL
)
1174 if ((DECL_BUILT_IN_CLASS (SYMBOL_REF_DECL (symbol
))
1176 && DECL_FUNCTION_CODE (SYMBOL_REF_DECL (symbol
))
1177 >= BUILT_IN_ASAN_REPORT_LOAD1
1178 && DECL_FUNCTION_CODE (SYMBOL_REF_DECL (symbol
))
1179 <= BUILT_IN_ASAN_STOREN
)
1187 /* If cross_jump_death_matters is not 0, the insn's mode
1188 indicates whether or not the insn contains any stack-like
1191 if ((mode
& CLEANUP_POST_REGSTACK
) && stack_regs_mentioned (i1
))
1193 /* If register stack conversion has already been done, then
1194 death notes must also be compared before it is certain that
1195 the two instruction streams match. */
1198 HARD_REG_SET i1_regset
, i2_regset
;
1200 CLEAR_HARD_REG_SET (i1_regset
);
1201 CLEAR_HARD_REG_SET (i2_regset
);
1203 for (note
= REG_NOTES (i1
); note
; note
= XEXP (note
, 1))
1204 if (REG_NOTE_KIND (note
) == REG_DEAD
&& STACK_REG_P (XEXP (note
, 0)))
1205 SET_HARD_REG_BIT (i1_regset
, REGNO (XEXP (note
, 0)));
1207 for (note
= REG_NOTES (i2
); note
; note
= XEXP (note
, 1))
1208 if (REG_NOTE_KIND (note
) == REG_DEAD
&& STACK_REG_P (XEXP (note
, 0)))
1209 SET_HARD_REG_BIT (i2_regset
, REGNO (XEXP (note
, 0)));
1211 if (!hard_reg_set_equal_p (i1_regset
, i2_regset
))
1216 if (reload_completed
1217 ? rtx_renumbered_equal_p (p1
, p2
) : rtx_equal_p (p1
, p2
))
1220 return can_replace_by (i1
, i2
);
1223 /* When comparing insns I1 and I2 in flow_find_cross_jump or
1224 flow_find_head_matching_sequence, ensure the notes match. */
1227 merge_notes (rtx i1
, rtx i2
)
1229 /* If the merged insns have different REG_EQUAL notes, then
1231 rtx equiv1
= find_reg_equal_equiv_note (i1
);
1232 rtx equiv2
= find_reg_equal_equiv_note (i2
);
1234 if (equiv1
&& !equiv2
)
1235 remove_note (i1
, equiv1
);
1236 else if (!equiv1
&& equiv2
)
1237 remove_note (i2
, equiv2
);
1238 else if (equiv1
&& equiv2
1239 && !rtx_equal_p (XEXP (equiv1
, 0), XEXP (equiv2
, 0)))
1241 remove_note (i1
, equiv1
);
1242 remove_note (i2
, equiv2
);
1246 /* Walks from I1 in BB1 backward till the next non-debug insn, and returns the
1247 resulting insn in I1, and the corresponding bb in BB1. At the head of a
1248 bb, if there is a predecessor bb that reaches this bb via fallthru, and
1249 FOLLOW_FALLTHRU, walks further in the predecessor bb and registers this in
1250 DID_FALLTHRU. Otherwise, stops at the head of the bb. */
1253 walk_to_nondebug_insn (rtx
*i1
, basic_block
*bb1
, bool follow_fallthru
,
1258 *did_fallthru
= false;
1261 while (!NONDEBUG_INSN_P (*i1
))
1263 if (*i1
!= BB_HEAD (*bb1
))
1265 *i1
= PREV_INSN (*i1
);
1269 if (!follow_fallthru
)
1272 fallthru
= find_fallthru_edge ((*bb1
)->preds
);
1273 if (!fallthru
|| fallthru
->src
== ENTRY_BLOCK_PTR_FOR_FN (cfun
)
1274 || !single_succ_p (fallthru
->src
))
1277 *bb1
= fallthru
->src
;
1278 *i1
= BB_END (*bb1
);
1279 *did_fallthru
= true;
1283 /* Look through the insns at the end of BB1 and BB2 and find the longest
1284 sequence that are either equivalent, or allow forward or backward
1285 replacement. Store the first insns for that sequence in *F1 and *F2 and
1286 return the sequence length.
1288 DIR_P indicates the allowed replacement direction on function entry, and
1289 the actual replacement direction on function exit. If NULL, only equivalent
1290 sequences are allowed.
1292 To simplify callers of this function, if the blocks match exactly,
1293 store the head of the blocks in *F1 and *F2. */
1296 flow_find_cross_jump (basic_block bb1
, basic_block bb2
, rtx
*f1
, rtx
*f2
,
1297 enum replace_direction
*dir_p
)
1299 rtx i1
, i2
, last1
, last2
, afterlast1
, afterlast2
;
1301 enum replace_direction dir
, last_dir
, afterlast_dir
;
1302 bool follow_fallthru
, did_fallthru
;
1308 afterlast_dir
= dir
;
1309 last_dir
= afterlast_dir
;
1311 /* Skip simple jumps at the end of the blocks. Complex jumps still
1312 need to be compared for equivalence, which we'll do below. */
1315 last1
= afterlast1
= last2
= afterlast2
= NULL_RTX
;
1317 || (returnjump_p (i1
) && !side_effects_p (PATTERN (i1
))))
1320 i1
= PREV_INSN (i1
);
1325 || (returnjump_p (i2
) && !side_effects_p (PATTERN (i2
))))
1328 /* Count everything except for unconditional jump as insn.
1329 Don't count any jumps if dir_p is NULL. */
1330 if (!simplejump_p (i2
) && !returnjump_p (i2
) && last1
&& dir_p
)
1332 i2
= PREV_INSN (i2
);
1337 /* In the following example, we can replace all jumps to C by jumps to A.
1339 This removes 4 duplicate insns.
1340 [bb A] insn1 [bb C] insn1
1346 We could also replace all jumps to A by jumps to C, but that leaves B
1347 alive, and removes only 2 duplicate insns. In a subsequent crossjump
1348 step, all jumps to B would be replaced with jumps to the middle of C,
1349 achieving the same result with more effort.
1350 So we allow only the first possibility, which means that we don't allow
1351 fallthru in the block that's being replaced. */
1353 follow_fallthru
= dir_p
&& dir
!= dir_forward
;
1354 walk_to_nondebug_insn (&i1
, &bb1
, follow_fallthru
, &did_fallthru
);
1358 follow_fallthru
= dir_p
&& dir
!= dir_backward
;
1359 walk_to_nondebug_insn (&i2
, &bb2
, follow_fallthru
, &did_fallthru
);
1363 if (i1
== BB_HEAD (bb1
) || i2
== BB_HEAD (bb2
))
1366 dir
= merge_dir (dir
, old_insns_match_p (0, i1
, i2
));
1367 if (dir
== dir_none
|| (!dir_p
&& dir
!= dir_both
))
1370 merge_memattrs (i1
, i2
);
1372 /* Don't begin a cross-jump with a NOTE insn. */
1375 merge_notes (i1
, i2
);
1377 afterlast1
= last1
, afterlast2
= last2
;
1378 last1
= i1
, last2
= i2
;
1379 afterlast_dir
= last_dir
;
1381 if (active_insn_p (i1
))
1385 i1
= PREV_INSN (i1
);
1386 i2
= PREV_INSN (i2
);
1390 /* Don't allow the insn after a compare to be shared by
1391 cross-jumping unless the compare is also shared. */
1392 if (ninsns
&& reg_mentioned_p (cc0_rtx
, last1
) && ! sets_cc0_p (last1
))
1393 last1
= afterlast1
, last2
= afterlast2
, last_dir
= afterlast_dir
, ninsns
--;
1396 /* Include preceding notes and labels in the cross-jump. One,
1397 this may bring us to the head of the blocks as requested above.
1398 Two, it keeps line number notes as matched as may be. */
1401 bb1
= BLOCK_FOR_INSN (last1
);
1402 while (last1
!= BB_HEAD (bb1
) && !NONDEBUG_INSN_P (PREV_INSN (last1
)))
1403 last1
= PREV_INSN (last1
);
1405 if (last1
!= BB_HEAD (bb1
) && LABEL_P (PREV_INSN (last1
)))
1406 last1
= PREV_INSN (last1
);
1408 bb2
= BLOCK_FOR_INSN (last2
);
1409 while (last2
!= BB_HEAD (bb2
) && !NONDEBUG_INSN_P (PREV_INSN (last2
)))
1410 last2
= PREV_INSN (last2
);
1412 if (last2
!= BB_HEAD (bb2
) && LABEL_P (PREV_INSN (last2
)))
1413 last2
= PREV_INSN (last2
);
1424 /* Like flow_find_cross_jump, except start looking for a matching sequence from
1425 the head of the two blocks. Do not include jumps at the end.
1426 If STOP_AFTER is nonzero, stop after finding that many matching
1427 instructions. If STOP_AFTER is zero, count all INSN_P insns, if it is
1428 non-zero, only count active insns. */
1431 flow_find_head_matching_sequence (basic_block bb1
, basic_block bb2
, rtx
*f1
,
1432 rtx
*f2
, int stop_after
)
1434 rtx i1
, i2
, last1
, last2
, beforelast1
, beforelast2
;
1438 int nehedges1
= 0, nehedges2
= 0;
1440 FOR_EACH_EDGE (e
, ei
, bb1
->succs
)
1441 if (e
->flags
& EDGE_EH
)
1443 FOR_EACH_EDGE (e
, ei
, bb2
->succs
)
1444 if (e
->flags
& EDGE_EH
)
1449 last1
= beforelast1
= last2
= beforelast2
= NULL_RTX
;
1453 /* Ignore notes, except NOTE_INSN_EPILOGUE_BEG. */
1454 while (!NONDEBUG_INSN_P (i1
) && i1
!= BB_END (bb1
))
1456 if (NOTE_P (i1
) && NOTE_KIND (i1
) == NOTE_INSN_EPILOGUE_BEG
)
1458 i1
= NEXT_INSN (i1
);
1461 while (!NONDEBUG_INSN_P (i2
) && i2
!= BB_END (bb2
))
1463 if (NOTE_P (i2
) && NOTE_KIND (i2
) == NOTE_INSN_EPILOGUE_BEG
)
1465 i2
= NEXT_INSN (i2
);
1468 if ((i1
== BB_END (bb1
) && !NONDEBUG_INSN_P (i1
))
1469 || (i2
== BB_END (bb2
) && !NONDEBUG_INSN_P (i2
)))
1472 if (NOTE_P (i1
) || NOTE_P (i2
)
1473 || JUMP_P (i1
) || JUMP_P (i2
))
1476 /* A sanity check to make sure we're not merging insns with different
1477 effects on EH. If only one of them ends a basic block, it shouldn't
1478 have an EH edge; if both end a basic block, there should be the same
1479 number of EH edges. */
1480 if ((i1
== BB_END (bb1
) && i2
!= BB_END (bb2
)
1482 || (i2
== BB_END (bb2
) && i1
!= BB_END (bb1
)
1484 || (i1
== BB_END (bb1
) && i2
== BB_END (bb2
)
1485 && nehedges1
!= nehedges2
))
1488 if (old_insns_match_p (0, i1
, i2
) != dir_both
)
1491 merge_memattrs (i1
, i2
);
1493 /* Don't begin a cross-jump with a NOTE insn. */
1496 merge_notes (i1
, i2
);
1498 beforelast1
= last1
, beforelast2
= last2
;
1499 last1
= i1
, last2
= i2
;
1500 if (!stop_after
|| active_insn_p (i1
))
1504 if (i1
== BB_END (bb1
) || i2
== BB_END (bb2
)
1505 || (stop_after
> 0 && ninsns
== stop_after
))
1508 i1
= NEXT_INSN (i1
);
1509 i2
= NEXT_INSN (i2
);
1513 /* Don't allow a compare to be shared by cross-jumping unless the insn
1514 after the compare is also shared. */
1515 if (ninsns
&& reg_mentioned_p (cc0_rtx
, last1
) && sets_cc0_p (last1
))
1516 last1
= beforelast1
, last2
= beforelast2
, ninsns
--;
1528 /* Return true iff outgoing edges of BB1 and BB2 match, together with
1529 the branch instruction. This means that if we commonize the control
1530 flow before end of the basic block, the semantic remains unchanged.
1532 We may assume that there exists one edge with a common destination. */
1535 outgoing_edges_match (int mode
, basic_block bb1
, basic_block bb2
)
1537 int nehedges1
= 0, nehedges2
= 0;
1538 edge fallthru1
= 0, fallthru2
= 0;
1542 /* If we performed shrink-wrapping, edges to the exit block can
1543 only be distinguished for JUMP_INSNs. The two paths may differ in
1544 whether they went through the prologue. Sibcalls are fine, we know
1545 that we either didn't need or inserted an epilogue before them. */
1546 if (crtl
->shrink_wrapped
1547 && single_succ_p (bb1
)
1548 && single_succ (bb1
) == EXIT_BLOCK_PTR_FOR_FN (cfun
)
1549 && !JUMP_P (BB_END (bb1
))
1550 && !(CALL_P (BB_END (bb1
)) && SIBLING_CALL_P (BB_END (bb1
))))
1553 /* If BB1 has only one successor, we may be looking at either an
1554 unconditional jump, or a fake edge to exit. */
1555 if (single_succ_p (bb1
)
1556 && (single_succ_edge (bb1
)->flags
& (EDGE_COMPLEX
| EDGE_FAKE
)) == 0
1557 && (!JUMP_P (BB_END (bb1
)) || simplejump_p (BB_END (bb1
))))
1558 return (single_succ_p (bb2
)
1559 && (single_succ_edge (bb2
)->flags
1560 & (EDGE_COMPLEX
| EDGE_FAKE
)) == 0
1561 && (!JUMP_P (BB_END (bb2
)) || simplejump_p (BB_END (bb2
))));
1563 /* Match conditional jumps - this may get tricky when fallthru and branch
1564 edges are crossed. */
1565 if (EDGE_COUNT (bb1
->succs
) == 2
1566 && any_condjump_p (BB_END (bb1
))
1567 && onlyjump_p (BB_END (bb1
)))
1569 edge b1
, f1
, b2
, f2
;
1570 bool reverse
, match
;
1571 rtx set1
, set2
, cond1
, cond2
;
1572 enum rtx_code code1
, code2
;
1574 if (EDGE_COUNT (bb2
->succs
) != 2
1575 || !any_condjump_p (BB_END (bb2
))
1576 || !onlyjump_p (BB_END (bb2
)))
1579 b1
= BRANCH_EDGE (bb1
);
1580 b2
= BRANCH_EDGE (bb2
);
1581 f1
= FALLTHRU_EDGE (bb1
);
1582 f2
= FALLTHRU_EDGE (bb2
);
1584 /* Get around possible forwarders on fallthru edges. Other cases
1585 should be optimized out already. */
1586 if (FORWARDER_BLOCK_P (f1
->dest
))
1587 f1
= single_succ_edge (f1
->dest
);
1589 if (FORWARDER_BLOCK_P (f2
->dest
))
1590 f2
= single_succ_edge (f2
->dest
);
1592 /* To simplify use of this function, return false if there are
1593 unneeded forwarder blocks. These will get eliminated later
1594 during cleanup_cfg. */
1595 if (FORWARDER_BLOCK_P (f1
->dest
)
1596 || FORWARDER_BLOCK_P (f2
->dest
)
1597 || FORWARDER_BLOCK_P (b1
->dest
)
1598 || FORWARDER_BLOCK_P (b2
->dest
))
1601 if (f1
->dest
== f2
->dest
&& b1
->dest
== b2
->dest
)
1603 else if (f1
->dest
== b2
->dest
&& b1
->dest
== f2
->dest
)
1608 set1
= pc_set (BB_END (bb1
));
1609 set2
= pc_set (BB_END (bb2
));
1610 if ((XEXP (SET_SRC (set1
), 1) == pc_rtx
)
1611 != (XEXP (SET_SRC (set2
), 1) == pc_rtx
))
1614 cond1
= XEXP (SET_SRC (set1
), 0);
1615 cond2
= XEXP (SET_SRC (set2
), 0);
1616 code1
= GET_CODE (cond1
);
1618 code2
= reversed_comparison_code (cond2
, BB_END (bb2
));
1620 code2
= GET_CODE (cond2
);
1622 if (code2
== UNKNOWN
)
1625 /* Verify codes and operands match. */
1626 match
= ((code1
== code2
1627 && rtx_renumbered_equal_p (XEXP (cond1
, 0), XEXP (cond2
, 0))
1628 && rtx_renumbered_equal_p (XEXP (cond1
, 1), XEXP (cond2
, 1)))
1629 || (code1
== swap_condition (code2
)
1630 && rtx_renumbered_equal_p (XEXP (cond1
, 1),
1632 && rtx_renumbered_equal_p (XEXP (cond1
, 0),
1635 /* If we return true, we will join the blocks. Which means that
1636 we will only have one branch prediction bit to work with. Thus
1637 we require the existing branches to have probabilities that are
1640 && optimize_bb_for_speed_p (bb1
)
1641 && optimize_bb_for_speed_p (bb2
))
1645 if (b1
->dest
== b2
->dest
)
1646 prob2
= b2
->probability
;
1648 /* Do not use f2 probability as f2 may be forwarded. */
1649 prob2
= REG_BR_PROB_BASE
- b2
->probability
;
1651 /* Fail if the difference in probabilities is greater than 50%.
1652 This rules out two well-predicted branches with opposite
1654 if (abs (b1
->probability
- prob2
) > REG_BR_PROB_BASE
/ 2)
1658 "Outcomes of branch in bb %i and %i differ too much (%i %i)\n",
1659 bb1
->index
, bb2
->index
, b1
->probability
, prob2
);
1665 if (dump_file
&& match
)
1666 fprintf (dump_file
, "Conditionals in bb %i and %i match.\n",
1667 bb1
->index
, bb2
->index
);
1672 /* Generic case - we are seeing a computed jump, table jump or trapping
1675 /* Check whether there are tablejumps in the end of BB1 and BB2.
1676 Return true if they are identical. */
1679 rtx_jump_table_data
*table1
, *table2
;
1681 if (tablejump_p (BB_END (bb1
), &label1
, &table1
)
1682 && tablejump_p (BB_END (bb2
), &label2
, &table2
)
1683 && GET_CODE (PATTERN (table1
)) == GET_CODE (PATTERN (table2
)))
1685 /* The labels should never be the same rtx. If they really are same
1686 the jump tables are same too. So disable crossjumping of blocks BB1
1687 and BB2 because when deleting the common insns in the end of BB1
1688 by delete_basic_block () the jump table would be deleted too. */
1689 /* If LABEL2 is referenced in BB1->END do not do anything
1690 because we would loose information when replacing
1691 LABEL1 by LABEL2 and then LABEL2 by LABEL1 in BB1->END. */
1692 if (label1
!= label2
&& !rtx_referenced_p (label2
, BB_END (bb1
)))
1694 /* Set IDENTICAL to true when the tables are identical. */
1695 bool identical
= false;
1698 p1
= PATTERN (table1
);
1699 p2
= PATTERN (table2
);
1700 if (GET_CODE (p1
) == ADDR_VEC
&& rtx_equal_p (p1
, p2
))
1704 else if (GET_CODE (p1
) == ADDR_DIFF_VEC
1705 && (XVECLEN (p1
, 1) == XVECLEN (p2
, 1))
1706 && rtx_equal_p (XEXP (p1
, 2), XEXP (p2
, 2))
1707 && rtx_equal_p (XEXP (p1
, 3), XEXP (p2
, 3)))
1712 for (i
= XVECLEN (p1
, 1) - 1; i
>= 0 && identical
; i
--)
1713 if (!rtx_equal_p (XVECEXP (p1
, 1, i
), XVECEXP (p2
, 1, i
)))
1719 replace_label_data rr
;
1722 /* Temporarily replace references to LABEL1 with LABEL2
1723 in BB1->END so that we could compare the instructions. */
1726 rr
.update_label_nuses
= false;
1727 for_each_rtx (&SET_BB_END (bb1
), replace_label
, &rr
);
1729 match
= (old_insns_match_p (mode
, BB_END (bb1
), BB_END (bb2
))
1731 if (dump_file
&& match
)
1733 "Tablejumps in bb %i and %i match.\n",
1734 bb1
->index
, bb2
->index
);
1736 /* Set the original label in BB1->END because when deleting
1737 a block whose end is a tablejump, the tablejump referenced
1738 from the instruction is deleted too. */
1741 for_each_rtx (&SET_BB_END (bb1
), replace_label
, &rr
);
1750 /* Find the last non-debug non-note instruction in each bb, except
1751 stop when we see the NOTE_INSN_BASIC_BLOCK, as old_insns_match_p
1752 handles that case specially. old_insns_match_p does not handle
1753 other types of instruction notes. */
1754 rtx last1
= BB_END (bb1
);
1755 rtx last2
= BB_END (bb2
);
1756 while (!NOTE_INSN_BASIC_BLOCK_P (last1
) &&
1757 (DEBUG_INSN_P (last1
) || NOTE_P (last1
)))
1758 last1
= PREV_INSN (last1
);
1759 while (!NOTE_INSN_BASIC_BLOCK_P (last2
) &&
1760 (DEBUG_INSN_P (last2
) || NOTE_P (last2
)))
1761 last2
= PREV_INSN (last2
);
1762 gcc_assert (last1
&& last2
);
1764 /* First ensure that the instructions match. There may be many outgoing
1765 edges so this test is generally cheaper. */
1766 if (old_insns_match_p (mode
, last1
, last2
) != dir_both
)
1769 /* Search the outgoing edges, ensure that the counts do match, find possible
1770 fallthru and exception handling edges since these needs more
1772 if (EDGE_COUNT (bb1
->succs
) != EDGE_COUNT (bb2
->succs
))
1775 bool nonfakeedges
= false;
1776 FOR_EACH_EDGE (e1
, ei
, bb1
->succs
)
1778 e2
= EDGE_SUCC (bb2
, ei
.index
);
1780 if ((e1
->flags
& EDGE_FAKE
) == 0)
1781 nonfakeedges
= true;
1783 if (e1
->flags
& EDGE_EH
)
1786 if (e2
->flags
& EDGE_EH
)
1789 if (e1
->flags
& EDGE_FALLTHRU
)
1791 if (e2
->flags
& EDGE_FALLTHRU
)
1795 /* If number of edges of various types does not match, fail. */
1796 if (nehedges1
!= nehedges2
1797 || (fallthru1
!= 0) != (fallthru2
!= 0))
1800 /* If !ACCUMULATE_OUTGOING_ARGS, bb1 (and bb2) have no successors
1801 and the last real insn doesn't have REG_ARGS_SIZE note, don't
1802 attempt to optimize, as the two basic blocks might have different
1803 REG_ARGS_SIZE depths. For noreturn calls and unconditional
1804 traps there should be REG_ARG_SIZE notes, they could be missing
1805 for __builtin_unreachable () uses though. */
1807 && !ACCUMULATE_OUTGOING_ARGS
1809 || !find_reg_note (last1
, REG_ARGS_SIZE
, NULL
)))
1812 /* fallthru edges must be forwarded to the same destination. */
1815 basic_block d1
= (forwarder_block_p (fallthru1
->dest
)
1816 ? single_succ (fallthru1
->dest
): fallthru1
->dest
);
1817 basic_block d2
= (forwarder_block_p (fallthru2
->dest
)
1818 ? single_succ (fallthru2
->dest
): fallthru2
->dest
);
1824 /* Ensure the same EH region. */
1826 rtx n1
= find_reg_note (BB_END (bb1
), REG_EH_REGION
, 0);
1827 rtx n2
= find_reg_note (BB_END (bb2
), REG_EH_REGION
, 0);
1832 if (n1
&& (!n2
|| XEXP (n1
, 0) != XEXP (n2
, 0)))
1836 /* The same checks as in try_crossjump_to_edge. It is required for RTL
1837 version of sequence abstraction. */
1838 FOR_EACH_EDGE (e1
, ei
, bb2
->succs
)
1842 basic_block d1
= e1
->dest
;
1844 if (FORWARDER_BLOCK_P (d1
))
1845 d1
= EDGE_SUCC (d1
, 0)->dest
;
1847 FOR_EACH_EDGE (e2
, ei
, bb1
->succs
)
1849 basic_block d2
= e2
->dest
;
1850 if (FORWARDER_BLOCK_P (d2
))
1851 d2
= EDGE_SUCC (d2
, 0)->dest
;
1863 /* Returns true if BB basic block has a preserve label. */
1866 block_has_preserve_label (basic_block bb
)
1870 && LABEL_PRESERVE_P (block_label (bb
)));
1873 /* E1 and E2 are edges with the same destination block. Search their
1874 predecessors for common code. If found, redirect control flow from
1875 (maybe the middle of) E1->SRC to (maybe the middle of) E2->SRC (dir_forward),
1876 or the other way around (dir_backward). DIR specifies the allowed
1877 replacement direction. */
1880 try_crossjump_to_edge (int mode
, edge e1
, edge e2
,
1881 enum replace_direction dir
)
1884 basic_block src1
= e1
->src
, src2
= e2
->src
;
1885 basic_block redirect_to
, redirect_from
, to_remove
;
1886 basic_block osrc1
, osrc2
, redirect_edges_to
, tmp
;
1887 rtx newpos1
, newpos2
;
1891 newpos1
= newpos2
= NULL_RTX
;
1893 /* If we have partitioned hot/cold basic blocks, it is a bad idea
1894 to try this optimization.
1896 Basic block partitioning may result in some jumps that appear to
1897 be optimizable (or blocks that appear to be mergeable), but which really
1898 must be left untouched (they are required to make it safely across
1899 partition boundaries). See the comments at the top of
1900 bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
1902 if (crtl
->has_bb_partition
&& reload_completed
)
1905 /* Search backward through forwarder blocks. We don't need to worry
1906 about multiple entry or chained forwarders, as they will be optimized
1907 away. We do this to look past the unconditional jump following a
1908 conditional jump that is required due to the current CFG shape. */
1909 if (single_pred_p (src1
)
1910 && FORWARDER_BLOCK_P (src1
))
1911 e1
= single_pred_edge (src1
), src1
= e1
->src
;
1913 if (single_pred_p (src2
)
1914 && FORWARDER_BLOCK_P (src2
))
1915 e2
= single_pred_edge (src2
), src2
= e2
->src
;
1917 /* Nothing to do if we reach ENTRY, or a common source block. */
1918 if (src1
== ENTRY_BLOCK_PTR_FOR_FN (cfun
) || src2
1919 == ENTRY_BLOCK_PTR_FOR_FN (cfun
))
1924 /* Seeing more than 1 forwarder blocks would confuse us later... */
1925 if (FORWARDER_BLOCK_P (e1
->dest
)
1926 && FORWARDER_BLOCK_P (single_succ (e1
->dest
)))
1929 if (FORWARDER_BLOCK_P (e2
->dest
)
1930 && FORWARDER_BLOCK_P (single_succ (e2
->dest
)))
1933 /* Likewise with dead code (possibly newly created by the other optimizations
1935 if (EDGE_COUNT (src1
->preds
) == 0 || EDGE_COUNT (src2
->preds
) == 0)
1938 /* Look for the common insn sequence, part the first ... */
1939 if (!outgoing_edges_match (mode
, src1
, src2
))
1942 /* ... and part the second. */
1943 nmatch
= flow_find_cross_jump (src1
, src2
, &newpos1
, &newpos2
, &dir
);
1947 if (newpos1
!= NULL_RTX
)
1948 src1
= BLOCK_FOR_INSN (newpos1
);
1949 if (newpos2
!= NULL_RTX
)
1950 src2
= BLOCK_FOR_INSN (newpos2
);
1952 if (dir
== dir_backward
)
1954 #define SWAP(T, X, Y) do { T tmp = (X); (X) = (Y); (Y) = tmp; } while (0)
1955 SWAP (basic_block
, osrc1
, osrc2
);
1956 SWAP (basic_block
, src1
, src2
);
1957 SWAP (edge
, e1
, e2
);
1958 SWAP (rtx
, newpos1
, newpos2
);
1962 /* Don't proceed with the crossjump unless we found a sufficient number
1963 of matching instructions or the 'from' block was totally matched
1964 (such that its predecessors will hopefully be redirected and the
1966 if ((nmatch
< PARAM_VALUE (PARAM_MIN_CROSSJUMP_INSNS
))
1967 && (newpos1
!= BB_HEAD (src1
)))
1970 /* Avoid deleting preserve label when redirecting ABNORMAL edges. */
1971 if (block_has_preserve_label (e1
->dest
)
1972 && (e1
->flags
& EDGE_ABNORMAL
))
1975 /* Here we know that the insns in the end of SRC1 which are common with SRC2
1977 If we have tablejumps in the end of SRC1 and SRC2
1978 they have been already compared for equivalence in outgoing_edges_match ()
1979 so replace the references to TABLE1 by references to TABLE2. */
1982 rtx_jump_table_data
*table1
, *table2
;
1984 if (tablejump_p (BB_END (osrc1
), &label1
, &table1
)
1985 && tablejump_p (BB_END (osrc2
), &label2
, &table2
)
1986 && label1
!= label2
)
1988 replace_label_data rr
;
1991 /* Replace references to LABEL1 with LABEL2. */
1994 rr
.update_label_nuses
= true;
1995 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1997 /* Do not replace the label in SRC1->END because when deleting
1998 a block whose end is a tablejump, the tablejump referenced
1999 from the instruction is deleted too. */
2000 if (insn
!= BB_END (osrc1
))
2001 for_each_rtx (&insn
, replace_label
, &rr
);
2006 /* Avoid splitting if possible. We must always split when SRC2 has
2007 EH predecessor edges, or we may end up with basic blocks with both
2008 normal and EH predecessor edges. */
2009 if (newpos2
== BB_HEAD (src2
)
2010 && !(EDGE_PRED (src2
, 0)->flags
& EDGE_EH
))
2014 if (newpos2
== BB_HEAD (src2
))
2016 /* Skip possible basic block header. */
2017 if (LABEL_P (newpos2
))
2018 newpos2
= NEXT_INSN (newpos2
);
2019 while (DEBUG_INSN_P (newpos2
))
2020 newpos2
= NEXT_INSN (newpos2
);
2021 if (NOTE_P (newpos2
))
2022 newpos2
= NEXT_INSN (newpos2
);
2023 while (DEBUG_INSN_P (newpos2
))
2024 newpos2
= NEXT_INSN (newpos2
);
2028 fprintf (dump_file
, "Splitting bb %i before %i insns\n",
2029 src2
->index
, nmatch
);
2030 redirect_to
= split_block (src2
, PREV_INSN (newpos2
))->dest
;
2035 "Cross jumping from bb %i to bb %i; %i common insns\n",
2036 src1
->index
, src2
->index
, nmatch
);
2038 /* We may have some registers visible through the block. */
2039 df_set_bb_dirty (redirect_to
);
2042 redirect_edges_to
= redirect_to
;
2044 redirect_edges_to
= osrc2
;
2046 /* Recompute the frequencies and counts of outgoing edges. */
2047 FOR_EACH_EDGE (s
, ei
, redirect_edges_to
->succs
)
2051 basic_block d
= s
->dest
;
2053 if (FORWARDER_BLOCK_P (d
))
2054 d
= single_succ (d
);
2056 FOR_EACH_EDGE (s2
, ei
, src1
->succs
)
2058 basic_block d2
= s2
->dest
;
2059 if (FORWARDER_BLOCK_P (d2
))
2060 d2
= single_succ (d2
);
2065 s
->count
+= s2
->count
;
2067 /* Take care to update possible forwarder blocks. We verified
2068 that there is no more than one in the chain, so we can't run
2069 into infinite loop. */
2070 if (FORWARDER_BLOCK_P (s
->dest
))
2072 single_succ_edge (s
->dest
)->count
+= s2
->count
;
2073 s
->dest
->count
+= s2
->count
;
2074 s
->dest
->frequency
+= EDGE_FREQUENCY (s
);
2077 if (FORWARDER_BLOCK_P (s2
->dest
))
2079 single_succ_edge (s2
->dest
)->count
-= s2
->count
;
2080 if (single_succ_edge (s2
->dest
)->count
< 0)
2081 single_succ_edge (s2
->dest
)->count
= 0;
2082 s2
->dest
->count
-= s2
->count
;
2083 s2
->dest
->frequency
-= EDGE_FREQUENCY (s
);
2084 if (s2
->dest
->frequency
< 0)
2085 s2
->dest
->frequency
= 0;
2086 if (s2
->dest
->count
< 0)
2087 s2
->dest
->count
= 0;
2090 if (!redirect_edges_to
->frequency
&& !src1
->frequency
)
2091 s
->probability
= (s
->probability
+ s2
->probability
) / 2;
2094 = ((s
->probability
* redirect_edges_to
->frequency
+
2095 s2
->probability
* src1
->frequency
)
2096 / (redirect_edges_to
->frequency
+ src1
->frequency
));
2099 /* Adjust count and frequency for the block. An earlier jump
2100 threading pass may have left the profile in an inconsistent
2101 state (see update_bb_profile_for_threading) so we must be
2102 prepared for overflows. */
2106 tmp
->count
+= src1
->count
;
2107 tmp
->frequency
+= src1
->frequency
;
2108 if (tmp
->frequency
> BB_FREQ_MAX
)
2109 tmp
->frequency
= BB_FREQ_MAX
;
2110 if (tmp
== redirect_edges_to
)
2112 tmp
= find_fallthru_edge (tmp
->succs
)->dest
;
2115 update_br_prob_note (redirect_edges_to
);
2117 /* Edit SRC1 to go to REDIRECT_TO at NEWPOS1. */
2119 /* Skip possible basic block header. */
2120 if (LABEL_P (newpos1
))
2121 newpos1
= NEXT_INSN (newpos1
);
2123 while (DEBUG_INSN_P (newpos1
))
2124 newpos1
= NEXT_INSN (newpos1
);
2126 if (NOTE_INSN_BASIC_BLOCK_P (newpos1
))
2127 newpos1
= NEXT_INSN (newpos1
);
2129 while (DEBUG_INSN_P (newpos1
))
2130 newpos1
= NEXT_INSN (newpos1
);
2132 redirect_from
= split_block (src1
, PREV_INSN (newpos1
))->src
;
2133 to_remove
= single_succ (redirect_from
);
2135 redirect_edge_and_branch_force (single_succ_edge (redirect_from
), redirect_to
);
2136 delete_basic_block (to_remove
);
2138 update_forwarder_flag (redirect_from
);
2139 if (redirect_to
!= src2
)
2140 update_forwarder_flag (src2
);
2145 /* Search the predecessors of BB for common insn sequences. When found,
2146 share code between them by redirecting control flow. Return true if
2147 any changes made. */
2150 try_crossjump_bb (int mode
, basic_block bb
)
2152 edge e
, e2
, fallthru
;
2154 unsigned max
, ix
, ix2
;
2156 /* Nothing to do if there is not at least two incoming edges. */
2157 if (EDGE_COUNT (bb
->preds
) < 2)
2160 /* Don't crossjump if this block ends in a computed jump,
2161 unless we are optimizing for size. */
2162 if (optimize_bb_for_size_p (bb
)
2163 && bb
!= EXIT_BLOCK_PTR_FOR_FN (cfun
)
2164 && computed_jump_p (BB_END (bb
)))
2167 /* If we are partitioning hot/cold basic blocks, we don't want to
2168 mess up unconditional or indirect jumps that cross between hot
2171 Basic block partitioning may result in some jumps that appear to
2172 be optimizable (or blocks that appear to be mergeable), but which really
2173 must be left untouched (they are required to make it safely across
2174 partition boundaries). See the comments at the top of
2175 bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */
2177 if (BB_PARTITION (EDGE_PRED (bb
, 0)->src
) !=
2178 BB_PARTITION (EDGE_PRED (bb
, 1)->src
)
2179 || (EDGE_PRED (bb
, 0)->flags
& EDGE_CROSSING
))
2182 /* It is always cheapest to redirect a block that ends in a branch to
2183 a block that falls through into BB, as that adds no branches to the
2184 program. We'll try that combination first. */
2186 max
= PARAM_VALUE (PARAM_MAX_CROSSJUMP_EDGES
);
2188 if (EDGE_COUNT (bb
->preds
) > max
)
2191 fallthru
= find_fallthru_edge (bb
->preds
);
2194 for (ix
= 0; ix
< EDGE_COUNT (bb
->preds
);)
2196 e
= EDGE_PRED (bb
, ix
);
2199 /* As noted above, first try with the fallthru predecessor (or, a
2200 fallthru predecessor if we are in cfglayout mode). */
2203 /* Don't combine the fallthru edge into anything else.
2204 If there is a match, we'll do it the other way around. */
2207 /* If nothing changed since the last attempt, there is nothing
2210 && !((e
->src
->flags
& BB_MODIFIED
)
2211 || (fallthru
->src
->flags
& BB_MODIFIED
)))
2214 if (try_crossjump_to_edge (mode
, e
, fallthru
, dir_forward
))
2222 /* Non-obvious work limiting check: Recognize that we're going
2223 to call try_crossjump_bb on every basic block. So if we have
2224 two blocks with lots of outgoing edges (a switch) and they
2225 share lots of common destinations, then we would do the
2226 cross-jump check once for each common destination.
2228 Now, if the blocks actually are cross-jump candidates, then
2229 all of their destinations will be shared. Which means that
2230 we only need check them for cross-jump candidacy once. We
2231 can eliminate redundant checks of crossjump(A,B) by arbitrarily
2232 choosing to do the check from the block for which the edge
2233 in question is the first successor of A. */
2234 if (EDGE_SUCC (e
->src
, 0) != e
)
2237 for (ix2
= 0; ix2
< EDGE_COUNT (bb
->preds
); ix2
++)
2239 e2
= EDGE_PRED (bb
, ix2
);
2244 /* We've already checked the fallthru edge above. */
2248 /* The "first successor" check above only prevents multiple
2249 checks of crossjump(A,B). In order to prevent redundant
2250 checks of crossjump(B,A), require that A be the block
2251 with the lowest index. */
2252 if (e
->src
->index
> e2
->src
->index
)
2255 /* If nothing changed since the last attempt, there is nothing
2258 && !((e
->src
->flags
& BB_MODIFIED
)
2259 || (e2
->src
->flags
& BB_MODIFIED
)))
2262 /* Both e and e2 are not fallthru edges, so we can crossjump in either
2264 if (try_crossjump_to_edge (mode
, e
, e2
, dir_both
))
2274 crossjumps_occured
= true;
2279 /* Search the successors of BB for common insn sequences. When found,
2280 share code between them by moving it across the basic block
2281 boundary. Return true if any changes made. */
2284 try_head_merge_bb (basic_block bb
)
2286 basic_block final_dest_bb
= NULL
;
2287 int max_match
= INT_MAX
;
2289 rtx
*headptr
, *currptr
, *nextptr
;
2290 bool changed
, moveall
;
2292 rtx e0_last_head
, cond
, move_before
;
2293 unsigned nedges
= EDGE_COUNT (bb
->succs
);
2294 rtx jump
= BB_END (bb
);
2295 regset live
, live_union
;
2297 /* Nothing to do if there is not at least two outgoing edges. */
2301 /* Don't crossjump if this block ends in a computed jump,
2302 unless we are optimizing for size. */
2303 if (optimize_bb_for_size_p (bb
)
2304 && bb
!= EXIT_BLOCK_PTR_FOR_FN (cfun
)
2305 && computed_jump_p (BB_END (bb
)))
2308 cond
= get_condition (jump
, &move_before
, true, false);
2309 if (cond
== NULL_RTX
)
2312 if (reg_mentioned_p (cc0_rtx
, jump
))
2313 move_before
= prev_nonnote_nondebug_insn (jump
);
2319 for (ix
= 0; ix
< nedges
; ix
++)
2320 if (EDGE_SUCC (bb
, ix
)->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
2323 for (ix
= 0; ix
< nedges
; ix
++)
2325 edge e
= EDGE_SUCC (bb
, ix
);
2326 basic_block other_bb
= e
->dest
;
2328 if (df_get_bb_dirty (other_bb
))
2330 block_was_dirty
= true;
2334 if (e
->flags
& EDGE_ABNORMAL
)
2337 /* Normally, all destination blocks must only be reachable from this
2338 block, i.e. they must have one incoming edge.
2340 There is one special case we can handle, that of multiple consecutive
2341 jumps where the first jumps to one of the targets of the second jump.
2342 This happens frequently in switch statements for default labels.
2343 The structure is as follows:
2349 jump with targets A, B, C, D...
2351 has two incoming edges, from FINAL_DEST_BB and BB
2353 In this case, we can try to move the insns through BB and into
2355 if (EDGE_COUNT (other_bb
->preds
) != 1)
2357 edge incoming_edge
, incoming_bb_other_edge
;
2360 if (final_dest_bb
!= NULL
2361 || EDGE_COUNT (other_bb
->preds
) != 2)
2364 /* We must be able to move the insns across the whole block. */
2365 move_before
= BB_HEAD (bb
);
2366 while (!NONDEBUG_INSN_P (move_before
))
2367 move_before
= NEXT_INSN (move_before
);
2369 if (EDGE_COUNT (bb
->preds
) != 1)
2371 incoming_edge
= EDGE_PRED (bb
, 0);
2372 final_dest_bb
= incoming_edge
->src
;
2373 if (EDGE_COUNT (final_dest_bb
->succs
) != 2)
2375 FOR_EACH_EDGE (incoming_bb_other_edge
, ei
, final_dest_bb
->succs
)
2376 if (incoming_bb_other_edge
!= incoming_edge
)
2378 if (incoming_bb_other_edge
->dest
!= other_bb
)
2383 e0
= EDGE_SUCC (bb
, 0);
2384 e0_last_head
= NULL_RTX
;
2387 for (ix
= 1; ix
< nedges
; ix
++)
2389 edge e
= EDGE_SUCC (bb
, ix
);
2390 rtx e0_last
, e_last
;
2393 nmatch
= flow_find_head_matching_sequence (e0
->dest
, e
->dest
,
2394 &e0_last
, &e_last
, 0);
2398 if (nmatch
< max_match
)
2401 e0_last_head
= e0_last
;
2405 /* If we matched an entire block, we probably have to avoid moving the
2408 && e0_last_head
== BB_END (e0
->dest
)
2409 && (find_reg_note (e0_last_head
, REG_EH_REGION
, 0)
2410 || control_flow_insn_p (e0_last_head
)))
2416 e0_last_head
= prev_real_insn (e0_last_head
);
2417 while (DEBUG_INSN_P (e0_last_head
));
2423 /* We must find a union of the live registers at each of the end points. */
2424 live
= BITMAP_ALLOC (NULL
);
2425 live_union
= BITMAP_ALLOC (NULL
);
2427 currptr
= XNEWVEC (rtx
, nedges
);
2428 headptr
= XNEWVEC (rtx
, nedges
);
2429 nextptr
= XNEWVEC (rtx
, nedges
);
2431 for (ix
= 0; ix
< nedges
; ix
++)
2434 basic_block merge_bb
= EDGE_SUCC (bb
, ix
)->dest
;
2435 rtx head
= BB_HEAD (merge_bb
);
2437 while (!NONDEBUG_INSN_P (head
))
2438 head
= NEXT_INSN (head
);
2442 /* Compute the end point and live information */
2443 for (j
= 1; j
< max_match
; j
++)
2445 head
= NEXT_INSN (head
);
2446 while (!NONDEBUG_INSN_P (head
));
2447 simulate_backwards_to_point (merge_bb
, live
, head
);
2448 IOR_REG_SET (live_union
, live
);
2451 /* If we're moving across two blocks, verify the validity of the
2452 first move, then adjust the target and let the loop below deal
2453 with the final move. */
2454 if (final_dest_bb
!= NULL
)
2458 moveall
= can_move_insns_across (currptr
[0], e0_last_head
, move_before
,
2459 jump
, e0
->dest
, live_union
,
2463 if (move_upto
== NULL_RTX
)
2466 while (e0_last_head
!= move_upto
)
2468 df_simulate_one_insn_backwards (e0
->dest
, e0_last_head
,
2470 e0_last_head
= PREV_INSN (e0_last_head
);
2473 if (e0_last_head
== NULL_RTX
)
2476 jump
= BB_END (final_dest_bb
);
2477 cond
= get_condition (jump
, &move_before
, true, false);
2478 if (cond
== NULL_RTX
)
2481 if (reg_mentioned_p (cc0_rtx
, jump
))
2482 move_before
= prev_nonnote_nondebug_insn (jump
);
2492 moveall
= can_move_insns_across (currptr
[0], e0_last_head
,
2493 move_before
, jump
, e0
->dest
, live_union
,
2495 if (!moveall
&& move_upto
== NULL_RTX
)
2497 if (jump
== move_before
)
2500 /* Try again, using a different insertion point. */
2504 /* Don't try moving before a cc0 user, as that may invalidate
2506 if (reg_mentioned_p (cc0_rtx
, jump
))
2513 if (final_dest_bb
&& !moveall
)
2514 /* We haven't checked whether a partial move would be OK for the first
2515 move, so we have to fail this case. */
2521 if (currptr
[0] == move_upto
)
2523 for (ix
= 0; ix
< nedges
; ix
++)
2525 rtx curr
= currptr
[ix
];
2527 curr
= NEXT_INSN (curr
);
2528 while (!NONDEBUG_INSN_P (curr
));
2533 /* If we can't currently move all of the identical insns, remember
2534 each insn after the range that we'll merge. */
2536 for (ix
= 0; ix
< nedges
; ix
++)
2538 rtx curr
= currptr
[ix
];
2540 curr
= NEXT_INSN (curr
);
2541 while (!NONDEBUG_INSN_P (curr
));
2545 reorder_insns (headptr
[0], currptr
[0], PREV_INSN (move_before
));
2546 df_set_bb_dirty (EDGE_SUCC (bb
, 0)->dest
);
2547 if (final_dest_bb
!= NULL
)
2548 df_set_bb_dirty (final_dest_bb
);
2549 df_set_bb_dirty (bb
);
2550 for (ix
= 1; ix
< nedges
; ix
++)
2552 df_set_bb_dirty (EDGE_SUCC (bb
, ix
)->dest
);
2553 delete_insn_chain (headptr
[ix
], currptr
[ix
], false);
2557 if (jump
== move_before
)
2560 /* For the unmerged insns, try a different insertion point. */
2564 /* Don't try moving before a cc0 user, as that may invalidate
2566 if (reg_mentioned_p (cc0_rtx
, jump
))
2570 for (ix
= 0; ix
< nedges
; ix
++)
2571 currptr
[ix
] = headptr
[ix
] = nextptr
[ix
];
2581 crossjumps_occured
|= changed
;
2586 /* Return true if BB contains just bb note, or bb note followed
2587 by only DEBUG_INSNs. */
2590 trivially_empty_bb_p (basic_block bb
)
2592 rtx insn
= BB_END (bb
);
2596 if (insn
== BB_HEAD (bb
))
2598 if (!DEBUG_INSN_P (insn
))
2600 insn
= PREV_INSN (insn
);
2604 /* Do simple CFG optimizations - basic block merging, simplifying of jump
2605 instructions etc. Return nonzero if changes were made. */
2608 try_optimize_cfg (int mode
)
2610 bool changed_overall
= false;
2613 basic_block bb
, b
, next
;
2615 if (mode
& (CLEANUP_CROSSJUMP
| CLEANUP_THREADING
))
2618 crossjumps_occured
= false;
2620 FOR_EACH_BB_FN (bb
, cfun
)
2621 update_forwarder_flag (bb
);
2623 if (! targetm
.cannot_modify_jumps_p ())
2626 /* Attempt to merge blocks as made possible by edge removal. If
2627 a block has only one successor, and the successor has only
2628 one predecessor, they may be combined. */
2631 block_was_dirty
= false;
2637 "\n\ntry_optimize_cfg iteration %i\n\n",
2640 for (b
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->next_bb
; b
2641 != EXIT_BLOCK_PTR_FOR_FN (cfun
);)
2645 bool changed_here
= false;
2647 /* Delete trivially dead basic blocks. This is either
2648 blocks with no predecessors, or empty blocks with no
2649 successors. However if the empty block with no
2650 successors is the successor of the ENTRY_BLOCK, it is
2651 kept. This ensures that the ENTRY_BLOCK will have a
2652 successor which is a precondition for many RTL
2653 passes. Empty blocks may result from expanding
2654 __builtin_unreachable (). */
2655 if (EDGE_COUNT (b
->preds
) == 0
2656 || (EDGE_COUNT (b
->succs
) == 0
2657 && trivially_empty_bb_p (b
)
2658 && single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
))->dest
2662 if (EDGE_COUNT (b
->preds
) > 0)
2667 if (current_ir_type () == IR_RTL_CFGLAYOUT
)
2670 && BARRIER_P (BB_FOOTER (b
)))
2671 FOR_EACH_EDGE (e
, ei
, b
->preds
)
2672 if ((e
->flags
& EDGE_FALLTHRU
)
2673 && BB_FOOTER (e
->src
) == NULL
)
2677 SET_BB_FOOTER (e
->src
) = BB_FOOTER (b
);
2678 SET_BB_FOOTER (b
) = NULL
;
2683 SET_BB_FOOTER (e
->src
) = emit_barrier ();
2690 rtx last
= get_last_bb_insn (b
);
2691 if (last
&& BARRIER_P (last
))
2692 FOR_EACH_EDGE (e
, ei
, b
->preds
)
2693 if ((e
->flags
& EDGE_FALLTHRU
))
2694 emit_barrier_after (BB_END (e
->src
));
2697 delete_basic_block (b
);
2699 /* Avoid trying to remove the exit block. */
2700 b
= (c
== ENTRY_BLOCK_PTR_FOR_FN (cfun
) ? c
->next_bb
: c
);
2704 /* Remove code labels no longer used. */
2705 if (single_pred_p (b
)
2706 && (single_pred_edge (b
)->flags
& EDGE_FALLTHRU
)
2707 && !(single_pred_edge (b
)->flags
& EDGE_COMPLEX
)
2708 && LABEL_P (BB_HEAD (b
))
2709 /* If the previous block ends with a branch to this
2710 block, we can't delete the label. Normally this
2711 is a condjump that is yet to be simplified, but
2712 if CASE_DROPS_THRU, this can be a tablejump with
2713 some element going to the same place as the
2714 default (fallthru). */
2715 && (single_pred (b
) == ENTRY_BLOCK_PTR_FOR_FN (cfun
)
2716 || !JUMP_P (BB_END (single_pred (b
)))
2717 || ! label_is_jump_target_p (BB_HEAD (b
),
2718 BB_END (single_pred (b
)))))
2720 delete_insn (BB_HEAD (b
));
2722 fprintf (dump_file
, "Deleted label in block %i.\n",
2726 /* If we fall through an empty block, we can remove it. */
2727 if (!(mode
& (CLEANUP_CFGLAYOUT
| CLEANUP_NO_INSN_DEL
))
2728 && single_pred_p (b
)
2729 && (single_pred_edge (b
)->flags
& EDGE_FALLTHRU
)
2730 && !LABEL_P (BB_HEAD (b
))
2731 && FORWARDER_BLOCK_P (b
)
2732 /* Note that forwarder_block_p true ensures that
2733 there is a successor for this block. */
2734 && (single_succ_edge (b
)->flags
& EDGE_FALLTHRU
)
2735 && n_basic_blocks_for_fn (cfun
) > NUM_FIXED_BLOCKS
+ 1)
2739 "Deleting fallthru block %i.\n",
2742 c
= ((b
->prev_bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
2743 ? b
->next_bb
: b
->prev_bb
);
2744 redirect_edge_succ_nodup (single_pred_edge (b
),
2746 delete_basic_block (b
);
2752 /* Merge B with its single successor, if any. */
2753 if (single_succ_p (b
)
2754 && (s
= single_succ_edge (b
))
2755 && !(s
->flags
& EDGE_COMPLEX
)
2756 && (c
= s
->dest
) != EXIT_BLOCK_PTR_FOR_FN (cfun
)
2757 && single_pred_p (c
)
2760 /* When not in cfg_layout mode use code aware of reordering
2761 INSN. This code possibly creates new basic blocks so it
2762 does not fit merge_blocks interface and is kept here in
2763 hope that it will become useless once more of compiler
2764 is transformed to use cfg_layout mode. */
2766 if ((mode
& CLEANUP_CFGLAYOUT
)
2767 && can_merge_blocks_p (b
, c
))
2769 merge_blocks (b
, c
);
2770 update_forwarder_flag (b
);
2771 changed_here
= true;
2773 else if (!(mode
& CLEANUP_CFGLAYOUT
)
2774 /* If the jump insn has side effects,
2775 we can't kill the edge. */
2776 && (!JUMP_P (BB_END (b
))
2777 || (reload_completed
2778 ? simplejump_p (BB_END (b
))
2779 : (onlyjump_p (BB_END (b
))
2780 && !tablejump_p (BB_END (b
),
2782 && (next
= merge_blocks_move (s
, b
, c
, mode
)))
2785 changed_here
= true;
2789 /* Simplify branch over branch. */
2790 if ((mode
& CLEANUP_EXPENSIVE
)
2791 && !(mode
& CLEANUP_CFGLAYOUT
)
2792 && try_simplify_condjump (b
))
2793 changed_here
= true;
2795 /* If B has a single outgoing edge, but uses a
2796 non-trivial jump instruction without side-effects, we
2797 can either delete the jump entirely, or replace it
2798 with a simple unconditional jump. */
2799 if (single_succ_p (b
)
2800 && single_succ (b
) != EXIT_BLOCK_PTR_FOR_FN (cfun
)
2801 && onlyjump_p (BB_END (b
))
2802 && !CROSSING_JUMP_P (BB_END (b
))
2803 && try_redirect_by_replacing_jump (single_succ_edge (b
),
2805 (mode
& CLEANUP_CFGLAYOUT
) != 0))
2807 update_forwarder_flag (b
);
2808 changed_here
= true;
2811 /* Simplify branch to branch. */
2812 if (try_forward_edges (mode
, b
))
2814 update_forwarder_flag (b
);
2815 changed_here
= true;
2818 /* Look for shared code between blocks. */
2819 if ((mode
& CLEANUP_CROSSJUMP
)
2820 && try_crossjump_bb (mode
, b
))
2821 changed_here
= true;
2823 if ((mode
& CLEANUP_CROSSJUMP
)
2824 /* This can lengthen register lifetimes. Do it only after
2827 && try_head_merge_bb (b
))
2828 changed_here
= true;
2830 /* Don't get confused by the index shift caused by
2838 if ((mode
& CLEANUP_CROSSJUMP
)
2839 && try_crossjump_bb (mode
, EXIT_BLOCK_PTR_FOR_FN (cfun
)))
2842 if (block_was_dirty
)
2844 /* This should only be set by head-merging. */
2845 gcc_assert (mode
& CLEANUP_CROSSJUMP
);
2851 /* Edge forwarding in particular can cause hot blocks previously
2852 reached by both hot and cold blocks to become dominated only
2853 by cold blocks. This will cause the verification below to fail,
2854 and lead to now cold code in the hot section. This is not easy
2855 to detect and fix during edge forwarding, and in some cases
2856 is only visible after newly unreachable blocks are deleted,
2857 which will be done in fixup_partitions. */
2858 fixup_partitions ();
2860 #ifdef ENABLE_CHECKING
2861 verify_flow_info ();
2865 changed_overall
|= changed
;
2871 FOR_ALL_BB_FN (b
, cfun
)
2872 b
->flags
&= ~(BB_FORWARDER_BLOCK
| BB_NONTHREADABLE_BLOCK
);
2874 return changed_overall
;
2877 /* Delete all unreachable basic blocks. */
2880 delete_unreachable_blocks (void)
2882 bool changed
= false;
2883 basic_block b
, prev_bb
;
2885 find_unreachable_blocks ();
2887 /* When we're in GIMPLE mode and there may be debug insns, we should
2888 delete blocks in reverse dominator order, so as to get a chance
2889 to substitute all released DEFs into debug stmts. If we don't
2890 have dominators information, walking blocks backward gets us a
2891 better chance of retaining most debug information than
2893 if (MAY_HAVE_DEBUG_INSNS
&& current_ir_type () == IR_GIMPLE
2894 && dom_info_available_p (CDI_DOMINATORS
))
2896 for (b
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
2897 b
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
); b
= prev_bb
)
2899 prev_bb
= b
->prev_bb
;
2901 if (!(b
->flags
& BB_REACHABLE
))
2903 /* Speed up the removal of blocks that don't dominate
2904 others. Walking backwards, this should be the common
2906 if (!first_dom_son (CDI_DOMINATORS
, b
))
2907 delete_basic_block (b
);
2911 = get_all_dominated_blocks (CDI_DOMINATORS
, b
);
2917 prev_bb
= b
->prev_bb
;
2919 gcc_assert (!(b
->flags
& BB_REACHABLE
));
2921 delete_basic_block (b
);
2933 for (b
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
2934 b
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
); b
= prev_bb
)
2936 prev_bb
= b
->prev_bb
;
2938 if (!(b
->flags
& BB_REACHABLE
))
2940 delete_basic_block (b
);
2947 tidy_fallthru_edges ();
2951 /* Delete any jump tables never referenced. We can't delete them at the
2952 time of removing tablejump insn as they are referenced by the preceding
2953 insns computing the destination, so we delay deleting and garbagecollect
2954 them once life information is computed. */
2956 delete_dead_jumptables (void)
2960 /* A dead jump table does not belong to any basic block. Scan insns
2961 between two adjacent basic blocks. */
2962 FOR_EACH_BB_FN (bb
, cfun
)
2966 for (insn
= NEXT_INSN (BB_END (bb
));
2967 insn
&& !NOTE_INSN_BASIC_BLOCK_P (insn
);
2970 next
= NEXT_INSN (insn
);
2972 && LABEL_NUSES (insn
) == LABEL_PRESERVE_P (insn
)
2973 && JUMP_TABLE_DATA_P (next
))
2975 rtx label
= insn
, jump
= next
;
2978 fprintf (dump_file
, "Dead jumptable %i removed\n",
2981 next
= NEXT_INSN (next
);
2983 delete_insn (label
);
2990 /* Tidy the CFG by deleting unreachable code and whatnot. */
2993 cleanup_cfg (int mode
)
2995 bool changed
= false;
2997 /* Set the cfglayout mode flag here. We could update all the callers
2998 but that is just inconvenient, especially given that we eventually
2999 want to have cfglayout mode as the default. */
3000 if (current_ir_type () == IR_RTL_CFGLAYOUT
)
3001 mode
|= CLEANUP_CFGLAYOUT
;
3003 timevar_push (TV_CLEANUP_CFG
);
3004 if (delete_unreachable_blocks ())
3007 /* We've possibly created trivially dead code. Cleanup it right
3008 now to introduce more opportunities for try_optimize_cfg. */
3009 if (!(mode
& (CLEANUP_NO_INSN_DEL
))
3010 && !reload_completed
)
3011 delete_trivially_dead_insns (get_insns (), max_reg_num ());
3016 /* To tail-merge blocks ending in the same noreturn function (e.g.
3017 a call to abort) we have to insert fake edges to exit. Do this
3018 here once. The fake edges do not interfere with any other CFG
3020 if (mode
& CLEANUP_CROSSJUMP
)
3021 add_noreturn_fake_exit_edges ();
3023 if (!dbg_cnt (cfg_cleanup
))
3026 while (try_optimize_cfg (mode
))
3028 delete_unreachable_blocks (), changed
= true;
3029 if (!(mode
& CLEANUP_NO_INSN_DEL
))
3031 /* Try to remove some trivially dead insns when doing an expensive
3032 cleanup. But delete_trivially_dead_insns doesn't work after
3033 reload (it only handles pseudos) and run_fast_dce is too costly
3034 to run in every iteration.
3036 For effective cross jumping, we really want to run a fast DCE to
3037 clean up any dead conditions, or they get in the way of performing
3040 Other transformations in cleanup_cfg are not so sensitive to dead
3041 code, so delete_trivially_dead_insns or even doing nothing at all
3043 if ((mode
& CLEANUP_EXPENSIVE
) && !reload_completed
3044 && !delete_trivially_dead_insns (get_insns (), max_reg_num ()))
3046 if ((mode
& CLEANUP_CROSSJUMP
) && crossjumps_occured
)
3053 if (mode
& CLEANUP_CROSSJUMP
)
3054 remove_fake_exit_edges ();
3056 /* Don't call delete_dead_jumptables in cfglayout mode, because
3057 that function assumes that jump tables are in the insns stream.
3058 But we also don't _have_ to delete dead jumptables in cfglayout
3059 mode because we shouldn't even be looking at things that are
3060 not in a basic block. Dead jumptables are cleaned up when
3061 going out of cfglayout mode. */
3062 if (!(mode
& CLEANUP_CFGLAYOUT
))
3063 delete_dead_jumptables ();
3065 /* ??? We probably do this way too often. */
3068 || (mode
& CLEANUP_CFG_CHANGED
)))
3070 timevar_push (TV_REPAIR_LOOPS
);
3071 /* The above doesn't preserve dominance info if available. */
3072 gcc_assert (!dom_info_available_p (CDI_DOMINATORS
));
3073 calculate_dominance_info (CDI_DOMINATORS
);
3074 fix_loop_structure (NULL
);
3075 free_dominance_info (CDI_DOMINATORS
);
3076 timevar_pop (TV_REPAIR_LOOPS
);
3079 timevar_pop (TV_CLEANUP_CFG
);
3086 const pass_data pass_data_jump
=
3088 RTL_PASS
, /* type */
3090 OPTGROUP_NONE
, /* optinfo_flags */
3091 TV_JUMP
, /* tv_id */
3092 0, /* properties_required */
3093 0, /* properties_provided */
3094 0, /* properties_destroyed */
3095 0, /* todo_flags_start */
3096 0, /* todo_flags_finish */
3099 class pass_jump
: public rtl_opt_pass
3102 pass_jump (gcc::context
*ctxt
)
3103 : rtl_opt_pass (pass_data_jump
, ctxt
)
3106 /* opt_pass methods: */
3107 virtual unsigned int execute (function
*);
3109 }; // class pass_jump
3112 pass_jump::execute (function
*)
3114 delete_trivially_dead_insns (get_insns (), max_reg_num ());
3116 dump_flow_info (dump_file
, dump_flags
);
3117 cleanup_cfg ((optimize
? CLEANUP_EXPENSIVE
: 0)
3118 | (flag_thread_jumps
? CLEANUP_THREADING
: 0));
3125 make_pass_jump (gcc::context
*ctxt
)
3127 return new pass_jump (ctxt
);
3132 const pass_data pass_data_jump2
=
3134 RTL_PASS
, /* type */
3136 OPTGROUP_NONE
, /* optinfo_flags */
3137 TV_JUMP
, /* tv_id */
3138 0, /* properties_required */
3139 0, /* properties_provided */
3140 0, /* properties_destroyed */
3141 0, /* todo_flags_start */
3142 0, /* todo_flags_finish */
3145 class pass_jump2
: public rtl_opt_pass
3148 pass_jump2 (gcc::context
*ctxt
)
3149 : rtl_opt_pass (pass_data_jump2
, ctxt
)
3152 /* opt_pass methods: */
3153 virtual unsigned int execute (function
*)
3155 cleanup_cfg (flag_crossjumping
? CLEANUP_CROSSJUMP
: 0);
3159 }; // class pass_jump2
3164 make_pass_jump2 (gcc::context
*ctxt
)
3166 return new pass_jump2 (ctxt
);