gcc/cfgbuild.c

   1 /* Control flow graph building code for GNU compiler.
   2    Copyright (C) 1987-2015 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 it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  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/>.  */
  19
  20 \f
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "backend.h"
  25 #include "cfghooks.h"
  26 #include "alias.h"
  27 #include "tree.h"
  28 #include "rtl.h"
  29 #include "cfgrtl.h"
  30 #include "cfganal.h"
  31 #include "cfgbuild.h"
  32 #include "regs.h"
  33 #include "flags.h"
  34 #include "except.h"
  35 #include "insn-config.h"
  36 #include "expmed.h"
  37 #include "dojump.h"
  38 #include "explow.h"
  39 #include "calls.h"
  40 #include "emit-rtl.h"
  41 #include "varasm.h"
  42 #include "stmt.h"
  43 #include "expr.h"
  44 #include "diagnostic-core.h"
  45 #include "timevar.h"
  46
  47 static void make_edges (basic_block, basic_block, int);
  48 static void make_label_edge (sbitmap, basic_block, rtx, int);
  49 static void find_bb_boundaries (basic_block);
  50 static void compute_outgoing_frequencies (basic_block);
  51 \f
  52 /* Return true if insn is something that should be contained inside basic
  53    block.  */
  54
  55 bool
  56 inside_basic_block_p (const rtx_insn *insn)
  57 {
  58   switch (GET_CODE (insn))
  59     {
  60     case CODE_LABEL:
  61       /* Avoid creating of basic block for jumptables.  */
  62       return (NEXT_INSN (insn) == 0
  63               || ! JUMP_TABLE_DATA_P (NEXT_INSN (insn)));
  64
  65     case JUMP_INSN:
  66     case CALL_INSN:
  67     case INSN:
  68     case DEBUG_INSN:
  69       return true;
  70
  71     case JUMP_TABLE_DATA:
  72     case BARRIER:
  73     case NOTE:
  74       return false;
  75
  76     default:
  77       gcc_unreachable ();
  78     }
  79 }
  80
  81 /* Return true if INSN may cause control flow transfer, so it should be last in
  82    the basic block.  */
  83
  84 bool
  85 control_flow_insn_p (const rtx_insn *insn)
  86 {
  87   switch (GET_CODE (insn))
  88     {
  89     case NOTE:
  90     case CODE_LABEL:
  91     case DEBUG_INSN:
  92       return false;
  93
  94     case JUMP_INSN:
  95       return true;
  96
  97     case CALL_INSN:
  98       /* Noreturn and sibling call instructions terminate the basic blocks
  99          (but only if they happen unconditionally).  */
 100       if ((SIBLING_CALL_P (insn)
 101            || find_reg_note (insn, REG_NORETURN, 0))
 102           && GET_CODE (PATTERN (insn)) != COND_EXEC)
 103         return true;
 104
 105       /* Call insn may return to the nonlocal goto handler.  */
 106       if (can_nonlocal_goto (insn))
 107         return true;
 108       break;
 109
 110     case INSN:
 111       /* Treat trap instructions like noreturn calls (same provision).  */
 112       if (GET_CODE (PATTERN (insn)) == TRAP_IF
 113           && XEXP (PATTERN (insn), 0) == const1_rtx)
 114         return true;
 115       if (!cfun->can_throw_non_call_exceptions)
 116         return false;
 117       break;
 118
 119     case JUMP_TABLE_DATA:
 120     case BARRIER:
 121       /* It is nonsense to reach this when looking for the
 122          end of basic block, but before dead code is eliminated
 123          this may happen.  */
 124       return false;
 125
 126     default:
 127       gcc_unreachable ();
 128     }
 129
 130   return can_throw_internal (insn);
 131 }
 132
 133 \f
 134 /* Create an edge between two basic blocks.  FLAGS are auxiliary information
 135    about the edge that is accumulated between calls.  */
 136
 137 /* Create an edge from a basic block to a label.  */
 138
 139 static void
 140 make_label_edge (sbitmap edge_cache, basic_block src, rtx label, int flags)
 141 {
 142   gcc_assert (LABEL_P (label));
 143
 144   /* If the label was never emitted, this insn is junk, but avoid a
 145      crash trying to refer to BLOCK_FOR_INSN (label).  This can happen
 146      as a result of a syntax error and a diagnostic has already been
 147      printed.  */
 148
 149   if (INSN_UID (label) == 0)
 150     return;
 151
 152   cached_make_edge (edge_cache, src, BLOCK_FOR_INSN (label), flags);
 153 }
 154
 155 /* Create the edges generated by INSN in REGION.  */
 156
 157 void
 158 rtl_make_eh_edge (sbitmap edge_cache, basic_block src, rtx insn)
 159 {
 160   eh_landing_pad lp = get_eh_landing_pad_from_rtx (insn);
 161
 162   if (lp)
 163     {
 164       rtx_insn *label = lp->landing_pad;
 165
 166       /* During initial rtl generation, use the post_landing_pad.  */
 167       if (label == NULL)
 168         {
 169           gcc_assert (lp->post_landing_pad);
 170           label = label_rtx (lp->post_landing_pad);
 171         }
 172
 173       make_label_edge (edge_cache, src, label,
 174                        EDGE_ABNORMAL | EDGE_EH
 175                        | (CALL_P (insn) ? EDGE_ABNORMAL_CALL : 0));
 176     }
 177 }
 178
 179 /* States of basic block as seen by find_many_sub_basic_blocks.  */
 180 enum state {
 181   /* Basic blocks created via split_block belong to this state.
 182      make_edges will examine these basic blocks to see if we need to
 183      create edges going out of them.  */
 184   BLOCK_NEW = 0,
 185
 186   /* Basic blocks that do not need examining belong to this state.
 187      These blocks will be left intact.  In particular, make_edges will
 188      not create edges going out of these basic blocks.  */
 189   BLOCK_ORIGINAL,
 190
 191   /* Basic blocks that may need splitting (due to a label appearing in
 192      the middle, etc) belong to this state.  After splitting them,
 193      make_edges will create edges going out of them as needed.  */
 194   BLOCK_TO_SPLIT
 195 };
 196
 197 #define STATE(BB) (enum state) ((size_t) (BB)->aux)
 198 #define SET_STATE(BB, STATE) ((BB)->aux = (void *) (size_t) (STATE))
 199
 200 /* Used internally by purge_dead_tablejump_edges, ORed into state.  */
 201 #define BLOCK_USED_BY_TABLEJUMP         32
 202 #define FULL_STATE(BB) ((size_t) (BB)->aux)
 203
 204 /* Identify the edges going out of basic blocks between MIN and MAX,
 205    inclusive, that have their states set to BLOCK_NEW or
 206    BLOCK_TO_SPLIT.
 207
 208    UPDATE_P should be nonzero if we are updating CFG and zero if we
 209    are building CFG from scratch.  */
 210
 211 static void
 212 make_edges (basic_block min, basic_block max, int update_p)
 213 {
 214   basic_block bb;
 215   sbitmap edge_cache = NULL;
 216
 217   /* Heavy use of computed goto in machine-generated code can lead to
 218      nearly fully-connected CFGs.  In that case we spend a significant
 219      amount of time searching the edge lists for duplicates.  */
 220   if (forced_labels || cfun->cfg->max_jumptable_ents > 100)
 221     edge_cache = sbitmap_alloc (last_basic_block_for_fn (cfun));
 222
 223   /* By nature of the way these get numbered, ENTRY_BLOCK_PTR->next_bb block
 224      is always the entry.  */
 225   if (min == ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb)
 226     make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), min, EDGE_FALLTHRU);
 227
 228   FOR_BB_BETWEEN (bb, min, max->next_bb, next_bb)
 229     {
 230       rtx_insn *insn;
 231       enum rtx_code code;
 232       edge e;
 233       edge_iterator ei;
 234
 235       if (STATE (bb) == BLOCK_ORIGINAL)
 236         continue;
 237
 238       /* If we have an edge cache, cache edges going out of BB.  */
 239       if (edge_cache)
 240         {
 241           bitmap_clear (edge_cache);
 242           if (update_p)
 243             {
 244               FOR_EACH_EDGE (e, ei, bb->succs)
 245                 if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
 246                   bitmap_set_bit (edge_cache, e->dest->index);
 247             }
 248         }
 249
 250       if (LABEL_P (BB_HEAD (bb))
 251           && LABEL_ALT_ENTRY_P (BB_HEAD (bb)))
 252         cached_make_edge (NULL, ENTRY_BLOCK_PTR_FOR_FN (cfun), bb, 0);
 253
 254       /* Examine the last instruction of the block, and discover the
 255          ways we can leave the block.  */
 256
 257       insn = BB_END (bb);
 258       code = GET_CODE (insn);
 259
 260       /* A branch.  */
 261       if (code == JUMP_INSN)
 262         {
 263           rtx tmp;
 264           rtx_jump_table_data *table;
 265
 266           /* Recognize a non-local goto as a branch outside the
 267              current function.  */
 268           if (find_reg_note (insn, REG_NON_LOCAL_GOTO, NULL_RTX))
 269             ;
 270
 271           /* Recognize a tablejump and do the right thing.  */
 272           else if (tablejump_p (insn, NULL, &table))
 273             {
 274               rtvec vec = table->get_labels ();
 275               int j;
 276
 277               for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j)
 278                 make_label_edge (edge_cache, bb,
 279                                  XEXP (RTVEC_ELT (vec, j), 0), 0);
 280
 281               /* Some targets (eg, ARM) emit a conditional jump that also
 282                  contains the out-of-range target.  Scan for these and
 283                  add an edge if necessary.  */
 284               if ((tmp = single_set (insn)) != NULL
 285                   && SET_DEST (tmp) == pc_rtx
 286                   && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
 287                   && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF)
 288                 make_label_edge (edge_cache, bb,
 289                                  LABEL_REF_LABEL (XEXP (SET_SRC (tmp), 2)), 0);
 290             }
 291
 292           /* If this is a computed jump, then mark it as reaching
 293              everything on the forced_labels list.  */
 294           else if (computed_jump_p (insn))
 295             {
 296               for (rtx_insn_list *x = forced_labels; x; x = x->next ())
 297                 make_label_edge (edge_cache, bb, x->insn (), EDGE_ABNORMAL);
 298             }
 299
 300           /* Returns create an exit out.  */
 301           else if (returnjump_p (insn))
 302             cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
 303
 304           /* Recognize asm goto and do the right thing.  */
 305           else if ((tmp = extract_asm_operands (PATTERN (insn))) != NULL)
 306             {
 307               int i, n = ASM_OPERANDS_LABEL_LENGTH (tmp);
 308               for (i = 0; i < n; ++i)
 309                 make_label_edge (edge_cache, bb,
 310                                  XEXP (ASM_OPERANDS_LABEL (tmp, i), 0), 0);
 311             }
 312
 313           /* Otherwise, we have a plain conditional or unconditional jump.  */
 314           else
 315             {
 316               gcc_assert (JUMP_LABEL (insn));
 317               make_label_edge (edge_cache, bb, JUMP_LABEL (insn), 0);
 318             }
 319         }
 320
 321       /* If this is a sibling call insn, then this is in effect a combined call
 322          and return, and so we need an edge to the exit block.  No need to
 323          worry about EH edges, since we wouldn't have created the sibling call
 324          in the first place.  */
 325       if (code == CALL_INSN && SIBLING_CALL_P (insn))
 326         cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR_FOR_FN (cfun),
 327                           EDGE_SIBCALL | EDGE_ABNORMAL);
 328
 329       /* If this is a CALL_INSN, then mark it as reaching the active EH
 330          handler for this CALL_INSN.  If we're handling non-call
 331          exceptions then any insn can reach any of the active handlers.
 332          Also mark the CALL_INSN as reaching any nonlocal goto handler.  */
 333       else if (code == CALL_INSN || cfun->can_throw_non_call_exceptions)
 334         {
 335           /* Add any appropriate EH edges.  */
 336           rtl_make_eh_edge (edge_cache, bb, insn);
 337
 338           if (code == CALL_INSN)
 339             {
 340               if (can_nonlocal_goto (insn))
 341                 {
 342                   /* ??? This could be made smarter: in some cases it's
 343                      possible to tell that certain calls will not do a
 344                      nonlocal goto.  For example, if the nested functions
 345                      that do the nonlocal gotos do not have their addresses
 346                      taken, then only calls to those functions or to other
 347                      nested functions that use them could possibly do
 348                      nonlocal gotos.  */
 349                   for (rtx_insn_list *x = nonlocal_goto_handler_labels;
 350                        x;
 351                        x = x->next ())
 352                     make_label_edge (edge_cache, bb, x->insn (),
 353                                      EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
 354                 }
 355
 356               if (flag_tm)
 357                 {
 358                   rtx note;
 359                   for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
 360                     if (REG_NOTE_KIND (note) == REG_TM)
 361                       make_label_edge (edge_cache, bb, XEXP (note, 0),
 362                                        EDGE_ABNORMAL | EDGE_ABNORMAL_CALL);
 363                 }
 364             }
 365         }
 366
 367       /* Find out if we can drop through to the next block.  */
 368       insn = NEXT_INSN (insn);
 369       e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
 370       if (e && e->flags & EDGE_FALLTHRU)
 371         insn = NULL;
 372
 373       while (insn
 374              && NOTE_P (insn)
 375              && NOTE_KIND (insn) != NOTE_INSN_BASIC_BLOCK)
 376         insn = NEXT_INSN (insn);
 377
 378       if (!insn)
 379         cached_make_edge (edge_cache, bb, EXIT_BLOCK_PTR_FOR_FN (cfun),
 380                           EDGE_FALLTHRU);
 381       else if (bb->next_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
 382         {
 383           if (insn == BB_HEAD (bb->next_bb))
 384             cached_make_edge (edge_cache, bb, bb->next_bb, EDGE_FALLTHRU);
 385         }
 386     }
 387
 388   if (edge_cache)
 389     sbitmap_free (edge_cache);
 390 }
 391 \f
 392 static void
 393 mark_tablejump_edge (rtx label)
 394 {
 395   basic_block bb;
 396
 397   gcc_assert (LABEL_P (label));
 398   /* See comment in make_label_edge.  */
 399   if (INSN_UID (label) == 0)
 400     return;
 401   bb = BLOCK_FOR_INSN (label);
 402   SET_STATE (bb, FULL_STATE (bb) | BLOCK_USED_BY_TABLEJUMP);
 403 }
 404
 405 static void
 406 purge_dead_tablejump_edges (basic_block bb, rtx_jump_table_data *table)
 407 {
 408   rtx_insn *insn = BB_END (bb);
 409   rtx tmp;
 410   rtvec vec;
 411   int j;
 412   edge_iterator ei;
 413   edge e;
 414
 415   vec = table->get_labels ();
 416
 417   for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j)
 418     mark_tablejump_edge (XEXP (RTVEC_ELT (vec, j), 0));
 419
 420   /* Some targets (eg, ARM) emit a conditional jump that also
 421      contains the out-of-range target.  Scan for these and
 422      add an edge if necessary.  */
 423   if ((tmp = single_set (insn)) != NULL
 424        && SET_DEST (tmp) == pc_rtx
 425        && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
 426        && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF)
 427     mark_tablejump_edge (LABEL_REF_LABEL (XEXP (SET_SRC (tmp), 2)));
 428
 429   for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
 430     {
 431       if (FULL_STATE (e->dest) & BLOCK_USED_BY_TABLEJUMP)
 432         SET_STATE (e->dest, FULL_STATE (e->dest)
 433                             & ~(size_t) BLOCK_USED_BY_TABLEJUMP);
 434       else if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
 435         {
 436           remove_edge (e);
 437           continue;
 438         }
 439       ei_next (&ei);
 440     }
 441 }
 442
 443 /* Scan basic block BB for possible BB boundaries inside the block
 444    and create new basic blocks in the progress.  */
 445
 446 static void
 447 find_bb_boundaries (basic_block bb)
 448 {
 449   basic_block orig_bb = bb;
 450   rtx_insn *insn = BB_HEAD (bb);
 451   rtx_insn *end = BB_END (bb), *x;
 452   rtx_jump_table_data *table;
 453   rtx_insn *flow_transfer_insn = NULL;
 454   edge fallthru = NULL;
 455
 456   if (insn == BB_END (bb))
 457     return;
 458
 459   if (LABEL_P (insn))
 460     insn = NEXT_INSN (insn);
 461
 462   /* Scan insn chain and try to find new basic block boundaries.  */
 463   while (1)
 464     {
 465       enum rtx_code code = GET_CODE (insn);
 466
 467       /* In case we've previously seen an insn that effects a control
 468          flow transfer, split the block.  */
 469       if ((flow_transfer_insn || code == CODE_LABEL)
 470           && inside_basic_block_p (insn))
 471         {
 472           fallthru = split_block (bb, PREV_INSN (insn));
 473           if (flow_transfer_insn)
 474             {
 475               BB_END (bb) = flow_transfer_insn;
 476
 477               /* Clean up the bb field for the insns between the blocks.  */
 478               for (x = NEXT_INSN (flow_transfer_insn);
 479                    x != BB_HEAD (fallthru->dest);
 480                    x = NEXT_INSN (x))
 481                 if (!BARRIER_P (x))
 482                   set_block_for_insn (x, NULL);
 483             }
 484
 485           bb = fallthru->dest;
 486           remove_edge (fallthru);
 487           flow_transfer_insn = NULL;
 488           if (code == CODE_LABEL && LABEL_ALT_ENTRY_P (insn))
 489             make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), bb, 0);
 490         }
 491       else if (code == BARRIER)
 492         {
 493           /* __builtin_unreachable () may cause a barrier to be emitted in
 494              the middle of a BB.  We need to split it in the same manner as
 495              if the barrier were preceded by a control_flow_insn_p insn.  */
 496           if (!flow_transfer_insn)
 497             flow_transfer_insn = prev_nonnote_insn_bb (insn);
 498         }
 499
 500       if (control_flow_insn_p (insn))
 501         flow_transfer_insn = insn;
 502       if (insn == end)
 503         break;
 504       insn = NEXT_INSN (insn);
 505     }
 506
 507   /* In case expander replaced normal insn by sequence terminating by
 508      return and barrier, or possibly other sequence not behaving like
 509      ordinary jump, we need to take care and move basic block boundary.  */
 510   if (flow_transfer_insn)
 511     {
 512       BB_END (bb) = flow_transfer_insn;
 513
 514       /* Clean up the bb field for the insns that do not belong to BB.  */
 515       x = flow_transfer_insn;
 516       while (x != end)
 517         {
 518           x = NEXT_INSN (x);
 519           if (!BARRIER_P (x))
 520             set_block_for_insn (x, NULL);
 521         }
 522     }
 523
 524   /* We've possibly replaced the conditional jump by conditional jump
 525      followed by cleanup at fallthru edge, so the outgoing edges may
 526      be dead.  */
 527   purge_dead_edges (bb);
 528
 529   /* purge_dead_edges doesn't handle tablejump's, but if we have split the
 530      basic block, we might need to kill some edges.  */
 531   if (bb != orig_bb && tablejump_p (BB_END (bb), NULL, &table))
 532     purge_dead_tablejump_edges (bb, table);
 533 }
 534
 535 /*  Assume that frequency of basic block B is known.  Compute frequencies
 536     and probabilities of outgoing edges.  */
 537
 538 static void
 539 compute_outgoing_frequencies (basic_block b)
 540 {
 541   edge e, f;
 542   edge_iterator ei;
 543
 544   if (EDGE_COUNT (b->succs) == 2)
 545     {
 546       rtx note = find_reg_note (BB_END (b), REG_BR_PROB, NULL);
 547       int probability;
 548
 549       if (note)
 550         {
 551           probability = XINT (note, 0);
 552           e = BRANCH_EDGE (b);
 553           e->probability = probability;
 554           e->count = apply_probability (b->count, probability);
 555           f = FALLTHRU_EDGE (b);
 556           f->probability = REG_BR_PROB_BASE - probability;
 557           f->count = b->count - e->count;
 558           return;
 559         }
 560       else
 561         {
 562           guess_outgoing_edge_probabilities (b);
 563         }
 564     }
 565   else if (single_succ_p (b))
 566     {
 567       e = single_succ_edge (b);
 568       e->probability = REG_BR_PROB_BASE;
 569       e->count = b->count;
 570       return;
 571     }
 572   else
 573     {
 574       /* We rely on BBs with more than two successors to have sane probabilities
 575          and do not guess them here. For BBs terminated by switch statements
 576          expanded to jump-table jump, we have done the right thing during
 577          expansion. For EH edges, we still guess the probabilities here.  */
 578       bool complex_edge = false;
 579       FOR_EACH_EDGE (e, ei, b->succs)
 580         if (e->flags & EDGE_COMPLEX)
 581           {
 582             complex_edge = true;
 583             break;
 584           }
 585       if (complex_edge)
 586         guess_outgoing_edge_probabilities (b);
 587     }
 588
 589   if (b->count)
 590     FOR_EACH_EDGE (e, ei, b->succs)
 591       e->count = apply_probability (b->count, e->probability);
 592 }
 593
 594 /* Assume that some pass has inserted labels or control flow
 595    instructions within a basic block.  Split basic blocks as needed
 596    and create edges.  */
 597
 598 void
 599 find_many_sub_basic_blocks (sbitmap blocks)
 600 {
 601   basic_block bb, min, max;
 602
 603   FOR_EACH_BB_FN (bb, cfun)
 604     SET_STATE (bb,
 605                bitmap_bit_p (blocks, bb->index) ? BLOCK_TO_SPLIT : BLOCK_ORIGINAL);
 606
 607   FOR_EACH_BB_FN (bb, cfun)
 608     if (STATE (bb) == BLOCK_TO_SPLIT)
 609       find_bb_boundaries (bb);
 610
 611   FOR_EACH_BB_FN (bb, cfun)
 612     if (STATE (bb) != BLOCK_ORIGINAL)
 613       break;
 614
 615   min = max = bb;
 616   for (; bb != EXIT_BLOCK_PTR_FOR_FN (cfun); bb = bb->next_bb)
 617     if (STATE (bb) != BLOCK_ORIGINAL)
 618       max = bb;
 619
 620   /* Now re-scan and wire in all edges.  This expect simple (conditional)
 621      jumps at the end of each new basic blocks.  */
 622   make_edges (min, max, 1);
 623
 624   /* Update branch probabilities.  Expect only (un)conditional jumps
 625      to be created with only the forward edges.  */
 626   if (profile_status_for_fn (cfun) != PROFILE_ABSENT)
 627     FOR_BB_BETWEEN (bb, min, max->next_bb, next_bb)
 628       {
 629         edge e;
 630         edge_iterator ei;
 631
 632         if (STATE (bb) == BLOCK_ORIGINAL)
 633           continue;
 634         if (STATE (bb) == BLOCK_NEW)
 635           {
 636             bb->count = 0;
 637             bb->frequency = 0;
 638             FOR_EACH_EDGE (e, ei, bb->preds)
 639               {
 640                 bb->count += e->count;
 641                 bb->frequency += EDGE_FREQUENCY (e);
 642               }
 643           }
 644
 645         compute_outgoing_frequencies (bb);
 646       }
 647
 648   FOR_EACH_BB_FN (bb, cfun)
 649     SET_STATE (bb, 0);
 650 }