gcc/cfgbuild.c

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