OSDN Git Service

25f6cdfdc020e620a1d69c3555ebcef96f85925b
[pf3gnuchains/gcc-fork.git] / gcc / tree-ssa-threadupdate.c
1 /* Thread edges through blocks and update the control flow and SSA graphs.
2    Copyright (C) 2004, 2005 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
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 2, or (at your option)
9 any later version.
10
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.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING.  If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "flags.h"
27 #include "rtl.h"
28 #include "tm_p.h"
29 #include "ggc.h"
30 #include "basic-block.h"
31 #include "output.h"
32 #include "expr.h"
33 #include "function.h"
34 #include "diagnostic.h"
35 #include "tree-flow.h"
36 #include "tree-dump.h"
37 #include "tree-pass.h"
38 #include "cfgloop.h"
39
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.
43
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.
46
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.
49
50      2. Remove the control statement at the end of B' and all outgoing edges
51         except B'->C.
52
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
55         with the edge B'->C.
56
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.
61
62      5. Change the edge A->B to A->B'.
63
64         5a. This automatically deletes any PHI arguments associated with the
65             edge A->B in B.
66
67         5b. This automatically associates each new argument added in step 4
68             with the edge A->B'.
69
70      6. Repeat for other incoming edges into B.
71
72      7. Put the duplicated resources in B and all the B' blocks into SSA form.
73
74    Note that block duplication can be minimized by first collecting the
75    the 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.
79
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.  */
84
85
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.
90
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.  */
96
97 struct el
98 {
99   edge e;
100   struct el *next;
101 };
102
103 /* Main data structure recording information regarding B's duplicate
104    blocks.  */
105
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.  */
110
111 struct redirection_data
112 {
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;
116
117   /* An outgoing edge from B.  DUP_BLOCK will have OUTGOING_EDGE->dest as
118      its single successor.  */
119   edge outgoing_edge;
120
121   /* A list of incoming edges which we want to thread to
122      OUTGOING_EDGE->dest.  */
123   struct el *incoming_edges;
124
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;
129 };
130
131 /* Main data structure to hold information for duplicates of BB.  */
132 static htab_t redirection_data;
133
134 bool rediscover_loops_after_threading;
135
136 /* Data structure of information to pass to hash table traversal routines.  */
137 struct local_info
138 {
139   /* The current block we are working on.  */
140   basic_block bb;
141
142   /* A template copy of BB with no outgoing edges or control statement that
143      we use for creating copies.  */
144   basic_block template_block;
145
146   /* TRUE if we thread one or more jumps, FALSE otherwise.  */
147   bool jumps_threaded;
148 };
149
150 /* Remove the last statement in block BB if it is a control statement
151    Also remove all outgoing edges except the edge which reaches DEST_BB.
152    If DEST_BB is NULL, then remove all outgoing edges.  */
153
154 static void
155 remove_ctrl_stmt_and_useless_edges (basic_block bb, basic_block dest_bb)
156 {
157   block_stmt_iterator bsi;
158   edge e;
159   edge_iterator ei;
160
161   bsi = bsi_last (bb);
162
163   /* If the duplicate ends with a control statement, then remove it.
164
165      Note that if we are duplicating the template block rather than the
166      original basic block, then the duplicate might not have any real
167      statements in it.  */
168   if (!bsi_end_p (bsi)
169       && bsi_stmt (bsi)
170       && (TREE_CODE (bsi_stmt (bsi)) == COND_EXPR
171           || TREE_CODE (bsi_stmt (bsi)) == GOTO_EXPR
172           || TREE_CODE (bsi_stmt (bsi)) == SWITCH_EXPR))
173     bsi_remove (&bsi);
174
175   for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
176     {
177       if (e->dest != dest_bb)
178         remove_edge (e);
179       else
180         ei_next (&ei);
181     }
182 }
183
184 /* Create a duplicate of BB which only reaches the destination of the edge
185    stored in RD.  Record the duplicate block in RD.  */
186
187 static void
188 create_block_for_threading (basic_block bb, struct redirection_data *rd)
189 {
190   /* We can use the generic block duplication code and simply remove
191      the stuff we do not need.  */
192   rd->dup_block = duplicate_block (bb, NULL);
193
194   /* Zero out the profile, since the block is unreachable for now.  */
195   rd->dup_block->frequency = 0;
196   rd->dup_block->count = 0;
197
198   /* The call to duplicate_block will copy everything, including the
199      useless COND_EXPR or SWITCH_EXPR at the end of BB.  We just remove
200      the useless COND_EXPR or SWITCH_EXPR here rather than having a
201      specialized block copier.  We also remove all outgoing edges
202      from the duplicate block.  The appropriate edge will be created
203      later.  */
204   remove_ctrl_stmt_and_useless_edges (rd->dup_block, NULL);
205 }
206
207 /* Hashing and equality routines for our hash table.  */
208 static hashval_t
209 redirection_data_hash (const void *p)
210 {
211   edge e = ((struct redirection_data *)p)->outgoing_edge;
212   return e->dest->index;
213 }
214
215 static int
216 redirection_data_eq (const void *p1, const void *p2)
217 {
218   edge e1 = ((struct redirection_data *)p1)->outgoing_edge;
219   edge e2 = ((struct redirection_data *)p2)->outgoing_edge;
220
221   return e1 == e2;
222 }
223
224 /* Given an outgoing edge E lookup and return its entry in our hash table.
225
226    If INSERT is true, then we insert the entry into the hash table if
227    it is not already present.  INCOMING_EDGE is added to the list of incoming
228    edges associated with E in the hash table.  */
229
230 static struct redirection_data *
231 lookup_redirection_data (edge e, edge incoming_edge, enum insert_option insert)
232 {
233   void **slot;
234   struct redirection_data *elt;
235
236  /* Build a hash table element so we can see if E is already
237      in the table.  */
238   elt = xmalloc (sizeof (struct redirection_data));
239   elt->outgoing_edge = e;
240   elt->dup_block = NULL;
241   elt->do_not_duplicate = false;
242   elt->incoming_edges = NULL;
243
244   slot = htab_find_slot (redirection_data, elt, insert);
245
246   /* This will only happen if INSERT is false and the entry is not
247      in the hash table.  */
248   if (slot == NULL)
249     {
250       free (elt);
251       return NULL;
252     }
253
254   /* This will only happen if E was not in the hash table and
255      INSERT is true.  */
256   if (*slot == NULL)
257     {
258       *slot = (void *)elt;
259       elt->incoming_edges = xmalloc (sizeof (struct el));
260       elt->incoming_edges->e = incoming_edge;
261       elt->incoming_edges->next = NULL;
262       return elt;
263     }
264   /* E was in the hash table.  */
265   else
266     {
267       /* Free ELT as we do not need it anymore, we will extract the
268          relevant entry from the hash table itself.  */
269       free (elt);
270
271       /* Get the entry stored in the hash table.  */
272       elt = (struct redirection_data *) *slot;
273
274       /* If insertion was requested, then we need to add INCOMING_EDGE
275          to the list of incoming edges associated with E.  */
276       if (insert)
277         {
278           struct el *el = xmalloc (sizeof (struct el));
279           el->next = elt->incoming_edges;
280           el->e = incoming_edge;
281           elt->incoming_edges = el;
282         }
283
284       return elt;
285     }
286 }
287
288 /* Given a duplicate block and its single destination (both stored
289    in RD).  Create an edge between the duplicate and its single
290    destination.
291
292    Add an additional argument to any PHI nodes at the single
293    destination.  */
294
295 static void
296 create_edge_and_update_destination_phis (struct redirection_data *rd)
297 {
298   edge e = make_edge (rd->dup_block, rd->outgoing_edge->dest, EDGE_FALLTHRU);
299   tree phi;
300
301   e->probability = REG_BR_PROB_BASE;
302   e->count = rd->dup_block->count;
303
304   /* If there are any PHI nodes at the destination of the outgoing edge
305      from the duplicate block, then we will need to add a new argument
306      to them.  The argument should have the same value as the argument
307      associated with the outgoing edge stored in RD.  */
308   for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
309     {
310       int indx = rd->outgoing_edge->dest_idx;
311       add_phi_arg (phi, PHI_ARG_DEF (phi, indx), e);
312     }
313 }
314
315 /* Hash table traversal callback routine to create duplicate blocks.  */
316
317 static int
318 create_duplicates (void **slot, void *data)
319 {
320   struct redirection_data *rd = (struct redirection_data *) *slot;
321   struct local_info *local_info = (struct local_info *)data;
322
323   /* If this entry should not have a duplicate created, then there's
324      nothing to do.  */
325   if (rd->do_not_duplicate)
326     return 1;
327
328   /* Create a template block if we have not done so already.  Otherwise
329      use the template to create a new block.  */
330   if (local_info->template_block == NULL)
331     {
332       create_block_for_threading (local_info->bb, rd);
333       local_info->template_block = rd->dup_block;
334
335       /* We do not create any outgoing edges for the template.  We will
336          take care of that in a later traversal.  That way we do not
337          create edges that are going to just be deleted.  */
338     }
339   else
340     {
341       create_block_for_threading (local_info->template_block, rd);
342
343       /* Go ahead and wire up outgoing edges and update PHIs for the duplicate
344          block.  */
345       create_edge_and_update_destination_phis (rd);
346     }
347
348   /* Keep walking the hash table.  */
349   return 1;
350 }
351
352 /* We did not create any outgoing edges for the template block during
353    block creation.  This hash table traversal callback creates the
354    outgoing edge for the template block.  */
355
356 static int
357 fixup_template_block (void **slot, void *data)
358 {
359   struct redirection_data *rd = (struct redirection_data *) *slot;
360   struct local_info *local_info = (struct local_info *)data;
361
362   /* If this is the template block, then create its outgoing edges
363      and halt the hash table traversal.  */
364   if (rd->dup_block && rd->dup_block == local_info->template_block)
365     {
366       create_edge_and_update_destination_phis (rd);
367       return 0;
368     }
369
370   return 1;
371 }
372
373 /* Not all jump threading requests are useful.  In particular some
374    jump threading requests can create irreducible regions which are
375    undesirable.
376
377    This routine will examine the BB's incoming edges for jump threading
378    requests which, if acted upon, would create irreducible regions.  Any
379    such jump threading requests found will be pruned away.  */
380
381 static void
382 prune_undesirable_thread_requests (basic_block bb)
383 {
384   edge e;
385   edge_iterator ei;
386   bool may_create_irreducible_region = false;
387   unsigned int num_outgoing_edges_into_loop = 0;
388
389   /* For the heuristics below, we need to know if BB has more than
390      one outgoing edge into a loop.  */
391   FOR_EACH_EDGE (e, ei, bb->succs)
392     num_outgoing_edges_into_loop += ((e->flags & EDGE_LOOP_EXIT) == 0);
393
394   if (num_outgoing_edges_into_loop > 1)
395     {
396       edge backedge = NULL;
397
398       /* Consider the effect of threading the edge (0, 1) to 2 on the left
399          CFG to produce the right CFG:
400     
401
402              0            0
403              |            |
404              1<--+        2<--------+
405             / \  |        |         |
406            2   3 |        4<----+   |
407             \ /  |       / \    |   |
408              4---+      E   1-- | --+
409              |              |   |
410              E              3---+
411
412
413         Threading the (0, 1) edge to 2 effectively creates two loops
414         (2, 4, 1) and (4, 1, 3) which are neither disjoint nor nested.
415         This is not good.
416
417         However, we do need to be able to thread  (0, 1) to 2 or 3
418         in the left CFG below (which creates the middle and right
419         CFGs with nested loops).
420
421              0          0             0
422              |          |             |
423              1<--+      2<----+       3<-+<-+
424             /|   |      |     |       |  |  |
425            2 |   |      3<-+  |       1--+  |
426             \|   |      |  |  |       |     |
427              3---+      1--+--+       2-----+
428
429          
430          A safe heuristic appears to be to only allow threading if BB
431          has a single incoming backedge from one of its direct successors.  */
432
433       FOR_EACH_EDGE (e, ei, bb->preds)
434         {
435           if (e->flags & EDGE_DFS_BACK)
436             {
437               if (backedge)
438                 {
439                   backedge = NULL;
440                   break;
441                 }
442               else
443                 {
444                   backedge = e;
445                 }
446             }
447         }
448
449       if (backedge && find_edge (bb, backedge->src))
450         ;
451       else
452         may_create_irreducible_region = true;
453     }
454   else
455     {
456       edge dest = NULL;
457
458       /* If we thread across the loop entry block (BB) into the
459          loop and BB is still reached from outside the loop, then
460          we would create an irreducible CFG.  Consider the effect
461          of threading the edge (1, 4) to 5 on the left CFG to produce
462          the right CFG
463
464              0               0
465             / \             / \
466            1   2           1   2
467             \ /            |   |
468              4<----+       5<->4
469             / \    |           |
470            E   5---+           E
471
472
473          Threading the (1, 4) edge to 5 creates two entry points
474          into the loop (4, 5) (one from block 1, the other from
475          block 2).  A classic irreducible region. 
476
477          So look at all of BB's incoming edges which are not
478          backedges and which are not threaded to the loop exit.
479          If that subset of incoming edges do not all thread
480          to the same block, then threading any of them will create
481          an irreducible region.  */
482
483       FOR_EACH_EDGE (e, ei, bb->preds)
484         {
485           edge e2;
486
487           /* We ignore back edges for now.  This may need refinement
488              as threading a backedge creates an inner loop which
489              we would need to verify has a single entry point. 
490
491              If all backedges thread to new locations, then this
492              block will no longer have incoming backedges and we
493              need not worry about creating irreducible regions
494              by threading through BB.  I don't think this happens
495              enough in practice to worry about it.  */
496           if (e->flags & EDGE_DFS_BACK)
497             continue;
498
499           /* If the incoming edge threads to the loop exit, then it
500              is clearly safe.  */
501           e2 = e->aux;
502           if (e2 && (e2->flags & EDGE_LOOP_EXIT))
503             continue;
504
505           /* E enters the loop header and is not threaded.  We can
506              not allow any other incoming edges to thread into
507              the loop as that would create an irreducible region.  */
508           if (!e2)
509             {
510               may_create_irreducible_region = true;
511               break;
512             }
513
514           /* We know that this incoming edge threads to a block inside
515              the loop.  This edge must thread to the same target in
516              the loop as any previously seen threaded edges.  Otherwise
517              we will create an irreducible region.  */
518           if (!dest)
519             dest = e2;
520           else if (e2 != dest)
521             {
522               may_create_irreducible_region = true;
523               break;
524             }
525         }
526     }
527
528   /* If we might create an irreducible region, then cancel any of
529      the jump threading requests for incoming edges which are
530      not backedges and which do not thread to the exit block.  */
531   if (may_create_irreducible_region)
532     {
533       FOR_EACH_EDGE (e, ei, bb->preds)
534         {
535           edge e2;
536
537           /* Ignore back edges.  */
538           if (e->flags & EDGE_DFS_BACK)
539             continue;
540
541           e2 = e->aux;
542
543           /* If this incoming edge was not threaded, then there is
544              nothing to do.  */
545           if (!e2)
546             continue;
547
548           /* If this incoming edge threaded to the loop exit,
549              then it can be ignored as it is safe.  */
550           if (e2->flags & EDGE_LOOP_EXIT)
551             continue;
552
553           if (e2)
554             {
555               /* This edge threaded into the loop and the jump thread
556                  request must be cancelled.  */
557               if (dump_file && (dump_flags & TDF_DETAILS))
558                 fprintf (dump_file, "  Not threading jump %d --> %d to %d\n",
559                          e->src->index, e->dest->index, e2->dest->index);
560               e->aux = NULL;
561             }
562         }
563     }
564 }
565
566 /* Hash table traversal callback to redirect each incoming edge
567    associated with this hash table element to its new destination.  */
568
569 static int
570 redirect_edges (void **slot, void *data)
571 {
572   struct redirection_data *rd = (struct redirection_data *) *slot;
573   struct local_info *local_info = (struct local_info *)data;
574   struct el *next, *el;
575
576   /* Walk over all the incoming edges associated associated with this
577      hash table entry.  */
578   for (el = rd->incoming_edges; el; el = next)
579     {
580       edge e = el->e;
581
582       /* Go ahead and free this element from the list.  Doing this now
583          avoids the need for another list walk when we destroy the hash
584          table.  */
585       next = el->next;
586       free (el);
587
588       /* Go ahead and clear E->aux.  It's not needed anymore and failure
589          to clear it will cause all kinds of unpleasant problems later.  */
590       e->aux = NULL;
591
592       if (rd->dup_block)
593         {
594           edge e2;
595
596           if (dump_file && (dump_flags & TDF_DETAILS))
597             fprintf (dump_file, "  Threaded jump %d --> %d to %d\n",
598                      e->src->index, e->dest->index, rd->dup_block->index);
599
600           /* Redirect the incoming edge to the appropriate duplicate
601              block.  */
602           e2 = redirect_edge_and_branch (e, rd->dup_block);
603           flush_pending_stmts (e2);
604
605           if ((dump_file && (dump_flags & TDF_DETAILS))
606               && e->src != e2->src)
607             fprintf (dump_file, "    basic block %d created\n", e2->src->index);
608         }
609       else
610         {
611           if (dump_file && (dump_flags & TDF_DETAILS))
612             fprintf (dump_file, "  Threaded jump %d --> %d to %d\n",
613                      e->src->index, e->dest->index, local_info->bb->index);
614
615           /* We are using BB as the duplicate.  Remove the unnecessary
616              outgoing edges and statements from BB.  */
617           remove_ctrl_stmt_and_useless_edges (local_info->bb,
618                                               rd->outgoing_edge->dest);
619
620           /* And fixup the flags on the single remaining edge.  */
621           single_succ_edge (local_info->bb)->flags
622             &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE | EDGE_ABNORMAL);
623           single_succ_edge (local_info->bb)->flags |= EDGE_FALLTHRU;
624         }
625     }
626
627   /* Indicate that we actually threaded one or more jumps.  */
628   if (rd->incoming_edges)
629     local_info->jumps_threaded = true;
630
631   return 1;
632 }
633
634 /* BB is a block which ends with a COND_EXPR or SWITCH_EXPR and when BB
635    is reached via one or more specific incoming edges, we know which
636    outgoing edge from BB will be traversed.
637
638    We want to redirect those incoming edges to the target of the
639    appropriate outgoing edge.  Doing so avoids a conditional branch
640    and may expose new optimization opportunities.  Note that we have
641    to update dominator tree and SSA graph after such changes.
642
643    The key to keeping the SSA graph update manageable is to duplicate
644    the side effects occurring in BB so that those side effects still
645    occur on the paths which bypass BB after redirecting edges.
646
647    We accomplish this by creating duplicates of BB and arranging for
648    the duplicates to unconditionally pass control to one specific
649    successor of BB.  We then revector the incoming edges into BB to
650    the appropriate duplicate of BB.
651
652    BB and its duplicates will have assignments to the same set of
653    SSA_NAMEs.  Right now, we just call into update_ssa to update the
654    SSA graph for those names.
655
656    We are also going to experiment with a true incremental update
657    scheme for the duplicated resources.  One of the interesting
658    properties we can exploit here is that all the resources set
659    in BB will have the same IDFS, so we have one IDFS computation
660    per block with incoming threaded edges, which can lower the
661    cost of the true incremental update algorithm.  */
662
663 static bool
664 thread_block (basic_block bb)
665 {
666   /* E is an incoming edge into BB that we may or may not want to
667      redirect to a duplicate of BB.  */
668   edge e;
669   edge_iterator ei;
670   struct local_info local_info;
671
672   /* FOUND_BACKEDGE indicates that we found an incoming backedge
673      into BB, in which case we may ignore certain jump threads
674      to avoid creating irreducible regions.  */
675   bool found_backedge = false;
676
677   /* ALL indicates whether or not all incoming edges into BB should
678      be threaded to a duplicate of BB.  */
679   bool all = true;
680
681   /* To avoid scanning a linear array for the element we need we instead
682      use a hash table.  For normal code there should be no noticeable
683      difference.  However, if we have a block with a large number of
684      incoming and outgoing edges such linear searches can get expensive.  */
685   redirection_data = htab_create (EDGE_COUNT (bb->succs),
686                                   redirection_data_hash,
687                                   redirection_data_eq,
688                                   free);
689
690   FOR_EACH_EDGE (e, ei, bb->preds)
691     found_backedge |= ((e->flags & EDGE_DFS_BACK) != 0);
692
693   /* If BB has incoming backedges, then threading across BB might
694      introduce an irreducible region, which would be undesirable
695      as that inhibits various optimizations later.  Prune away
696      any jump threading requests which we know will result in
697      an irreducible region.  */
698   if (found_backedge)
699     prune_undesirable_thread_requests (bb);
700
701   /* Record each unique threaded destination into a hash table for
702      efficient lookups.  */
703   FOR_EACH_EDGE (e, ei, bb->preds)
704     {
705       if (!e->aux)
706         {
707           all = false;
708         }
709       else
710         {
711           edge e2 = e->aux;
712
713           /* If we thread to a loop exit edge, then we will need to 
714              rediscover the loop exit edges.  While it may seem that
715              the new edge is a loop exit edge, that is not the case.
716              Consider threading the edge (5,6) to E in the CFG on the
717              left which creates the CFG on the right:
718
719
720                       0<--+            0<---+
721                      / \  |           / \   |
722                     1   2 |          1   2  |
723                    / \  | |         / \  |  |
724                   3   4 | |        3   4 6--+
725                    \ /  | |         \ /
726                     5   | |          5
727                      \ /  |          |
728                       6---+          E
729                       |
730                       E
731
732              After threading, the edge (0, 1)  is the loop exit edge and
733              the nodes 0, 2, 6 are the only nodes in the loop.  */
734           if (e2->flags & EDGE_LOOP_EXIT)
735             rediscover_loops_after_threading = true;
736
737           /* Insert the outgoing edge into the hash table if it is not
738              already in the hash table.  */
739           lookup_redirection_data (e2, e, INSERT);
740         }
741     }
742
743   /* If we are going to thread all incoming edges to an outgoing edge, then
744      BB will become unreachable.  Rather than just throwing it away, use
745      it for one of the duplicates.  Mark the first incoming edge with the
746      DO_NOT_DUPLICATE attribute.  */
747   if (all)
748     {
749       edge e = EDGE_PRED (bb, 0)->aux;
750       lookup_redirection_data (e, NULL, NO_INSERT)->do_not_duplicate = true;
751     }
752
753   /* Now create duplicates of BB.
754
755      Note that for a block with a high outgoing degree we can waste
756      a lot of time and memory creating and destroying useless edges.
757
758      So we first duplicate BB and remove the control structure at the
759      tail of the duplicate as well as all outgoing edges from the
760      duplicate.  We then use that duplicate block as a template for
761      the rest of the duplicates.  */
762   local_info.template_block = NULL;
763   local_info.bb = bb;
764   local_info.jumps_threaded = false;
765   htab_traverse (redirection_data, create_duplicates, &local_info);
766
767   /* The template does not have an outgoing edge.  Create that outgoing
768      edge and update PHI nodes as the edge's target as necessary.
769
770      We do this after creating all the duplicates to avoid creating
771      unnecessary edges.  */
772   htab_traverse (redirection_data, fixup_template_block, &local_info);
773
774   /* The hash table traversals above created the duplicate blocks (and the
775      statements within the duplicate blocks).  This loop creates PHI nodes for
776      the duplicated blocks and redirects the incoming edges into BB to reach
777      the duplicates of BB.  */
778   htab_traverse (redirection_data, redirect_edges, &local_info);
779
780   /* Done with this block.  Clear REDIRECTION_DATA.  */
781   htab_delete (redirection_data);
782   redirection_data = NULL;
783
784   /* Indicate to our caller whether or not any jumps were threaded.  */
785   return local_info.jumps_threaded;
786 }
787
788 /* Walk through all blocks and thread incoming edges to the block's
789    destinations as requested.  This is the only entry point into this
790    file.
791
792    Blocks which have one or more incoming edges have INCOMING_EDGE_THREADED
793    set in the block's annotation.
794
795    Each edge that should be threaded has the new destination edge stored in
796    the original edge's AUX field.
797
798    This routine (or one of its callees) will clear INCOMING_EDGE_THREADED
799    in the block annotations and the AUX field in the edges.
800
801    It is the caller's responsibility to fix the dominance information
802    and rewrite duplicated SSA_NAMEs back into SSA form.
803
804    Returns true if one or more edges were threaded, false otherwise.  */
805
806 bool
807 thread_through_all_blocks (bitmap threaded_blocks)
808 {
809   bool retval = false;
810   unsigned int i;
811   bitmap_iterator bi;
812
813   rediscover_loops_after_threading = false;
814
815   EXECUTE_IF_SET_IN_BITMAP (threaded_blocks, 0, i, bi)
816     {
817       basic_block bb = BASIC_BLOCK (i);
818
819       if (EDGE_COUNT (bb->preds) > 0)
820         retval |= thread_block (bb);
821     }
822
823   return retval;
824 }