1 /* Thread edges through blocks and update the control flow and SSA graphs.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation,
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "basic-block.h"
34 #include "diagnostic.h"
35 #include "tree-flow.h"
36 #include "tree-dump.h"
37 #include "tree-pass.h"
40 /* Given a block B, update the CFG and SSA graph to reflect redirecting
41 one or more in-edges to B to instead reach the destination of an
42 out-edge from B while preserving any side effects in B.
44 i.e., given A->B and B->C, change A->B to be A->C yet still preserve the
45 side effects of executing B.
47 1. Make a copy of B (including its outgoing edges and statements). Call
48 the copy B'. Note B' has no incoming edges or PHIs at this time.
50 2. Remove the control statement at the end of B' and all outgoing edges
53 3. Add a new argument to each PHI in C with the same value as the existing
54 argument associated with edge B->C. Associate the new PHI arguments
57 4. For each PHI in B, find or create a PHI in B' with an identical
58 PHI_RESULT. Add an argument to the PHI in B' which has the same
59 value as the PHI in B associated with the edge A->B. Associate
60 the new argument in the PHI in B' with the edge A->B.
62 5. Change the edge A->B to A->B'.
64 5a. This automatically deletes any PHI arguments associated with the
67 5b. This automatically associates each new argument added in step 4
70 6. Repeat for other incoming edges into B.
72 7. Put the duplicated resources in B and all the B' blocks into SSA form.
74 Note that block duplication can be minimized by first collecting the
75 set of unique destination blocks that the incoming edges should
76 be threaded to. Block duplication can be further minimized by using
77 B instead of creating B' for one destination if all edges into B are
78 going to be threaded to a successor of B.
80 We further reduce the number of edges and statements we create by
81 not copying all the outgoing edges and the control statement in
82 step #1. We instead create a template block without the outgoing
83 edges and duplicate the template. */
86 /* Steps #5 and #6 of the above algorithm are best implemented by walking
87 all the incoming edges which thread to the same destination edge at
88 the same time. That avoids lots of table lookups to get information
89 for the destination edge.
91 To realize that implementation we create a list of incoming edges
92 which thread to the same outgoing edge. Thus to implement steps
93 #5 and #6 we traverse our hash table of outgoing edge information.
94 For each entry we walk the list of incoming edges which thread to
95 the current outgoing edge. */
103 /* Main data structure recording information regarding B's duplicate
106 /* We need to efficiently record the unique thread destinations of this
107 block and specific information associated with those destinations. We
108 may have many incoming edges threaded to the same outgoing edge. This
109 can be naturally implemented with a hash table. */
111 struct redirection_data
113 /* A duplicate of B with the trailing control statement removed and which
114 targets a single successor of B. */
115 basic_block dup_block;
117 /* An outgoing edge from B. DUP_BLOCK will have OUTGOING_EDGE->dest as
118 its single successor. */
121 /* A list of incoming edges which we want to thread to
122 OUTGOING_EDGE->dest. */
123 struct el *incoming_edges;
125 /* Flag indicating whether or not we should create a duplicate block
126 for this thread destination. This is only true if we are threading
127 all incoming edges and thus are using BB itself as a duplicate block. */
128 bool do_not_duplicate;
131 /* Main data structure to hold information for duplicates of BB. */
132 static htab_t redirection_data;
134 /* Data structure of information to pass to hash table traversal routines. */
137 /* The current block we are working on. */
140 /* A template copy of BB with no outgoing edges or control statement that
141 we use for creating copies. */
142 basic_block template_block;
144 /* TRUE if we thread one or more jumps, FALSE otherwise. */
148 /* Passes which use the jump threading code register jump threading
149 opportunities as they are discovered. We keep the registered
150 jump threading opportunities in this vector as edge pairs
151 (original_edge, target_edge). */
152 static VEC(edge,heap) *threaded_edges;
155 /* Jump threading statistics. */
157 struct thread_stats_d
159 unsigned long num_threaded_edges;
162 struct thread_stats_d thread_stats;
165 /* Remove the last statement in block BB if it is a control statement
166 Also remove all outgoing edges except the edge which reaches DEST_BB.
167 If DEST_BB is NULL, then remove all outgoing edges. */
170 remove_ctrl_stmt_and_useless_edges (basic_block bb, basic_block dest_bb)
172 gimple_stmt_iterator gsi;
176 gsi = gsi_last_bb (bb);
178 /* If the duplicate ends with a control statement, then remove it.
180 Note that if we are duplicating the template block rather than the
181 original basic block, then the duplicate might not have any real
185 && (gimple_code (gsi_stmt (gsi)) == GIMPLE_COND
186 || gimple_code (gsi_stmt (gsi)) == GIMPLE_GOTO
187 || gimple_code (gsi_stmt (gsi)) == GIMPLE_SWITCH))
188 gsi_remove (&gsi, true);
190 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
192 if (e->dest != dest_bb)
199 /* Create a duplicate of BB which only reaches the destination of the edge
200 stored in RD. Record the duplicate block in RD. */
203 create_block_for_threading (basic_block bb, struct redirection_data *rd)
205 /* We can use the generic block duplication code and simply remove
206 the stuff we do not need. */
207 rd->dup_block = duplicate_block (bb, NULL, NULL);
209 /* Zero out the profile, since the block is unreachable for now. */
210 rd->dup_block->frequency = 0;
211 rd->dup_block->count = 0;
213 /* The call to duplicate_block will copy everything, including the
214 useless COND_EXPR or SWITCH_EXPR at the end of BB. We just remove
215 the useless COND_EXPR or SWITCH_EXPR here rather than having a
216 specialized block copier. We also remove all outgoing edges
217 from the duplicate block. The appropriate edge will be created
219 remove_ctrl_stmt_and_useless_edges (rd->dup_block, NULL);
222 /* Hashing and equality routines for our hash table. */
224 redirection_data_hash (const void *p)
226 edge e = ((const struct redirection_data *)p)->outgoing_edge;
227 return e->dest->index;
231 redirection_data_eq (const void *p1, const void *p2)
233 edge e1 = ((const struct redirection_data *)p1)->outgoing_edge;
234 edge e2 = ((const struct redirection_data *)p2)->outgoing_edge;
239 /* Given an outgoing edge E lookup and return its entry in our hash table.
241 If INSERT is true, then we insert the entry into the hash table if
242 it is not already present. INCOMING_EDGE is added to the list of incoming
243 edges associated with E in the hash table. */
245 static struct redirection_data *
246 lookup_redirection_data (edge e, edge incoming_edge, enum insert_option insert)
249 struct redirection_data *elt;
251 /* Build a hash table element so we can see if E is already
253 elt = XNEW (struct redirection_data);
254 elt->outgoing_edge = e;
255 elt->dup_block = NULL;
256 elt->do_not_duplicate = false;
257 elt->incoming_edges = NULL;
259 slot = htab_find_slot (redirection_data, elt, insert);
261 /* This will only happen if INSERT is false and the entry is not
262 in the hash table. */
269 /* This will only happen if E was not in the hash table and
274 elt->incoming_edges = XNEW (struct el);
275 elt->incoming_edges->e = incoming_edge;
276 elt->incoming_edges->next = NULL;
279 /* E was in the hash table. */
282 /* Free ELT as we do not need it anymore, we will extract the
283 relevant entry from the hash table itself. */
286 /* Get the entry stored in the hash table. */
287 elt = (struct redirection_data *) *slot;
289 /* If insertion was requested, then we need to add INCOMING_EDGE
290 to the list of incoming edges associated with E. */
293 struct el *el = XNEW (struct el);
294 el->next = elt->incoming_edges;
295 el->e = incoming_edge;
296 elt->incoming_edges = el;
303 /* Given a duplicate block and its single destination (both stored
304 in RD). Create an edge between the duplicate and its single
307 Add an additional argument to any PHI nodes at the single
311 create_edge_and_update_destination_phis (struct redirection_data *rd)
313 edge e = make_edge (rd->dup_block, rd->outgoing_edge->dest, EDGE_FALLTHRU);
314 gimple_stmt_iterator gsi;
316 rescan_loop_exit (e, true, false);
317 e->probability = REG_BR_PROB_BASE;
318 e->count = rd->dup_block->count;
319 e->aux = rd->outgoing_edge->aux;
321 /* If there are any PHI nodes at the destination of the outgoing edge
322 from the duplicate block, then we will need to add a new argument
323 to them. The argument should have the same value as the argument
324 associated with the outgoing edge stored in RD. */
325 for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
327 gimple phi = gsi_stmt (gsi);
328 source_location locus;
329 int indx = rd->outgoing_edge->dest_idx;
331 locus = gimple_phi_arg_location (phi, indx);
332 add_phi_arg (phi, gimple_phi_arg_def (phi, indx), e, locus);
336 /* Hash table traversal callback routine to create duplicate blocks. */
339 create_duplicates (void **slot, void *data)
341 struct redirection_data *rd = (struct redirection_data *) *slot;
342 struct local_info *local_info = (struct local_info *)data;
344 /* If this entry should not have a duplicate created, then there's
346 if (rd->do_not_duplicate)
349 /* Create a template block if we have not done so already. Otherwise
350 use the template to create a new block. */
351 if (local_info->template_block == NULL)
353 create_block_for_threading (local_info->bb, rd);
354 local_info->template_block = rd->dup_block;
356 /* We do not create any outgoing edges for the template. We will
357 take care of that in a later traversal. That way we do not
358 create edges that are going to just be deleted. */
362 create_block_for_threading (local_info->template_block, rd);
364 /* Go ahead and wire up outgoing edges and update PHIs for the duplicate
366 create_edge_and_update_destination_phis (rd);
369 /* Keep walking the hash table. */
373 /* We did not create any outgoing edges for the template block during
374 block creation. This hash table traversal callback creates the
375 outgoing edge for the template block. */
378 fixup_template_block (void **slot, void *data)
380 struct redirection_data *rd = (struct redirection_data *) *slot;
381 struct local_info *local_info = (struct local_info *)data;
383 /* If this is the template block, then create its outgoing edges
384 and halt the hash table traversal. */
385 if (rd->dup_block && rd->dup_block == local_info->template_block)
387 create_edge_and_update_destination_phis (rd);
394 /* Hash table traversal callback to redirect each incoming edge
395 associated with this hash table element to its new destination. */
398 redirect_edges (void **slot, void *data)
400 struct redirection_data *rd = (struct redirection_data *) *slot;
401 struct local_info *local_info = (struct local_info *)data;
402 struct el *next, *el;
404 /* Walk over all the incoming edges associated associated with this
406 for (el = rd->incoming_edges; el; el = next)
410 /* Go ahead and free this element from the list. Doing this now
411 avoids the need for another list walk when we destroy the hash
416 /* Go ahead and clear E->aux. It's not needed anymore and failure
417 to clear it will cause all kinds of unpleasant problems later. */
420 thread_stats.num_threaded_edges++;
426 if (dump_file && (dump_flags & TDF_DETAILS))
427 fprintf (dump_file, " Threaded jump %d --> %d to %d\n",
428 e->src->index, e->dest->index, rd->dup_block->index);
430 rd->dup_block->count += e->count;
431 rd->dup_block->frequency += EDGE_FREQUENCY (e);
432 EDGE_SUCC (rd->dup_block, 0)->count += e->count;
433 /* Redirect the incoming edge to the appropriate duplicate
435 e2 = redirect_edge_and_branch (e, rd->dup_block);
436 gcc_assert (e == e2);
437 flush_pending_stmts (e2);
441 if (dump_file && (dump_flags & TDF_DETAILS))
442 fprintf (dump_file, " Threaded jump %d --> %d to %d\n",
443 e->src->index, e->dest->index, local_info->bb->index);
445 /* We are using BB as the duplicate. Remove the unnecessary
446 outgoing edges and statements from BB. */
447 remove_ctrl_stmt_and_useless_edges (local_info->bb,
448 rd->outgoing_edge->dest);
450 /* Fixup the flags on the single remaining edge. */
451 single_succ_edge (local_info->bb)->flags
452 &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE | EDGE_ABNORMAL);
453 single_succ_edge (local_info->bb)->flags |= EDGE_FALLTHRU;
455 /* And adjust count and frequency on BB. */
456 local_info->bb->count = e->count;
457 local_info->bb->frequency = EDGE_FREQUENCY (e);
461 /* Indicate that we actually threaded one or more jumps. */
462 if (rd->incoming_edges)
463 local_info->jumps_threaded = true;
468 /* Return true if this block has no executable statements other than
469 a simple ctrl flow instruction. When the number of outgoing edges
470 is one, this is equivalent to a "forwarder" block. */
473 redirection_block_p (basic_block bb)
475 gimple_stmt_iterator gsi;
477 /* Advance to the first executable statement. */
478 gsi = gsi_start_bb (bb);
479 while (!gsi_end_p (gsi)
480 && (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL
481 || gimple_nop_p (gsi_stmt (gsi))))
484 /* Check if this is an empty block. */
488 /* Test that we've reached the terminating control statement. */
489 return gsi_stmt (gsi)
490 && (gimple_code (gsi_stmt (gsi)) == GIMPLE_COND
491 || gimple_code (gsi_stmt (gsi)) == GIMPLE_GOTO
492 || gimple_code (gsi_stmt (gsi)) == GIMPLE_SWITCH);
495 /* BB is a block which ends with a COND_EXPR or SWITCH_EXPR and when BB
496 is reached via one or more specific incoming edges, we know which
497 outgoing edge from BB will be traversed.
499 We want to redirect those incoming edges to the target of the
500 appropriate outgoing edge. Doing so avoids a conditional branch
501 and may expose new optimization opportunities. Note that we have
502 to update dominator tree and SSA graph after such changes.
504 The key to keeping the SSA graph update manageable is to duplicate
505 the side effects occurring in BB so that those side effects still
506 occur on the paths which bypass BB after redirecting edges.
508 We accomplish this by creating duplicates of BB and arranging for
509 the duplicates to unconditionally pass control to one specific
510 successor of BB. We then revector the incoming edges into BB to
511 the appropriate duplicate of BB.
513 If NOLOOP_ONLY is true, we only perform the threading as long as it
514 does not affect the structure of the loops in a nontrivial way. */
517 thread_block (basic_block bb, bool noloop_only)
519 /* E is an incoming edge into BB that we may or may not want to
520 redirect to a duplicate of BB. */
523 struct local_info local_info;
524 struct loop *loop = bb->loop_father;
526 /* ALL indicates whether or not all incoming edges into BB should
527 be threaded to a duplicate of BB. */
530 /* To avoid scanning a linear array for the element we need we instead
531 use a hash table. For normal code there should be no noticeable
532 difference. However, if we have a block with a large number of
533 incoming and outgoing edges such linear searches can get expensive. */
534 redirection_data = htab_create (EDGE_COUNT (bb->succs),
535 redirection_data_hash,
539 /* If we thread the latch of the loop to its exit, the loop ceases to
540 exist. Make sure we do not restrict ourselves in order to preserve
542 if (loop->header == bb)
544 e = loop_latch_edge (loop);
547 if (e2 && loop_exit_edge_p (loop, e2))
554 /* Record each unique threaded destination into a hash table for
555 efficient lookups. */
556 FOR_EACH_EDGE (e, ei, bb->preds)
561 /* If NOLOOP_ONLY is true, we only allow threading through the
562 header of a loop to exit edges. */
564 && bb == bb->loop_father->header
565 && !loop_exit_edge_p (bb->loop_father, e2)))
571 update_bb_profile_for_threading (e->dest, EDGE_FREQUENCY (e),
572 e->count, (edge) e->aux);
574 /* Insert the outgoing edge into the hash table if it is not
575 already in the hash table. */
576 lookup_redirection_data (e2, e, INSERT);
579 /* If we are going to thread all incoming edges to an outgoing edge, then
580 BB will become unreachable. Rather than just throwing it away, use
581 it for one of the duplicates. Mark the first incoming edge with the
582 DO_NOT_DUPLICATE attribute. */
585 edge e = (edge) EDGE_PRED (bb, 0)->aux;
586 lookup_redirection_data (e, NULL, NO_INSERT)->do_not_duplicate = true;
589 /* We do not update dominance info. */
590 free_dominance_info (CDI_DOMINATORS);
592 /* Now create duplicates of BB.
594 Note that for a block with a high outgoing degree we can waste
595 a lot of time and memory creating and destroying useless edges.
597 So we first duplicate BB and remove the control structure at the
598 tail of the duplicate as well as all outgoing edges from the
599 duplicate. We then use that duplicate block as a template for
600 the rest of the duplicates. */
601 local_info.template_block = NULL;
603 local_info.jumps_threaded = false;
604 htab_traverse (redirection_data, create_duplicates, &local_info);
606 /* The template does not have an outgoing edge. Create that outgoing
607 edge and update PHI nodes as the edge's target as necessary.
609 We do this after creating all the duplicates to avoid creating
610 unnecessary edges. */
611 htab_traverse (redirection_data, fixup_template_block, &local_info);
613 /* The hash table traversals above created the duplicate blocks (and the
614 statements within the duplicate blocks). This loop creates PHI nodes for
615 the duplicated blocks and redirects the incoming edges into BB to reach
616 the duplicates of BB. */
617 htab_traverse (redirection_data, redirect_edges, &local_info);
619 /* Done with this block. Clear REDIRECTION_DATA. */
620 htab_delete (redirection_data);
621 redirection_data = NULL;
623 /* Indicate to our caller whether or not any jumps were threaded. */
624 return local_info.jumps_threaded;
627 /* Threads edge E through E->dest to the edge E->aux. Returns the copy
628 of E->dest created during threading, or E->dest if it was not necessary
629 to copy it (E is its single predecessor). */
632 thread_single_edge (edge e)
634 basic_block bb = e->dest;
635 edge eto = (edge) e->aux;
636 struct redirection_data rd;
637 struct local_info local_info;
641 thread_stats.num_threaded_edges++;
643 if (single_pred_p (bb))
645 /* If BB has just a single predecessor, we should only remove the
646 control statements at its end, and successors except for ETO. */
647 remove_ctrl_stmt_and_useless_edges (bb, eto->dest);
649 /* And fixup the flags on the single remaining edge. */
650 eto->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE | EDGE_ABNORMAL);
651 eto->flags |= EDGE_FALLTHRU;
656 /* Otherwise, we need to create a copy. */
657 update_bb_profile_for_threading (bb, EDGE_FREQUENCY (e), e->count, eto);
660 rd.outgoing_edge = eto;
662 create_block_for_threading (bb, &rd);
663 create_edge_and_update_destination_phis (&rd);
665 if (dump_file && (dump_flags & TDF_DETAILS))
666 fprintf (dump_file, " Threaded jump %d --> %d to %d\n",
667 e->src->index, e->dest->index, rd.dup_block->index);
669 rd.dup_block->count = e->count;
670 rd.dup_block->frequency = EDGE_FREQUENCY (e);
671 single_succ_edge (rd.dup_block)->count = e->count;
672 redirect_edge_and_branch (e, rd.dup_block);
673 flush_pending_stmts (e);
678 /* Callback for dfs_enumerate_from. Returns true if BB is different
679 from STOP and DBDS_CE_STOP. */
681 static basic_block dbds_ce_stop;
683 dbds_continue_enumeration_p (const_basic_block bb, const void *stop)
685 return (bb != (const_basic_block) stop
686 && bb != dbds_ce_stop);
689 /* Evaluates the dominance relationship of latch of the LOOP and BB, and
690 returns the state. */
694 /* BB does not dominate latch of the LOOP. */
696 /* The LOOP is broken (there is no path from the header to its latch. */
698 /* BB dominates the latch of the LOOP. */
702 static enum bb_dom_status
703 determine_bb_domination_status (struct loop *loop, basic_block bb)
705 basic_block *bblocks;
707 bool bb_reachable = false;
711 #ifdef ENABLE_CHECKING
712 /* This function assumes BB is a successor of LOOP->header. */
716 FOR_EACH_EDGE (e, ei, bb->preds)
718 if (e->src == loop->header)
729 if (bb == loop->latch)
730 return DOMST_DOMINATING;
732 /* Check that BB dominates LOOP->latch, and that it is back-reachable
735 bblocks = XCNEWVEC (basic_block, loop->num_nodes);
736 dbds_ce_stop = loop->header;
737 nblocks = dfs_enumerate_from (loop->latch, 1, dbds_continue_enumeration_p,
738 bblocks, loop->num_nodes, bb);
739 for (i = 0; i < nblocks; i++)
740 FOR_EACH_EDGE (e, ei, bblocks[i]->preds)
742 if (e->src == loop->header)
745 return DOMST_NONDOMINATING;
752 return (bb_reachable ? DOMST_DOMINATING : DOMST_LOOP_BROKEN);
755 /* Thread jumps through the header of LOOP. Returns true if cfg changes.
756 If MAY_PEEL_LOOP_HEADERS is false, we avoid threading from entry edges
757 to the inside of the loop. */
760 thread_through_loop_header (struct loop *loop, bool may_peel_loop_headers)
762 basic_block header = loop->header;
763 edge e, tgt_edge, latch = loop_latch_edge (loop);
765 basic_block tgt_bb, atgt_bb;
766 enum bb_dom_status domst;
768 /* We have already threaded through headers to exits, so all the threading
769 requests now are to the inside of the loop. We need to avoid creating
770 irreducible regions (i.e., loops with more than one entry block), and
771 also loop with several latch edges, or new subloops of the loop (although
772 there are cases where it might be appropriate, it is difficult to decide,
773 and doing it wrongly may confuse other optimizers).
775 We could handle more general cases here. However, the intention is to
776 preserve some information about the loop, which is impossible if its
777 structure changes significantly, in a way that is not well understood.
778 Thus we only handle few important special cases, in which also updating
779 of the loop-carried information should be feasible:
781 1) Propagation of latch edge to a block that dominates the latch block
782 of a loop. This aims to handle the following idiom:
793 After threading the latch edge, this becomes
804 The original header of the loop is moved out of it, and we may thread
805 the remaining edges through it without further constraints.
807 2) All entry edges are propagated to a single basic block that dominates
808 the latch block of the loop. This aims to handle the following idiom
809 (normally created for "for" loops):
832 /* Threading through the header won't improve the code if the header has just
834 if (single_succ_p (header))
839 tgt_edge = (edge) latch->aux;
840 tgt_bb = tgt_edge->dest;
842 else if (!may_peel_loop_headers
843 && !redirection_block_p (loop->header))
849 FOR_EACH_EDGE (e, ei, header->preds)
856 /* If latch is not threaded, and there is a header
857 edge that is not threaded, we would create loop
858 with multiple entries. */
862 tgt_edge = (edge) e->aux;
863 atgt_bb = tgt_edge->dest;
866 /* Two targets of threading would make us create loop
867 with multiple entries. */
868 else if (tgt_bb != atgt_bb)
874 /* There are no threading requests. */
878 /* Redirecting to empty loop latch is useless. */
879 if (tgt_bb == loop->latch
880 && empty_block_p (loop->latch))
884 /* The target block must dominate the loop latch, otherwise we would be
885 creating a subloop. */
886 domst = determine_bb_domination_status (loop, tgt_bb);
887 if (domst == DOMST_NONDOMINATING)
889 if (domst == DOMST_LOOP_BROKEN)
891 /* If the loop ceased to exist, mark it as such, and thread through its
895 return thread_block (header, false);
898 if (tgt_bb->loop_father->header == tgt_bb)
900 /* If the target of the threading is a header of a subloop, we need
901 to create a preheader for it, so that the headers of the two loops
903 if (EDGE_COUNT (tgt_bb->preds) > 2)
905 tgt_bb = create_preheader (tgt_bb->loop_father, 0);
906 gcc_assert (tgt_bb != NULL);
909 tgt_bb = split_edge (tgt_edge);
914 /* First handle the case latch edge is redirected. */
915 loop->latch = thread_single_edge (latch);
916 gcc_assert (single_succ (loop->latch) == tgt_bb);
917 loop->header = tgt_bb;
919 /* Thread the remaining edges through the former header. */
920 thread_block (header, false);
924 basic_block new_preheader;
926 /* Now consider the case entry edges are redirected to the new entry
927 block. Remember one entry edge, so that we can find the new
928 preheader (its destination after threading). */
929 FOR_EACH_EDGE (e, ei, header->preds)
935 /* The duplicate of the header is the new preheader of the loop. Ensure
936 that it is placed correctly in the loop hierarchy. */
937 set_loop_copy (loop, loop_outer (loop));
939 thread_block (header, false);
940 set_loop_copy (loop, NULL);
941 new_preheader = e->dest;
943 /* Create the new latch block. This is always necessary, as the latch
944 must have only a single successor, but the original header had at
945 least two successors. */
947 mfb_kj_edge = single_succ_edge (new_preheader);
948 loop->header = mfb_kj_edge->dest;
949 latch = make_forwarder_block (tgt_bb, mfb_keep_just, NULL);
950 loop->header = latch->dest;
951 loop->latch = latch->src;
957 /* We failed to thread anything. Cancel the requests. */
958 FOR_EACH_EDGE (e, ei, header->preds)
965 /* Walk through the registered jump threads and convert them into a
966 form convenient for this pass.
968 Any block which has incoming edges threaded to outgoing edges
969 will have its entry in THREADED_BLOCK set.
971 Any threaded edge will have its new outgoing edge stored in the
972 original edge's AUX field.
974 This form avoids the need to walk all the edges in the CFG to
975 discover blocks which need processing and avoids unnecessary
976 hash table lookups to map from threaded edge to new target. */
979 mark_threaded_blocks (bitmap threaded_blocks)
983 bitmap tmp = BITMAP_ALLOC (NULL);
988 for (i = 0; i < VEC_length (edge, threaded_edges); i += 2)
990 edge e = VEC_index (edge, threaded_edges, i);
991 edge e2 = VEC_index (edge, threaded_edges, i + 1);
994 bitmap_set_bit (tmp, e->dest->index);
997 /* If optimizing for size, only thread through block if we don't have
998 to duplicate it or it's an otherwise empty redirection block. */
999 if (optimize_function_for_size_p (cfun))
1001 EXECUTE_IF_SET_IN_BITMAP (tmp, 0, i, bi)
1003 bb = BASIC_BLOCK (i);
1004 if (EDGE_COUNT (bb->preds) > 1
1005 && !redirection_block_p (bb))
1007 FOR_EACH_EDGE (e, ei, bb->preds)
1011 bitmap_set_bit (threaded_blocks, i);
1015 bitmap_copy (threaded_blocks, tmp);
1021 /* Walk through all blocks and thread incoming edges to the appropriate
1022 outgoing edge for each edge pair recorded in THREADED_EDGES.
1024 It is the caller's responsibility to fix the dominance information
1025 and rewrite duplicated SSA_NAMEs back into SSA form.
1027 If MAY_PEEL_LOOP_HEADERS is false, we avoid threading edges through
1028 loop headers if it does not simplify the loop.
1030 Returns true if one or more edges were threaded, false otherwise. */
1033 thread_through_all_blocks (bool may_peel_loop_headers)
1035 bool retval = false;
1038 bitmap threaded_blocks;
1042 /* We must know about loops in order to preserve them. */
1043 gcc_assert (current_loops != NULL);
1045 if (threaded_edges == NULL)
1048 threaded_blocks = BITMAP_ALLOC (NULL);
1049 memset (&thread_stats, 0, sizeof (thread_stats));
1051 mark_threaded_blocks (threaded_blocks);
1053 initialize_original_copy_tables ();
1055 /* First perform the threading requests that do not affect
1057 EXECUTE_IF_SET_IN_BITMAP (threaded_blocks, 0, i, bi)
1059 basic_block bb = BASIC_BLOCK (i);
1061 if (EDGE_COUNT (bb->preds) > 0)
1062 retval |= thread_block (bb, true);
1065 /* Then perform the threading through loop headers. We start with the
1066 innermost loop, so that the changes in cfg we perform won't affect
1067 further threading. */
1068 FOR_EACH_LOOP (li, loop, LI_FROM_INNERMOST)
1071 || !bitmap_bit_p (threaded_blocks, loop->header->index))
1074 retval |= thread_through_loop_header (loop, may_peel_loop_headers);
1077 statistics_counter_event (cfun, "Jumps threaded",
1078 thread_stats.num_threaded_edges);
1080 free_original_copy_tables ();
1082 BITMAP_FREE (threaded_blocks);
1083 threaded_blocks = NULL;
1084 VEC_free (edge, heap, threaded_edges);
1085 threaded_edges = NULL;
1088 loops_state_set (LOOPS_NEED_FIXUP);
1093 /* Register a jump threading opportunity. We queue up all the jump
1094 threading opportunities discovered by a pass and update the CFG
1095 and SSA form all at once.
1097 E is the edge we can thread, E2 is the new target edge, i.e., we
1098 are effectively recording that E->dest can be changed to E2->dest
1099 after fixing the SSA graph. */
1102 register_jump_thread (edge e, edge e2)
1104 if (threaded_edges == NULL)
1105 threaded_edges = VEC_alloc (edge, heap, 10);
1107 VEC_safe_push (edge, heap, threaded_edges, e);
1108 VEC_safe_push (edge, heap, threaded_edges, e2);