gcc/tree-cfgcleanup.c

   1 /* CFG cleanup for trees.
   2    Copyright (C) 2001, 2002, 2003, 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 "rtl.h"
  27 #include "tm_p.h"
  28 #include "hard-reg-set.h"
  29 #include "basic-block.h"
  30 #include "output.h"
  31 #include "errors.h"
  32 #include "flags.h"
  33 #include "function.h"
  34 #include "expr.h"
  35 #include "ggc.h"
  36 #include "langhooks.h"
  37 #include "diagnostic.h"
  38 #include "tree-flow.h"
  39 #include "timevar.h"
  40 #include "tree-dump.h"
  41 #include "tree-pass.h"
  42 #include "toplev.h"
  43 #include "except.h"
  44 #include "cfgloop.h"
  45 #include "cfglayout.h"
  46 #include "hashtab.h"
  47 #include "tree-ssa-propagate.h"
  48
  49 /* Remove any fallthru edge from EV.  Return true if an edge was removed.  */
  50
  51 static bool
  52 remove_fallthru_edge (VEC(edge,gc) *ev)
  53 {
  54   edge_iterator ei;
  55   edge e;
  56
  57   FOR_EACH_EDGE (e, ei, ev)
  58     if ((e->flags & EDGE_FALLTHRU) != 0)
  59       {
  60         remove_edge (e);
  61         return true;
  62       }
  63   return false;
  64 }
  65
  66 /* Disconnect an unreachable block in the control expression starting
  67    at block BB.  */
  68
  69 static bool
  70 cleanup_control_expr_graph (basic_block bb, block_stmt_iterator bsi)
  71 {
  72   edge taken_edge;
  73   bool retval = false;
  74   tree expr = bsi_stmt (bsi), val;
  75
  76   if (!single_succ_p (bb))
  77     {
  78       edge e;
  79       edge_iterator ei;
  80
  81       switch (TREE_CODE (expr))
  82         {
  83         case COND_EXPR:
  84           val = COND_EXPR_COND (expr);
  85           break;
  86
  87         case SWITCH_EXPR:
  88           val = SWITCH_COND (expr);
  89           if (TREE_CODE (val) != INTEGER_CST)
  90             return false;
  91           break;
  92
  93         default:
  94           gcc_unreachable ();
  95         }
  96
  97       taken_edge = find_taken_edge (bb, val);
  98       if (!taken_edge)
  99         return false;
 100
 101       /* Remove all the edges except the one that is always executed.  */
 102       for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
 103         {
 104           if (e != taken_edge)
 105             {
 106               taken_edge->probability += e->probability;
 107               taken_edge->count += e->count;
 108               remove_edge (e);
 109               retval = true;
 110             }
 111           else
 112             ei_next (&ei);
 113         }
 114       if (taken_edge->probability > REG_BR_PROB_BASE)
 115         taken_edge->probability = REG_BR_PROB_BASE;
 116     }
 117   else
 118     taken_edge = single_succ_edge (bb);
 119
 120   bsi_remove (&bsi);
 121   taken_edge->flags = EDGE_FALLTHRU;
 122
 123   /* We removed some paths from the cfg.  */
 124   free_dominance_info (CDI_DOMINATORS);
 125
 126   return retval;
 127 }
 128
 129 /* A list of all the noreturn calls passed to modify_stmt.
 130    cleanup_control_flow uses it to detect cases where a mid-block
 131    indirect call has been turned into a noreturn call.  When this
 132    happens, all the instructions after the call are no longer
 133    reachable and must be deleted as dead.  */
 134
 135 VEC(tree,gc) *modified_noreturn_calls;
 136
 137 /* Try to remove superfluous control structures.  */
 138
 139 static bool
 140 cleanup_control_flow (void)
 141 {
 142   basic_block bb;
 143   block_stmt_iterator bsi;
 144   bool retval = false;
 145   tree stmt;
 146
 147   /* Detect cases where a mid-block call is now known not to return.  */
 148   while (VEC_length (tree, modified_noreturn_calls))
 149     {
 150       stmt = VEC_pop (tree, modified_noreturn_calls);
 151       bb = bb_for_stmt (stmt);
 152       if (bb != NULL && last_stmt (bb) != stmt && noreturn_call_p (stmt))
 153         split_block (bb, stmt);
 154     }
 155
 156   FOR_EACH_BB (bb)
 157     {
 158       bsi = bsi_last (bb);
 159
 160       if (bsi_end_p (bsi))
 161         continue;
 162
 163       stmt = bsi_stmt (bsi);
 164       if (TREE_CODE (stmt) == COND_EXPR
 165           || TREE_CODE (stmt) == SWITCH_EXPR)
 166         retval |= cleanup_control_expr_graph (bb, bsi);
 167
 168       /* If we had a computed goto which has a compile-time determinable
 169          destination, then we can eliminate the goto.  */
 170       if (TREE_CODE (stmt) == GOTO_EXPR
 171           && TREE_CODE (GOTO_DESTINATION (stmt)) == ADDR_EXPR
 172           && TREE_CODE (TREE_OPERAND (GOTO_DESTINATION (stmt), 0)) == LABEL_DECL)
 173         {
 174           edge e;
 175           tree label;
 176           edge_iterator ei;
 177           basic_block target_block;
 178           bool removed_edge = false;
 179
 180           /* First look at all the outgoing edges.  Delete any outgoing
 181              edges which do not go to the right block.  For the one
 182              edge which goes to the right block, fix up its flags.  */
 183           label = TREE_OPERAND (GOTO_DESTINATION (stmt), 0);
 184           target_block = label_to_block (label);
 185           for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
 186             {
 187               if (e->dest != target_block)
 188                 {
 189                   removed_edge = true;
 190                   remove_edge (e);
 191                 }
 192               else
 193                 {
 194                   /* Turn off the EDGE_ABNORMAL flag.  */
 195                   e->flags &= ~EDGE_ABNORMAL;
 196
 197                   /* And set EDGE_FALLTHRU.  */
 198                   e->flags |= EDGE_FALLTHRU;
 199                   ei_next (&ei);
 200                 }
 201             }
 202
 203           /* If we removed one or more edges, then we will need to fix the
 204              dominators.  It may be possible to incrementally update them.  */
 205           if (removed_edge)
 206             free_dominance_info (CDI_DOMINATORS);
 207
 208           /* Remove the GOTO_EXPR as it is not needed.  The CFG has all the
 209              relevant information we need.  */
 210           bsi_remove (&bsi);
 211           retval = true;
 212         }
 213
 214       /* Check for indirect calls that have been turned into
 215          noreturn calls.  */
 216       if (noreturn_call_p (stmt) && remove_fallthru_edge (bb->succs))
 217         {
 218           free_dominance_info (CDI_DOMINATORS);
 219           retval = true;
 220         }
 221     }
 222   return retval;
 223 }
 224
 225 /* Return true if basic block BB does nothing except pass control
 226    flow to another block and that we can safely insert a label at
 227    the start of the successor block.
 228
 229    As a precondition, we require that BB be not equal to
 230    ENTRY_BLOCK_PTR.  */
 231
 232 static bool
 233 tree_forwarder_block_p (basic_block bb, bool phi_wanted)
 234 {
 235   block_stmt_iterator bsi;
 236
 237   /* BB must have a single outgoing edge.  */
 238   if (single_succ_p (bb) != 1
 239       /* If PHI_WANTED is false, BB must not have any PHI nodes.
 240          Otherwise, BB must have PHI nodes.  */
 241       || (phi_nodes (bb) != NULL_TREE) != phi_wanted
 242       /* BB may not be a predecessor of EXIT_BLOCK_PTR.  */
 243       || single_succ (bb) == EXIT_BLOCK_PTR
 244       /* Nor should this be an infinite loop.  */
 245       || single_succ (bb) == bb
 246       /* BB may not have an abnormal outgoing edge.  */
 247       || (single_succ_edge (bb)->flags & EDGE_ABNORMAL))
 248     return false;
 249
 250 #if ENABLE_CHECKING
 251   gcc_assert (bb != ENTRY_BLOCK_PTR);
 252 #endif
 253
 254   /* Now walk through the statements backward.  We can ignore labels,
 255      anything else means this is not a forwarder block.  */
 256   for (bsi = bsi_last (bb); !bsi_end_p (bsi); bsi_prev (&bsi))
 257     {
 258       tree stmt = bsi_stmt (bsi);
 259
 260       switch (TREE_CODE (stmt))
 261         {
 262         case LABEL_EXPR:
 263           if (DECL_NONLOCAL (LABEL_EXPR_LABEL (stmt)))
 264             return false;
 265           break;
 266
 267         default:
 268           return false;
 269         }
 270     }
 271
 272   if (find_edge (ENTRY_BLOCK_PTR, bb))
 273     return false;
 274
 275   if (current_loops)
 276     {
 277       basic_block dest;
 278       /* Protect loop latches, headers and preheaders.  */
 279       if (bb->loop_father->header == bb)
 280         return false;
 281       dest = EDGE_SUCC (bb, 0)->dest;
 282
 283       if (dest->loop_father->header == dest)
 284         return false;
 285     }
 286
 287   return true;
 288 }
 289
 290 /* Return true if BB has at least one abnormal incoming edge.  */
 291
 292 static inline bool
 293 has_abnormal_incoming_edge_p (basic_block bb)
 294 {
 295   edge e;
 296   edge_iterator ei;
 297
 298   FOR_EACH_EDGE (e, ei, bb->preds)
 299     if (e->flags & EDGE_ABNORMAL)
 300       return true;
 301
 302   return false;
 303 }
 304
 305 /* If all the PHI nodes in DEST have alternatives for E1 and E2 and
 306    those alternatives are equal in each of the PHI nodes, then return
 307    true, else return false.  */
 308
 309 static bool
 310 phi_alternatives_equal (basic_block dest, edge e1, edge e2)
 311 {
 312   int n1 = e1->dest_idx;
 313   int n2 = e2->dest_idx;
 314   tree phi;
 315
 316   for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
 317     {
 318       tree val1 = PHI_ARG_DEF (phi, n1);
 319       tree val2 = PHI_ARG_DEF (phi, n2);
 320
 321       gcc_assert (val1 != NULL_TREE);
 322       gcc_assert (val2 != NULL_TREE);
 323
 324       if (!operand_equal_for_phi_arg_p (val1, val2))
 325         return false;
 326     }
 327
 328   return true;
 329 }
 330
 331 /* Removes forwarder block BB.  Returns false if this failed.  If a new
 332    forwarder block is created due to redirection of edges, it is
 333    stored to worklist.  */
 334
 335 static bool
 336 remove_forwarder_block (basic_block bb, basic_block **worklist)
 337 {
 338   edge succ = single_succ_edge (bb), e, s;
 339   basic_block dest = succ->dest;
 340   tree label;
 341   tree phi;
 342   edge_iterator ei;
 343   block_stmt_iterator bsi, bsi_to;
 344   bool seen_abnormal_edge = false;
 345
 346   /* We check for infinite loops already in tree_forwarder_block_p.
 347      However it may happen that the infinite loop is created
 348      afterwards due to removal of forwarders.  */
 349   if (dest == bb)
 350     return false;
 351
 352   /* If the destination block consists of a nonlocal label, do not merge
 353      it.  */
 354   label = first_stmt (dest);
 355   if (label
 356       && TREE_CODE (label) == LABEL_EXPR
 357       && DECL_NONLOCAL (LABEL_EXPR_LABEL (label)))
 358     return false;
 359
 360   /* If there is an abnormal edge to basic block BB, but not into
 361      dest, problems might occur during removal of the phi node at out
 362      of ssa due to overlapping live ranges of registers.
 363
 364      If there is an abnormal edge in DEST, the problems would occur
 365      anyway since cleanup_dead_labels would then merge the labels for
 366      two different eh regions, and rest of exception handling code
 367      does not like it.
 368
 369      So if there is an abnormal edge to BB, proceed only if there is
 370      no abnormal edge to DEST and there are no phi nodes in DEST.  */
 371   if (has_abnormal_incoming_edge_p (bb))
 372     {
 373       seen_abnormal_edge = true;
 374
 375       if (has_abnormal_incoming_edge_p (dest)
 376           || phi_nodes (dest) != NULL_TREE)
 377         return false;
 378     }
 379
 380   /* If there are phi nodes in DEST, and some of the blocks that are
 381      predecessors of BB are also predecessors of DEST, check that the
 382      phi node arguments match.  */
 383   if (phi_nodes (dest))
 384     {
 385       FOR_EACH_EDGE (e, ei, bb->preds)
 386         {
 387           s = find_edge (e->src, dest);
 388           if (!s)
 389             continue;
 390
 391           if (!phi_alternatives_equal (dest, succ, s))
 392             return false;
 393         }
 394     }
 395
 396   /* Redirect the edges.  */
 397   for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
 398     {
 399       if (e->flags & EDGE_ABNORMAL)
 400         {
 401           /* If there is an abnormal edge, redirect it anyway, and
 402              move the labels to the new block to make it legal.  */
 403           s = redirect_edge_succ_nodup (e, dest);
 404         }
 405       else
 406         s = redirect_edge_and_branch (e, dest);
 407
 408       if (s == e)
 409         {
 410           /* Create arguments for the phi nodes, since the edge was not
 411              here before.  */
 412           for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
 413             add_phi_arg (phi, PHI_ARG_DEF (phi, succ->dest_idx), s);
 414         }
 415       else
 416         {
 417           /* The source basic block might become a forwarder.  We know
 418              that it was not a forwarder before, since it used to have
 419              at least two outgoing edges, so we may just add it to
 420              worklist.  */
 421           if (tree_forwarder_block_p (s->src, false))
 422             *(*worklist)++ = s->src;
 423         }
 424     }
 425
 426   if (seen_abnormal_edge)
 427     {
 428       /* Move the labels to the new block, so that the redirection of
 429          the abnormal edges works.  */
 430
 431       bsi_to = bsi_start (dest);
 432       for (bsi = bsi_start (bb); !bsi_end_p (bsi); )
 433         {
 434           label = bsi_stmt (bsi);
 435           gcc_assert (TREE_CODE (label) == LABEL_EXPR);
 436           bsi_remove (&bsi);
 437           bsi_insert_before (&bsi_to, label, BSI_CONTINUE_LINKING);
 438         }
 439     }
 440
 441   /* Update the dominators.  */
 442   if (dom_info_available_p (CDI_DOMINATORS))
 443     {
 444       basic_block dom, dombb, domdest;
 445
 446       dombb = get_immediate_dominator (CDI_DOMINATORS, bb);
 447       domdest = get_immediate_dominator (CDI_DOMINATORS, dest);
 448       if (domdest == bb)
 449         {
 450           /* Shortcut to avoid calling (relatively expensive)
 451              nearest_common_dominator unless necessary.  */
 452           dom = dombb;
 453         }
 454       else
 455         dom = nearest_common_dominator (CDI_DOMINATORS, domdest, dombb);
 456
 457       set_immediate_dominator (CDI_DOMINATORS, dest, dom);
 458     }
 459
 460   /* And kill the forwarder block.  */
 461   delete_basic_block (bb);
 462
 463   return true;
 464 }
 465
 466 /* Removes forwarder blocks.  */
 467
 468 static bool
 469 cleanup_forwarder_blocks (void)
 470 {
 471   basic_block bb;
 472   bool changed = false;
 473   basic_block *worklist = xmalloc (sizeof (basic_block) * n_basic_blocks);
 474   basic_block *current = worklist;
 475
 476   FOR_EACH_BB (bb)
 477     {
 478       if (tree_forwarder_block_p (bb, false))
 479         *current++ = bb;
 480     }
 481
 482   while (current != worklist)
 483     {
 484       bb = *--current;
 485       changed |= remove_forwarder_block (bb, &current);
 486     }
 487
 488   free (worklist);
 489   return changed;
 490 }
 491
 492 /* Remove unreachable blocks and other miscellaneous clean up work.  */
 493
 494 bool
 495 cleanup_tree_cfg (void)
 496 {
 497   bool retval = false;
 498
 499   timevar_push (TV_TREE_CLEANUP_CFG);
 500
 501   retval = cleanup_control_flow ();
 502   retval |= delete_unreachable_blocks ();
 503
 504   /* cleanup_forwarder_blocks can redirect edges out of SWITCH_EXPRs,
 505      which can get expensive.  So we want to enable recording of edge
 506      to CASE_LABEL_EXPR mappings around the call to
 507      cleanup_forwarder_blocks.  */
 508   start_recording_case_labels ();
 509   retval |= cleanup_forwarder_blocks ();
 510   end_recording_case_labels ();
 511
 512 #ifdef ENABLE_CHECKING
 513   if (retval)
 514     {
 515       gcc_assert (!cleanup_control_flow ());
 516       gcc_assert (!delete_unreachable_blocks ());
 517       gcc_assert (!cleanup_forwarder_blocks ());
 518     }
 519 #endif
 520
 521   /* Merging the blocks creates no new opportunities for the other
 522      optimizations, so do it here.  */
 523   retval |= merge_seq_blocks ();
 524
 525   compact_blocks ();
 526
 527 #ifdef ENABLE_CHECKING
 528   verify_flow_info ();
 529 #endif
 530   timevar_pop (TV_TREE_CLEANUP_CFG);
 531   return retval;
 532 }
 533
 534 /* Cleanup cfg and repair loop structures.  */
 535
 536 void
 537 cleanup_tree_cfg_loop (void)
 538 {
 539   bitmap changed_bbs = BITMAP_ALLOC (NULL);
 540
 541   cleanup_tree_cfg ();
 542
 543   fix_loop_structure (current_loops, changed_bbs);
 544   calculate_dominance_info (CDI_DOMINATORS);
 545
 546   /* This usually does nothing.  But sometimes parts of cfg that originally
 547      were inside a loop get out of it due to edge removal (since they
 548      become unreachable by back edges from latch).  */
 549   rewrite_into_loop_closed_ssa (changed_bbs, TODO_update_ssa);
 550
 551   BITMAP_FREE (changed_bbs);
 552
 553 #ifdef ENABLE_CHECKING
 554   verify_loop_structure (current_loops);
 555 #endif
 556 }
 557
 558 /* Merge the PHI nodes at BB into those at BB's sole successor.  */
 559
 560 static void
 561 remove_forwarder_block_with_phi (basic_block bb)
 562 {
 563   edge succ = single_succ_edge (bb);
 564   basic_block dest = succ->dest;
 565   tree label;
 566   basic_block dombb, domdest, dom;
 567
 568   /* We check for infinite loops already in tree_forwarder_block_p.
 569      However it may happen that the infinite loop is created
 570      afterwards due to removal of forwarders.  */
 571   if (dest == bb)
 572     return;
 573
 574   /* If the destination block consists of a nonlocal label, do not
 575      merge it.  */
 576   label = first_stmt (dest);
 577   if (label
 578       && TREE_CODE (label) == LABEL_EXPR
 579       && DECL_NONLOCAL (LABEL_EXPR_LABEL (label)))
 580     return;
 581
 582   /* Redirect each incoming edge to BB to DEST.  */
 583   while (EDGE_COUNT (bb->preds) > 0)
 584     {
 585       edge e = EDGE_PRED (bb, 0), s;
 586       tree phi;
 587
 588       s = find_edge (e->src, dest);
 589       if (s)
 590         {
 591           /* We already have an edge S from E->src to DEST.  If S and
 592              E->dest's sole successor edge have the same PHI arguments
 593              at DEST, redirect S to DEST.  */
 594           if (phi_alternatives_equal (dest, s, succ))
 595             {
 596               e = redirect_edge_and_branch (e, dest);
 597               PENDING_STMT (e) = NULL_TREE;
 598               continue;
 599             }
 600
 601           /* PHI arguments are different.  Create a forwarder block by
 602              splitting E so that we can merge PHI arguments on E to
 603              DEST.  */
 604           e = single_succ_edge (split_edge (e));
 605         }
 606
 607       s = redirect_edge_and_branch (e, dest);
 608
 609       /* redirect_edge_and_branch must not create a new edge.  */
 610       gcc_assert (s == e);
 611
 612       /* Add to the PHI nodes at DEST each PHI argument removed at the
 613          destination of E.  */
 614       for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
 615         {
 616           tree def = PHI_ARG_DEF (phi, succ->dest_idx);
 617
 618           if (TREE_CODE (def) == SSA_NAME)
 619             {
 620               tree var;
 621
 622               /* If DEF is one of the results of PHI nodes removed during
 623                  redirection, replace it with the PHI argument that used
 624                  to be on E.  */
 625               for (var = PENDING_STMT (e); var; var = TREE_CHAIN (var))
 626                 {
 627                   tree old_arg = TREE_PURPOSE (var);
 628                   tree new_arg = TREE_VALUE (var);
 629
 630                   if (def == old_arg)
 631                     {
 632                       def = new_arg;
 633                       break;
 634                     }
 635                 }
 636             }
 637
 638           add_phi_arg (phi, def, s);
 639         }
 640
 641       PENDING_STMT (e) = NULL;
 642     }
 643
 644   /* Update the dominators.  */
 645   dombb = get_immediate_dominator (CDI_DOMINATORS, bb);
 646   domdest = get_immediate_dominator (CDI_DOMINATORS, dest);
 647   if (domdest == bb)
 648     {
 649       /* Shortcut to avoid calling (relatively expensive)
 650          nearest_common_dominator unless necessary.  */
 651       dom = dombb;
 652     }
 653   else
 654     dom = nearest_common_dominator (CDI_DOMINATORS, domdest, dombb);
 655
 656   set_immediate_dominator (CDI_DOMINATORS, dest, dom);
 657
 658   /* Remove BB since all of BB's incoming edges have been redirected
 659      to DEST.  */
 660   delete_basic_block (bb);
 661 }
 662
 663 /* This pass merges PHI nodes if one feeds into another.  For example,
 664    suppose we have the following:
 665
 666   goto <bb 9> (<L9>);
 667
 668 <L8>:;
 669   tem_17 = foo ();
 670
 671   # tem_6 = PHI <tem_17(8), tem_23(7)>;
 672 <L9>:;
 673
 674   # tem_3 = PHI <tem_6(9), tem_2(5)>;
 675 <L10>:;
 676
 677   Then we merge the first PHI node into the second one like so:
 678
 679   goto <bb 9> (<L10>);
 680
 681 <L8>:;
 682   tem_17 = foo ();
 683
 684   # tem_3 = PHI <tem_23(7), tem_2(5), tem_17(8)>;
 685 <L10>:;
 686 */
 687
 688 static void
 689 merge_phi_nodes (void)
 690 {
 691   basic_block *worklist = xmalloc (sizeof (basic_block) * n_basic_blocks);
 692   basic_block *current = worklist;
 693   basic_block bb;
 694
 695   calculate_dominance_info (CDI_DOMINATORS);
 696
 697   /* Find all PHI nodes that we may be able to merge.  */
 698   FOR_EACH_BB (bb)
 699     {
 700       basic_block dest;
 701
 702       /* Look for a forwarder block with PHI nodes.  */
 703       if (!tree_forwarder_block_p (bb, true))
 704         continue;
 705
 706       dest = single_succ (bb);
 707
 708       /* We have to feed into another basic block with PHI
 709          nodes.  */
 710       if (!phi_nodes (dest)
 711           /* We don't want to deal with a basic block with
 712              abnormal edges.  */
 713           || has_abnormal_incoming_edge_p (bb))
 714         continue;
 715
 716       if (!dominated_by_p (CDI_DOMINATORS, dest, bb))
 717         {
 718           /* If BB does not dominate DEST, then the PHI nodes at
 719              DEST must be the only users of the results of the PHI
 720              nodes at BB.  */
 721           *current++ = bb;
 722         }
 723     }
 724
 725   /* Now let's drain WORKLIST.  */
 726   while (current != worklist)
 727     {
 728       bb = *--current;
 729       remove_forwarder_block_with_phi (bb);
 730     }
 731
 732   free (worklist);
 733 }
 734
 735 static bool
 736 gate_merge_phi (void)
 737 {
 738   return 1;
 739 }
 740
 741 struct tree_opt_pass pass_merge_phi = {
 742   "mergephi",                   /* name */
 743   gate_merge_phi,               /* gate */
 744   merge_phi_nodes,              /* execute */
 745   NULL,                         /* sub */
 746   NULL,                         /* next */
 747   0,                            /* static_pass_number */
 748   TV_TREE_MERGE_PHI,            /* tv_id */
 749   PROP_cfg | PROP_ssa,          /* properties_required */
 750   0,                            /* properties_provided */
 751   0,                            /* properties_destroyed */
 752   0,                            /* todo_flags_start */
 753   TODO_dump_func | TODO_ggc_collect     /* todo_flags_finish */
 754   | TODO_verify_ssa,
 755   0                             /* letter */
 756 };