1 /* Thread edges through blocks and update the control flow and SSA graphs.
2 Copyright (C) 2004, 2005, 2006, 2007 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"
29 #include "basic-block.h"
33 #include "diagnostic.h"
34 #include "tree-flow.h"
35 #include "tree-dump.h"
36 #include "tree-pass.h"
39 /* Given a block B, update the CFG and SSA graph to reflect redirecting
40 one or more in-edges to B to instead reach the destination of an
41 out-edge from B while preserving any side effects in B.
43 i.e., given A->B and B->C, change A->B to be A->C yet still preserve the
44 side effects of executing B.
46 1. Make a copy of B (including its outgoing edges and statements). Call
47 the copy B'. Note B' has no incoming edges or PHIs at this time.
49 2. Remove the control statement at the end of B' and all outgoing edges
52 3. Add a new argument to each PHI in C with the same value as the existing
53 argument associated with edge B->C. Associate the new PHI arguments
56 4. For each PHI in B, find or create a PHI in B' with an identical
57 PHI_RESULT. Add an argument to the PHI in B' which has the same
58 value as the PHI in B associated with the edge A->B. Associate
59 the new argument in the PHI in B' with the edge A->B.
61 5. Change the edge A->B to A->B'.
63 5a. This automatically deletes any PHI arguments associated with the
66 5b. This automatically associates each new argument added in step 4
69 6. Repeat for other incoming edges into B.
71 7. Put the duplicated resources in B and all the B' blocks into SSA form.
73 Note that block duplication can be minimized by first collecting the
74 the set of unique destination blocks that the incoming edges should
75 be threaded to. Block duplication can be further minimized by using
76 B instead of creating B' for one destination if all edges into B are
77 going to be threaded to a successor of B.
79 We further reduce the number of edges and statements we create by
80 not copying all the outgoing edges and the control statement in
81 step #1. We instead create a template block without the outgoing
82 edges and duplicate the template. */
85 /* Steps #5 and #6 of the above algorithm are best implemented by walking
86 all the incoming edges which thread to the same destination edge at
87 the same time. That avoids lots of table lookups to get information
88 for the destination edge.
90 To realize that implementation we create a list of incoming edges
91 which thread to the same outgoing edge. Thus to implement steps
92 #5 and #6 we traverse our hash table of outgoing edge information.
93 For each entry we walk the list of incoming edges which thread to
94 the current outgoing edge. */
102 /* Main data structure recording information regarding B's duplicate
105 /* We need to efficiently record the unique thread destinations of this
106 block and specific information associated with those destinations. We
107 may have many incoming edges threaded to the same outgoing edge. This
108 can be naturally implemented with a hash table. */
110 struct redirection_data
112 /* A duplicate of B with the trailing control statement removed and which
113 targets a single successor of B. */
114 basic_block dup_block
;
116 /* An outgoing edge from B. DUP_BLOCK will have OUTGOING_EDGE->dest as
117 its single successor. */
120 /* A list of incoming edges which we want to thread to
121 OUTGOING_EDGE->dest. */
122 struct el
*incoming_edges
;
124 /* Flag indicating whether or not we should create a duplicate block
125 for this thread destination. This is only true if we are threading
126 all incoming edges and thus are using BB itself as a duplicate block. */
127 bool do_not_duplicate
;
130 /* Main data structure to hold information for duplicates of BB. */
131 static htab_t redirection_data
;
133 /* Data structure of information to pass to hash table traversal routines. */
136 /* The current block we are working on. */
139 /* A template copy of BB with no outgoing edges or control statement that
140 we use for creating copies. */
141 basic_block template_block
;
143 /* TRUE if we thread one or more jumps, FALSE otherwise. */
147 /* Passes which use the jump threading code register jump threading
148 opportunities as they are discovered. We keep the registered
149 jump threading opportunities in this vector as edge pairs
150 (original_edge, target_edge). */
151 static VEC(edge
,heap
) *threaded_edges
;
154 /* Jump threading statistics. */
156 struct thread_stats_d
158 unsigned long num_threaded_edges
;
161 struct thread_stats_d thread_stats
;
164 /* Remove the last statement in block BB if it is a control statement
165 Also remove all outgoing edges except the edge which reaches DEST_BB.
166 If DEST_BB is NULL, then remove all outgoing edges. */
169 remove_ctrl_stmt_and_useless_edges (basic_block bb
, basic_block dest_bb
)
171 block_stmt_iterator bsi
;
177 /* If the duplicate ends with a control statement, then remove it.
179 Note that if we are duplicating the template block rather than the
180 original basic block, then the duplicate might not have any real
184 && (TREE_CODE (bsi_stmt (bsi
)) == COND_EXPR
185 || TREE_CODE (bsi_stmt (bsi
)) == GOTO_EXPR
186 || TREE_CODE (bsi_stmt (bsi
)) == SWITCH_EXPR
))
187 bsi_remove (&bsi
, true);
189 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
191 if (e
->dest
!= dest_bb
)
198 /* Create a duplicate of BB which only reaches the destination of the edge
199 stored in RD. Record the duplicate block in RD. */
202 create_block_for_threading (basic_block bb
, struct redirection_data
*rd
)
204 /* We can use the generic block duplication code and simply remove
205 the stuff we do not need. */
206 rd
->dup_block
= duplicate_block (bb
, NULL
, NULL
);
208 /* Zero out the profile, since the block is unreachable for now. */
209 rd
->dup_block
->frequency
= 0;
210 rd
->dup_block
->count
= 0;
212 /* The call to duplicate_block will copy everything, including the
213 useless COND_EXPR or SWITCH_EXPR at the end of BB. We just remove
214 the useless COND_EXPR or SWITCH_EXPR here rather than having a
215 specialized block copier. We also remove all outgoing edges
216 from the duplicate block. The appropriate edge will be created
218 remove_ctrl_stmt_and_useless_edges (rd
->dup_block
, NULL
);
221 /* Hashing and equality routines for our hash table. */
223 redirection_data_hash (const void *p
)
225 edge e
= ((const struct redirection_data
*)p
)->outgoing_edge
;
226 return e
->dest
->index
;
230 redirection_data_eq (const void *p1
, const void *p2
)
232 edge e1
= ((const struct redirection_data
*)p1
)->outgoing_edge
;
233 edge e2
= ((const struct redirection_data
*)p2
)->outgoing_edge
;
238 /* Given an outgoing edge E lookup and return its entry in our hash table.
240 If INSERT is true, then we insert the entry into the hash table if
241 it is not already present. INCOMING_EDGE is added to the list of incoming
242 edges associated with E in the hash table. */
244 static struct redirection_data
*
245 lookup_redirection_data (edge e
, edge incoming_edge
, enum insert_option insert
)
248 struct redirection_data
*elt
;
250 /* Build a hash table element so we can see if E is already
252 elt
= XNEW (struct redirection_data
);
253 elt
->outgoing_edge
= e
;
254 elt
->dup_block
= NULL
;
255 elt
->do_not_duplicate
= false;
256 elt
->incoming_edges
= NULL
;
258 slot
= htab_find_slot (redirection_data
, elt
, insert
);
260 /* This will only happen if INSERT is false and the entry is not
261 in the hash table. */
268 /* This will only happen if E was not in the hash table and
273 elt
->incoming_edges
= XNEW (struct el
);
274 elt
->incoming_edges
->e
= incoming_edge
;
275 elt
->incoming_edges
->next
= NULL
;
278 /* E was in the hash table. */
281 /* Free ELT as we do not need it anymore, we will extract the
282 relevant entry from the hash table itself. */
285 /* Get the entry stored in the hash table. */
286 elt
= (struct redirection_data
*) *slot
;
288 /* If insertion was requested, then we need to add INCOMING_EDGE
289 to the list of incoming edges associated with E. */
292 struct el
*el
= XNEW (struct el
);
293 el
->next
= elt
->incoming_edges
;
294 el
->e
= incoming_edge
;
295 elt
->incoming_edges
= el
;
302 /* Given a duplicate block and its single destination (both stored
303 in RD). Create an edge between the duplicate and its single
306 Add an additional argument to any PHI nodes at the single
310 create_edge_and_update_destination_phis (struct redirection_data
*rd
)
312 edge e
= make_edge (rd
->dup_block
, rd
->outgoing_edge
->dest
, EDGE_FALLTHRU
);
315 rescan_loop_exit (e
, true, false);
316 e
->probability
= REG_BR_PROB_BASE
;
317 e
->count
= rd
->dup_block
->count
;
318 e
->aux
= rd
->outgoing_edge
->aux
;
320 /* If there are any PHI nodes at the destination of the outgoing edge
321 from the duplicate block, then we will need to add a new argument
322 to them. The argument should have the same value as the argument
323 associated with the outgoing edge stored in RD. */
324 for (phi
= phi_nodes (e
->dest
); phi
; phi
= PHI_CHAIN (phi
))
326 int indx
= rd
->outgoing_edge
->dest_idx
;
327 add_phi_arg (phi
, PHI_ARG_DEF (phi
, indx
), e
);
331 /* Hash table traversal callback routine to create duplicate blocks. */
334 create_duplicates (void **slot
, void *data
)
336 struct redirection_data
*rd
= (struct redirection_data
*) *slot
;
337 struct local_info
*local_info
= (struct local_info
*)data
;
339 /* If this entry should not have a duplicate created, then there's
341 if (rd
->do_not_duplicate
)
344 /* Create a template block if we have not done so already. Otherwise
345 use the template to create a new block. */
346 if (local_info
->template_block
== NULL
)
348 create_block_for_threading (local_info
->bb
, rd
);
349 local_info
->template_block
= rd
->dup_block
;
351 /* We do not create any outgoing edges for the template. We will
352 take care of that in a later traversal. That way we do not
353 create edges that are going to just be deleted. */
357 create_block_for_threading (local_info
->template_block
, rd
);
359 /* Go ahead and wire up outgoing edges and update PHIs for the duplicate
361 create_edge_and_update_destination_phis (rd
);
364 /* Keep walking the hash table. */
368 /* We did not create any outgoing edges for the template block during
369 block creation. This hash table traversal callback creates the
370 outgoing edge for the template block. */
373 fixup_template_block (void **slot
, void *data
)
375 struct redirection_data
*rd
= (struct redirection_data
*) *slot
;
376 struct local_info
*local_info
= (struct local_info
*)data
;
378 /* If this is the template block, then create its outgoing edges
379 and halt the hash table traversal. */
380 if (rd
->dup_block
&& rd
->dup_block
== local_info
->template_block
)
382 create_edge_and_update_destination_phis (rd
);
389 /* Hash table traversal callback to redirect each incoming edge
390 associated with this hash table element to its new destination. */
393 redirect_edges (void **slot
, void *data
)
395 struct redirection_data
*rd
= (struct redirection_data
*) *slot
;
396 struct local_info
*local_info
= (struct local_info
*)data
;
397 struct el
*next
, *el
;
399 /* Walk over all the incoming edges associated associated with this
401 for (el
= rd
->incoming_edges
; el
; el
= next
)
405 /* Go ahead and free this element from the list. Doing this now
406 avoids the need for another list walk when we destroy the hash
411 /* Go ahead and clear E->aux. It's not needed anymore and failure
412 to clear it will cause all kinds of unpleasant problems later. */
415 thread_stats
.num_threaded_edges
++;
421 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
422 fprintf (dump_file
, " Threaded jump %d --> %d to %d\n",
423 e
->src
->index
, e
->dest
->index
, rd
->dup_block
->index
);
425 rd
->dup_block
->count
+= e
->count
;
426 rd
->dup_block
->frequency
+= EDGE_FREQUENCY (e
);
427 EDGE_SUCC (rd
->dup_block
, 0)->count
+= e
->count
;
428 /* Redirect the incoming edge to the appropriate duplicate
430 e2
= redirect_edge_and_branch (e
, rd
->dup_block
);
431 gcc_assert (e
== e2
);
432 flush_pending_stmts (e2
);
436 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
437 fprintf (dump_file
, " Threaded jump %d --> %d to %d\n",
438 e
->src
->index
, e
->dest
->index
, local_info
->bb
->index
);
440 /* We are using BB as the duplicate. Remove the unnecessary
441 outgoing edges and statements from BB. */
442 remove_ctrl_stmt_and_useless_edges (local_info
->bb
,
443 rd
->outgoing_edge
->dest
);
445 /* Fixup the flags on the single remaining edge. */
446 single_succ_edge (local_info
->bb
)->flags
447 &= ~(EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
| EDGE_ABNORMAL
);
448 single_succ_edge (local_info
->bb
)->flags
|= EDGE_FALLTHRU
;
450 /* And adjust count and frequency on BB. */
451 local_info
->bb
->count
= e
->count
;
452 local_info
->bb
->frequency
= EDGE_FREQUENCY (e
);
456 /* Indicate that we actually threaded one or more jumps. */
457 if (rd
->incoming_edges
)
458 local_info
->jumps_threaded
= true;
463 /* Return true if this block has no executable statements other than
464 a simple ctrl flow instruction. When the number of outgoing edges
465 is one, this is equivalent to a "forwarder" block. */
468 redirection_block_p (basic_block bb
)
470 block_stmt_iterator bsi
;
472 /* Advance to the first executable statement. */
473 bsi
= bsi_start (bb
);
474 while (!bsi_end_p (bsi
)
475 && (TREE_CODE (bsi_stmt (bsi
)) == LABEL_EXPR
476 || IS_EMPTY_STMT (bsi_stmt (bsi
))))
479 /* Check if this is an empty block. */
483 /* Test that we've reached the terminating control statement. */
484 return bsi_stmt (bsi
)
485 && (TREE_CODE (bsi_stmt (bsi
)) == COND_EXPR
486 || TREE_CODE (bsi_stmt (bsi
)) == GOTO_EXPR
487 || TREE_CODE (bsi_stmt (bsi
)) == SWITCH_EXPR
);
490 /* BB is a block which ends with a COND_EXPR or SWITCH_EXPR and when BB
491 is reached via one or more specific incoming edges, we know which
492 outgoing edge from BB will be traversed.
494 We want to redirect those incoming edges to the target of the
495 appropriate outgoing edge. Doing so avoids a conditional branch
496 and may expose new optimization opportunities. Note that we have
497 to update dominator tree and SSA graph after such changes.
499 The key to keeping the SSA graph update manageable is to duplicate
500 the side effects occurring in BB so that those side effects still
501 occur on the paths which bypass BB after redirecting edges.
503 We accomplish this by creating duplicates of BB and arranging for
504 the duplicates to unconditionally pass control to one specific
505 successor of BB. We then revector the incoming edges into BB to
506 the appropriate duplicate of BB.
508 If NOLOOP_ONLY is true, we only perform the threading as long as it
509 does not affect the structure of the loops in a nontrivial way. */
512 thread_block (basic_block bb
, bool noloop_only
)
514 /* E is an incoming edge into BB that we may or may not want to
515 redirect to a duplicate of BB. */
518 struct local_info local_info
;
519 struct loop
*loop
= bb
->loop_father
;
521 /* ALL indicates whether or not all incoming edges into BB should
522 be threaded to a duplicate of BB. */
525 /* To avoid scanning a linear array for the element we need we instead
526 use a hash table. For normal code there should be no noticeable
527 difference. However, if we have a block with a large number of
528 incoming and outgoing edges such linear searches can get expensive. */
529 redirection_data
= htab_create (EDGE_COUNT (bb
->succs
),
530 redirection_data_hash
,
534 /* If we thread the latch of the loop to its exit, the loop ceases to
535 exist. Make sure we do not restrict ourselves in order to preserve
537 if (loop
->header
== bb
)
539 e
= loop_latch_edge (loop
);
542 if (e2
&& loop_exit_edge_p (loop
, e2
))
549 /* Record each unique threaded destination into a hash table for
550 efficient lookups. */
551 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
556 /* If NOLOOP_ONLY is true, we only allow threading through the
557 header of a loop to exit edges. */
559 && bb
== bb
->loop_father
->header
560 && !loop_exit_edge_p (bb
->loop_father
, e2
)))
566 update_bb_profile_for_threading (e
->dest
, EDGE_FREQUENCY (e
),
567 e
->count
, (edge
) e
->aux
);
569 /* Insert the outgoing edge into the hash table if it is not
570 already in the hash table. */
571 lookup_redirection_data (e2
, e
, INSERT
);
574 /* If we are going to thread all incoming edges to an outgoing edge, then
575 BB will become unreachable. Rather than just throwing it away, use
576 it for one of the duplicates. Mark the first incoming edge with the
577 DO_NOT_DUPLICATE attribute. */
580 edge e
= (edge
) EDGE_PRED (bb
, 0)->aux
;
581 lookup_redirection_data (e
, NULL
, NO_INSERT
)->do_not_duplicate
= true;
584 /* We do not update dominance info. */
585 free_dominance_info (CDI_DOMINATORS
);
587 /* Now create duplicates of BB.
589 Note that for a block with a high outgoing degree we can waste
590 a lot of time and memory creating and destroying useless edges.
592 So we first duplicate BB and remove the control structure at the
593 tail of the duplicate as well as all outgoing edges from the
594 duplicate. We then use that duplicate block as a template for
595 the rest of the duplicates. */
596 local_info
.template_block
= NULL
;
598 local_info
.jumps_threaded
= false;
599 htab_traverse (redirection_data
, create_duplicates
, &local_info
);
601 /* The template does not have an outgoing edge. Create that outgoing
602 edge and update PHI nodes as the edge's target as necessary.
604 We do this after creating all the duplicates to avoid creating
605 unnecessary edges. */
606 htab_traverse (redirection_data
, fixup_template_block
, &local_info
);
608 /* The hash table traversals above created the duplicate blocks (and the
609 statements within the duplicate blocks). This loop creates PHI nodes for
610 the duplicated blocks and redirects the incoming edges into BB to reach
611 the duplicates of BB. */
612 htab_traverse (redirection_data
, redirect_edges
, &local_info
);
614 /* Done with this block. Clear REDIRECTION_DATA. */
615 htab_delete (redirection_data
);
616 redirection_data
= NULL
;
618 /* Indicate to our caller whether or not any jumps were threaded. */
619 return local_info
.jumps_threaded
;
622 /* Threads edge E through E->dest to the edge E->aux. Returns the copy
623 of E->dest created during threading, or E->dest if it was not necessary
624 to copy it (E is its single predecessor). */
627 thread_single_edge (edge e
)
629 basic_block bb
= e
->dest
;
630 edge eto
= (edge
) e
->aux
;
631 struct redirection_data rd
;
632 struct local_info local_info
;
636 thread_stats
.num_threaded_edges
++;
638 if (single_pred_p (bb
))
640 /* If BB has just a single predecessor, we should only remove the
641 control statements at its end, and successors except for ETO. */
642 remove_ctrl_stmt_and_useless_edges (bb
, eto
->dest
);
644 /* And fixup the flags on the single remaining edge. */
645 eto
->flags
&= ~(EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
| EDGE_ABNORMAL
);
646 eto
->flags
|= EDGE_FALLTHRU
;
651 /* Otherwise, we need to create a copy. */
652 update_bb_profile_for_threading (bb
, EDGE_FREQUENCY (e
), e
->count
, eto
);
655 rd
.outgoing_edge
= eto
;
657 create_block_for_threading (bb
, &rd
);
658 create_edge_and_update_destination_phis (&rd
);
660 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
661 fprintf (dump_file
, " Threaded jump %d --> %d to %d\n",
662 e
->src
->index
, e
->dest
->index
, rd
.dup_block
->index
);
664 rd
.dup_block
->count
= e
->count
;
665 rd
.dup_block
->frequency
= EDGE_FREQUENCY (e
);
666 single_succ_edge (rd
.dup_block
)->count
= e
->count
;
667 redirect_edge_and_branch (e
, rd
.dup_block
);
668 flush_pending_stmts (e
);
673 /* Callback for dfs_enumerate_from. Returns true if BB is different
674 from STOP and DBDS_CE_STOP. */
676 static basic_block dbds_ce_stop
;
678 dbds_continue_enumeration_p (const_basic_block bb
, const void *stop
)
680 return (bb
!= (const_basic_block
) stop
681 && bb
!= dbds_ce_stop
);
684 /* Evaluates the dominance relationship of latch of the LOOP and BB, and
685 returns the state. */
689 /* BB does not dominate latch of the LOOP. */
691 /* The LOOP is broken (there is no path from the header to its latch. */
693 /* BB dominates the latch of the LOOP. */
697 static enum bb_dom_status
698 determine_bb_domination_status (struct loop
*loop
, basic_block bb
)
700 basic_block
*bblocks
;
702 bool bb_reachable
= false;
706 #ifdef ENABLE_CHECKING
707 /* This function assumes BB is a successor of LOOP->header. */
711 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
713 if (e
->src
== loop
->header
)
724 if (bb
== loop
->latch
)
725 return DOMST_DOMINATING
;
727 /* Check that BB dominates LOOP->latch, and that it is back-reachable
730 bblocks
= XCNEWVEC (basic_block
, loop
->num_nodes
);
731 dbds_ce_stop
= loop
->header
;
732 nblocks
= dfs_enumerate_from (loop
->latch
, 1, dbds_continue_enumeration_p
,
733 bblocks
, loop
->num_nodes
, bb
);
734 for (i
= 0; i
< nblocks
; i
++)
735 FOR_EACH_EDGE (e
, ei
, bblocks
[i
]->preds
)
737 if (e
->src
== loop
->header
)
740 return DOMST_NONDOMINATING
;
747 return (bb_reachable
? DOMST_DOMINATING
: DOMST_LOOP_BROKEN
);
750 /* Thread jumps through the header of LOOP. Returns true if cfg changes.
751 If MAY_PEEL_LOOP_HEADERS is false, we avoid threading from entry edges
752 to the inside of the loop. */
755 thread_through_loop_header (struct loop
*loop
, bool may_peel_loop_headers
)
757 basic_block header
= loop
->header
;
758 edge e
, tgt_edge
, latch
= loop_latch_edge (loop
);
760 basic_block tgt_bb
, atgt_bb
;
761 enum bb_dom_status domst
;
763 /* We have already threaded through headers to exits, so all the threading
764 requests now are to the inside of the loop. We need to avoid creating
765 irreducible regions (i.e., loops with more than one entry block), and
766 also loop with several latch edges, or new subloops of the loop (although
767 there are cases where it might be appropriate, it is difficult to decide,
768 and doing it wrongly may confuse other optimizers).
770 We could handle more general cases here. However, the intention is to
771 preserve some information about the loop, which is impossible if its
772 structure changes significantly, in a way that is not well understood.
773 Thus we only handle few important special cases, in which also updating
774 of the loop-carried information should be feasible:
776 1) Propagation of latch edge to a block that dominates the latch block
777 of a loop. This aims to handle the following idiom:
788 After threading the latch edge, this becomes
799 The original header of the loop is moved out of it, and we may thread
800 the remaining edges through it without further constraints.
802 2) All entry edges are propagated to a single basic block that dominates
803 the latch block of the loop. This aims to handle the following idiom
804 (normally created for "for" loops):
827 /* Threading through the header won't improve the code if the header has just
829 if (single_succ_p (header
))
834 tgt_edge
= (edge
) latch
->aux
;
835 tgt_bb
= tgt_edge
->dest
;
837 else if (!may_peel_loop_headers
838 && !redirection_block_p (loop
->header
))
844 FOR_EACH_EDGE (e
, ei
, header
->preds
)
851 /* If latch is not threaded, and there is a header
852 edge that is not threaded, we would create loop
853 with multiple entries. */
857 tgt_edge
= (edge
) e
->aux
;
858 atgt_bb
= tgt_edge
->dest
;
861 /* Two targets of threading would make us create loop
862 with multiple entries. */
863 else if (tgt_bb
!= atgt_bb
)
869 /* There are no threading requests. */
873 /* Redirecting to empty loop latch is useless. */
874 if (tgt_bb
== loop
->latch
875 && empty_block_p (loop
->latch
))
879 /* The target block must dominate the loop latch, otherwise we would be
880 creating a subloop. */
881 domst
= determine_bb_domination_status (loop
, tgt_bb
);
882 if (domst
== DOMST_NONDOMINATING
)
884 if (domst
== DOMST_LOOP_BROKEN
)
886 /* If the loop ceased to exist, mark it as such, and thread through its
890 return thread_block (header
, false);
893 if (tgt_bb
->loop_father
->header
== tgt_bb
)
895 /* If the target of the threading is a header of a subloop, we need
896 to create a preheader for it, so that the headers of the two loops
898 if (EDGE_COUNT (tgt_bb
->preds
) > 2)
900 tgt_bb
= create_preheader (tgt_bb
->loop_father
, 0);
901 gcc_assert (tgt_bb
!= NULL
);
904 tgt_bb
= split_edge (tgt_edge
);
909 /* First handle the case latch edge is redirected. */
910 loop
->latch
= thread_single_edge (latch
);
911 gcc_assert (single_succ (loop
->latch
) == tgt_bb
);
912 loop
->header
= tgt_bb
;
914 /* Thread the remaining edges through the former header. */
915 thread_block (header
, false);
919 basic_block new_preheader
;
921 /* Now consider the case entry edges are redirected to the new entry
922 block. Remember one entry edge, so that we can find the new
923 preheader (its destination after threading). */
924 FOR_EACH_EDGE (e
, ei
, header
->preds
)
930 /* The duplicate of the header is the new preheader of the loop. Ensure
931 that it is placed correctly in the loop hierarchy. */
932 set_loop_copy (loop
, loop_outer (loop
));
934 thread_block (header
, false);
935 set_loop_copy (loop
, NULL
);
936 new_preheader
= e
->dest
;
938 /* Create the new latch block. This is always necessary, as the latch
939 must have only a single successor, but the original header had at
940 least two successors. */
942 mfb_kj_edge
= single_succ_edge (new_preheader
);
943 loop
->header
= mfb_kj_edge
->dest
;
944 latch
= make_forwarder_block (tgt_bb
, mfb_keep_just
, NULL
);
945 loop
->header
= latch
->dest
;
946 loop
->latch
= latch
->src
;
952 /* We failed to thread anything. Cancel the requests. */
953 FOR_EACH_EDGE (e
, ei
, header
->preds
)
960 /* Walk through the registered jump threads and convert them into a
961 form convenient for this pass.
963 Any block which has incoming edges threaded to outgoing edges
964 will have its entry in THREADED_BLOCK set.
966 Any threaded edge will have its new outgoing edge stored in the
967 original edge's AUX field.
969 This form avoids the need to walk all the edges in the CFG to
970 discover blocks which need processing and avoids unnecessary
971 hash table lookups to map from threaded edge to new target. */
974 mark_threaded_blocks (bitmap threaded_blocks
)
978 bitmap tmp
= BITMAP_ALLOC (NULL
);
983 for (i
= 0; i
< VEC_length (edge
, threaded_edges
); i
+= 2)
985 edge e
= VEC_index (edge
, threaded_edges
, i
);
986 edge e2
= VEC_index (edge
, threaded_edges
, i
+ 1);
989 bitmap_set_bit (tmp
, e
->dest
->index
);
992 /* If optimizing for size, only thread through block if we don't have
993 to duplicate it or it's an otherwise empty redirection block. */
996 EXECUTE_IF_SET_IN_BITMAP (tmp
, 0, i
, bi
)
998 bb
= BASIC_BLOCK (i
);
999 if (EDGE_COUNT (bb
->preds
) > 1
1000 && !redirection_block_p (bb
))
1002 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1006 bitmap_set_bit (threaded_blocks
, i
);
1010 bitmap_copy (threaded_blocks
, tmp
);
1016 /* Walk through all blocks and thread incoming edges to the appropriate
1017 outgoing edge for each edge pair recorded in THREADED_EDGES.
1019 It is the caller's responsibility to fix the dominance information
1020 and rewrite duplicated SSA_NAMEs back into SSA form.
1022 If MAY_PEEL_LOOP_HEADERS is false, we avoid threading edges through
1023 loop headers if it does not simplify the loop.
1025 Returns true if one or more edges were threaded, false otherwise. */
1028 thread_through_all_blocks (bool may_peel_loop_headers
)
1030 bool retval
= false;
1033 bitmap threaded_blocks
;
1037 /* We must know about loops in order to preserve them. */
1038 gcc_assert (current_loops
!= NULL
);
1040 if (threaded_edges
== NULL
)
1043 threaded_blocks
= BITMAP_ALLOC (NULL
);
1044 memset (&thread_stats
, 0, sizeof (thread_stats
));
1046 mark_threaded_blocks (threaded_blocks
);
1048 initialize_original_copy_tables ();
1050 /* First perform the threading requests that do not affect
1052 EXECUTE_IF_SET_IN_BITMAP (threaded_blocks
, 0, i
, bi
)
1054 basic_block bb
= BASIC_BLOCK (i
);
1056 if (EDGE_COUNT (bb
->preds
) > 0)
1057 retval
|= thread_block (bb
, true);
1060 /* Then perform the threading through loop headers. We start with the
1061 innermost loop, so that the changes in cfg we perform won't affect
1062 further threading. */
1063 FOR_EACH_LOOP (li
, loop
, LI_FROM_INNERMOST
)
1066 || !bitmap_bit_p (threaded_blocks
, loop
->header
->index
))
1069 retval
|= thread_through_loop_header (loop
, may_peel_loop_headers
);
1072 if (dump_file
&& (dump_flags
& TDF_STATS
))
1073 fprintf (dump_file
, "\nJumps threaded: %lu\n",
1074 thread_stats
.num_threaded_edges
);
1076 free_original_copy_tables ();
1078 BITMAP_FREE (threaded_blocks
);
1079 threaded_blocks
= NULL
;
1080 VEC_free (edge
, heap
, threaded_edges
);
1081 threaded_edges
= NULL
;
1084 loops_state_set (LOOPS_NEED_FIXUP
);
1089 /* Register a jump threading opportunity. We queue up all the jump
1090 threading opportunities discovered by a pass and update the CFG
1091 and SSA form all at once.
1093 E is the edge we can thread, E2 is the new target edge. ie, we
1094 are effectively recording that E->dest can be changed to E2->dest
1095 after fixing the SSA graph. */
1098 register_jump_thread (edge e
, edge e2
)
1100 if (threaded_edges
== NULL
)
1101 threaded_edges
= VEC_alloc (edge
, heap
, 10);
1103 VEC_safe_push (edge
, heap
, threaded_edges
, e
);
1104 VEC_safe_push (edge
, heap
, threaded_edges
, e2
);