gcc/cfg.c

   1 /* Control flow graph manipulation code for GNU compiler.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /* This file contains low level functions to manipulate the CFG and
  23    analyze it.  All other modules should not transform the data structure
  24    directly and use abstraction instead.  The file is supposed to be
  25    ordered bottom-up and should not contain any code dependent on a
  26    particular intermediate language (RTL or trees).
  27
  28    Available functionality:
  29      - Initialization/deallocation
  30          init_flow, clear_edges
  31      - Low level basic block manipulation
  32          alloc_block, expunge_block
  33      - Edge manipulation
  34          make_edge, make_single_succ_edge, cached_make_edge, remove_edge
  35          - Low level edge redirection (without updating instruction chain)
  36              redirect_edge_succ, redirect_edge_succ_nodup, redirect_edge_pred
  37      - Dumping and debugging
  38          dump_flow_info, debug_flow_info, dump_edge_info
  39      - Allocation of AUX fields for basic blocks
  40          alloc_aux_for_blocks, free_aux_for_blocks, alloc_aux_for_block
  41      - clear_bb_flags
  42      - Consistency checking
  43          verify_flow_info
  44      - Dumping and debugging
  45          print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
  46  */
  47 \f
  48 #include "config.h"
  49 #include "system.h"
  50 #include "coretypes.h"
  51 #include "tm.h"
  52 #include "tree.h"
  53 #include "rtl.h"
  54 #include "hard-reg-set.h"
  55 #include "basic-block.h"
  56 #include "regs.h"
  57 #include "flags.h"
  58 #include "output.h"
  59 #include "function.h"
  60 #include "except.h"
  61 #include "toplev.h"
  62 #include "tm_p.h"
  63 #include "obstack.h"
  64 #include "alloc-pool.h"
  65 #include "timevar.h"
  66 #include "ggc.h"
  67
  68 /* The obstack on which the flow graph components are allocated.  */
  69
  70 struct obstack flow_obstack;
  71 static char *flow_firstobj;
  72
  73 /* Number of basic blocks in the current function.  */
  74
  75 int n_basic_blocks;
  76
  77 /* First free basic block number.  */
  78
  79 int last_basic_block;
  80
  81 /* Number of edges in the current function.  */
  82
  83 int n_edges;
  84
  85 /* The basic block array.  */
  86
  87 varray_type basic_block_info;
  88
  89 /* The special entry and exit blocks.  */
  90 basic_block ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR;
  91
  92 /* Memory alloc pool for bb member rbi.  */
  93 alloc_pool rbi_pool;
  94
  95 void debug_flow_info (void);
  96 static void free_edge (edge);
  97
  98 /* Indicate the presence of the profile.  */
  99 enum profile_status profile_status;
 100 \f
 101 /* Called once at initialization time.  */
 102
 103 void
 104 init_flow (void)
 105 {
 106   static int initialized;
 107
 108   n_edges = 0;
 109
 110   if (!initialized)
 111     {
 112       gcc_obstack_init (&flow_obstack);
 113       flow_firstobj = obstack_alloc (&flow_obstack, 0);
 114       initialized = 1;
 115     }
 116   else
 117     {
 118       obstack_free (&flow_obstack, flow_firstobj);
 119       flow_firstobj = obstack_alloc (&flow_obstack, 0);
 120     }
 121
 122   ENTRY_BLOCK_PTR = ggc_alloc_cleared (sizeof (*ENTRY_BLOCK_PTR));
 123   ENTRY_BLOCK_PTR->index = ENTRY_BLOCK;
 124   EXIT_BLOCK_PTR = ggc_alloc_cleared (sizeof (*EXIT_BLOCK_PTR));
 125   EXIT_BLOCK_PTR->index = EXIT_BLOCK;
 126   ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
 127   EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
 128 }
 129 \f
 130 /* Helper function for remove_edge and clear_edges.  Frees edge structure
 131    without actually unlinking it from the pred/succ lists.  */
 132
 133 static void
 134 free_edge (edge e ATTRIBUTE_UNUSED)
 135 {
 136   n_edges--;
 137   /* ggc_free (e);  */
 138 }
 139
 140 /* Free the memory associated with the edge structures.  */
 141
 142 void
 143 clear_edges (void)
 144 {
 145   basic_block bb;
 146   edge e;
 147
 148   FOR_EACH_BB (bb)
 149     {
 150       edge e = bb->succ;
 151
 152       while (e)
 153         {
 154           edge next = e->succ_next;
 155
 156           free_edge (e);
 157           e = next;
 158         }
 159
 160       bb->succ = NULL;
 161       bb->pred = NULL;
 162     }
 163
 164   e = ENTRY_BLOCK_PTR->succ;
 165   while (e)
 166     {
 167       edge next = e->succ_next;
 168
 169       free_edge (e);
 170       e = next;
 171     }
 172
 173   EXIT_BLOCK_PTR->pred = NULL;
 174   ENTRY_BLOCK_PTR->succ = NULL;
 175
 176   if (n_edges)
 177     abort ();
 178 }
 179 \f
 180 /* Allocate memory for basic_block.  */
 181
 182 basic_block
 183 alloc_block (void)
 184 {
 185   basic_block bb;
 186   bb = ggc_alloc_cleared (sizeof (*bb));
 187   return bb;
 188 }
 189
 190 /* Create memory pool for rbi_pool.  */
 191
 192 void
 193 alloc_rbi_pool (void)
 194 {
 195   rbi_pool = create_alloc_pool ("rbi pool",
 196                                 sizeof (struct reorder_block_def),
 197                                 n_basic_blocks + 2);
 198 }
 199
 200 /* Free rbi_pool.  */
 201
 202 void
 203 free_rbi_pool (void)
 204 {
 205   free_alloc_pool (rbi_pool);
 206 }
 207
 208 /* Initialize rbi (the structure containing data used by basic block
 209    duplication and reordering) for the given basic block.  */
 210
 211 void
 212 initialize_bb_rbi (basic_block bb)
 213 {
 214   if (bb->rbi)
 215     abort ();
 216   bb->rbi = pool_alloc (rbi_pool);
 217   memset (bb->rbi, 0, sizeof (struct reorder_block_def));
 218 }
 219
 220 /* Link block B to chain after AFTER.  */
 221 void
 222 link_block (basic_block b, basic_block after)
 223 {
 224   b->next_bb = after->next_bb;
 225   b->prev_bb = after;
 226   after->next_bb = b;
 227   b->next_bb->prev_bb = b;
 228 }
 229
 230 /* Unlink block B from chain.  */
 231 void
 232 unlink_block (basic_block b)
 233 {
 234   b->next_bb->prev_bb = b->prev_bb;
 235   b->prev_bb->next_bb = b->next_bb;
 236   b->prev_bb = NULL;
 237   b->next_bb = NULL;
 238 }
 239
 240 /* Sequentially order blocks and compact the arrays.  */
 241 void
 242 compact_blocks (void)
 243 {
 244   int i;
 245   basic_block bb;
 246
 247   i = 0;
 248   FOR_EACH_BB (bb)
 249     {
 250       BASIC_BLOCK (i) = bb;
 251       bb->index = i;
 252       i++;
 253     }
 254
 255   if (i != n_basic_blocks)
 256     abort ();
 257
 258   for (; i < last_basic_block; i++)
 259     BASIC_BLOCK (i) = NULL;
 260
 261   last_basic_block = n_basic_blocks;
 262 }
 263
 264 /* Remove block B from the basic block array.  */
 265
 266 void
 267 expunge_block (basic_block b)
 268 {
 269   unlink_block (b);
 270   BASIC_BLOCK (b->index) = NULL;
 271   n_basic_blocks--;
 272   /* ggc_free (b); */
 273 }
 274 \f
 275 /* Create an edge connecting SRC and DEST with flags FLAGS.  Return newly
 276    created edge.  Use this only if you are sure that this edge can't
 277    possibly already exist.  */
 278
 279 edge
 280 unchecked_make_edge (basic_block src, basic_block dst, int flags)
 281 {
 282   edge e;
 283   e = ggc_alloc_cleared (sizeof (*e));
 284   n_edges++;
 285
 286   e->succ_next = src->succ;
 287   e->pred_next = dst->pred;
 288   e->src = src;
 289   e->dest = dst;
 290   e->flags = flags;
 291
 292   src->succ = e;
 293   dst->pred = e;
 294
 295   return e;
 296 }
 297
 298 /* Create an edge connecting SRC and DST with FLAGS optionally using
 299    edge cache CACHE.  Return the new edge, NULL if already exist.  */
 300
 301 edge
 302 cached_make_edge (sbitmap *edge_cache, basic_block src, basic_block dst, int flags)
 303 {
 304   int use_edge_cache;
 305   edge e;
 306
 307   /* Don't bother with edge cache for ENTRY or EXIT, if there aren't that
 308      many edges to them, or we didn't allocate memory for it.  */
 309   use_edge_cache = (edge_cache
 310                     && src != ENTRY_BLOCK_PTR && dst != EXIT_BLOCK_PTR);
 311
 312   /* Make sure we don't add duplicate edges.  */
 313   switch (use_edge_cache)
 314     {
 315     default:
 316       /* Quick test for non-existence of the edge.  */
 317       if (! TEST_BIT (edge_cache[src->index], dst->index))
 318         break;
 319
 320       /* The edge exists; early exit if no work to do.  */
 321       if (flags == 0)
 322         return NULL;
 323
 324       /* Fall through.  */
 325     case 0:
 326       for (e = src->succ; e; e = e->succ_next)
 327         if (e->dest == dst)
 328           {
 329             e->flags |= flags;
 330             return NULL;
 331           }
 332       break;
 333     }
 334
 335   e = unchecked_make_edge (src, dst, flags);
 336
 337   if (use_edge_cache)
 338     SET_BIT (edge_cache[src->index], dst->index);
 339
 340   return e;
 341 }
 342
 343 /* Create an edge connecting SRC and DEST with flags FLAGS.  Return newly
 344    created edge or NULL if already exist.  */
 345
 346 edge
 347 make_edge (basic_block src, basic_block dest, int flags)
 348 {
 349   return cached_make_edge (NULL, src, dest, flags);
 350 }
 351
 352 /* Create an edge connecting SRC to DEST and set probability by knowing
 353    that it is the single edge leaving SRC.  */
 354
 355 edge
 356 make_single_succ_edge (basic_block src, basic_block dest, int flags)
 357 {
 358   edge e = make_edge (src, dest, flags);
 359
 360   e->probability = REG_BR_PROB_BASE;
 361   e->count = src->count;
 362   return e;
 363 }
 364
 365 /* This function will remove an edge from the flow graph.  */
 366
 367 void
 368 remove_edge (edge e)
 369 {
 370   edge last_pred = NULL;
 371   edge last_succ = NULL;
 372   edge tmp;
 373   basic_block src, dest;
 374
 375   src = e->src;
 376   dest = e->dest;
 377   for (tmp = src->succ; tmp && tmp != e; tmp = tmp->succ_next)
 378     last_succ = tmp;
 379
 380   if (!tmp)
 381     abort ();
 382   if (last_succ)
 383     last_succ->succ_next = e->succ_next;
 384   else
 385     src->succ = e->succ_next;
 386
 387   for (tmp = dest->pred; tmp && tmp != e; tmp = tmp->pred_next)
 388     last_pred = tmp;
 389
 390   if (!tmp)
 391     abort ();
 392   if (last_pred)
 393     last_pred->pred_next = e->pred_next;
 394   else
 395     dest->pred = e->pred_next;
 396
 397   free_edge (e);
 398 }
 399
 400 /* Redirect an edge's successor from one block to another.  */
 401
 402 void
 403 redirect_edge_succ (edge e, basic_block new_succ)
 404 {
 405   edge *pe;
 406
 407   /* Disconnect the edge from the old successor block.  */
 408   for (pe = &e->dest->pred; *pe != e; pe = &(*pe)->pred_next)
 409     continue;
 410   *pe = (*pe)->pred_next;
 411
 412   /* Reconnect the edge to the new successor block.  */
 413   e->pred_next = new_succ->pred;
 414   new_succ->pred = e;
 415   e->dest = new_succ;
 416 }
 417
 418 /* Like previous but avoid possible duplicate edge.  */
 419
 420 edge
 421 redirect_edge_succ_nodup (edge e, basic_block new_succ)
 422 {
 423   edge s;
 424
 425   /* Check whether the edge is already present.  */
 426   for (s = e->src->succ; s; s = s->succ_next)
 427     if (s->dest == new_succ && s != e)
 428       break;
 429
 430   if (s)
 431     {
 432       s->flags |= e->flags;
 433       s->probability += e->probability;
 434       if (s->probability > REG_BR_PROB_BASE)
 435         s->probability = REG_BR_PROB_BASE;
 436       s->count += e->count;
 437       remove_edge (e);
 438       e = s;
 439     }
 440   else
 441     redirect_edge_succ (e, new_succ);
 442
 443   return e;
 444 }
 445
 446 /* Redirect an edge's predecessor from one block to another.  */
 447
 448 void
 449 redirect_edge_pred (edge e, basic_block new_pred)
 450 {
 451   edge *pe;
 452
 453   /* Disconnect the edge from the old predecessor block.  */
 454   for (pe = &e->src->succ; *pe != e; pe = &(*pe)->succ_next)
 455     continue;
 456
 457   *pe = (*pe)->succ_next;
 458
 459   /* Reconnect the edge to the new predecessor block.  */
 460   e->succ_next = new_pred->succ;
 461   new_pred->succ = e;
 462   e->src = new_pred;
 463 }
 464
 465 /* Clear all basic block flags, with the exception of partitioning.  */
 466 void
 467 clear_bb_flags (void)
 468 {
 469   basic_block bb;
 470
 471   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 472     bb->flags = BB_PARTITION (bb);
 473 }
 474 \f
 475 /* Check the consistency of profile information.  We can't do that
 476    in verify_flow_info, as the counts may get invalid for incompletely
 477    solved graphs, later eliminating of conditionals or roundoff errors.
 478    It is still practical to have them reported for debugging of simple
 479    testcases.  */
 480 void
 481 check_bb_profile (basic_block bb, FILE * file)
 482 {
 483   edge e;
 484   int sum = 0;
 485   gcov_type lsum;
 486
 487   if (profile_status == PROFILE_ABSENT)
 488     return;
 489
 490   if (bb != EXIT_BLOCK_PTR)
 491     {
 492       for (e = bb->succ; e; e = e->succ_next)
 493         sum += e->probability;
 494       if (bb->succ && abs (sum - REG_BR_PROB_BASE) > 100)
 495         fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
 496                  sum * 100.0 / REG_BR_PROB_BASE);
 497       lsum = 0;
 498       for (e = bb->succ; e; e = e->succ_next)
 499         lsum += e->count;
 500       if (bb->succ && (lsum - bb->count > 100 || lsum - bb->count < -100))
 501         fprintf (file, "Invalid sum of outgoing counts %i, should be %i\n",
 502                  (int) lsum, (int) bb->count);
 503     }
 504   if (bb != ENTRY_BLOCK_PTR)
 505     {
 506       sum = 0;
 507       for (e = bb->pred; e; e = e->pred_next)
 508         sum += EDGE_FREQUENCY (e);
 509       if (abs (sum - bb->frequency) > 100)
 510         fprintf (file,
 511                  "Invalid sum of incoming frequencies %i, should be %i\n",
 512                  sum, bb->frequency);
 513       lsum = 0;
 514       for (e = bb->pred; e; e = e->pred_next)
 515         lsum += e->count;
 516       if (lsum - bb->count > 100 || lsum - bb->count < -100)
 517         fprintf (file, "Invalid sum of incoming counts %i, should be %i\n",
 518                  (int) lsum, (int) bb->count);
 519     }
 520 }
 521 \f
 522 void
 523 dump_flow_info (FILE *file)
 524 {
 525   int i;
 526   basic_block bb;
 527   static const char * const reg_class_names[] = REG_CLASS_NAMES;
 528
 529   if (reg_n_info)
 530     {
 531       int max_regno = max_reg_num ();
 532       fprintf (file, "%d registers.\n", max_regno);
 533       for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
 534         if (REG_N_REFS (i))
 535           {
 536             enum reg_class class, altclass;
 537
 538             fprintf (file, "\nRegister %d used %d times across %d insns",
 539                      i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
 540             if (REG_BASIC_BLOCK (i) >= 0)
 541               fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
 542             if (REG_N_SETS (i))
 543               fprintf (file, "; set %d time%s", REG_N_SETS (i),
 544                        (REG_N_SETS (i) == 1) ? "" : "s");
 545             if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
 546               fprintf (file, "; user var");
 547             if (REG_N_DEATHS (i) != 1)
 548               fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
 549             if (REG_N_CALLS_CROSSED (i) == 1)
 550               fprintf (file, "; crosses 1 call");
 551             else if (REG_N_CALLS_CROSSED (i))
 552               fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
 553             if (regno_reg_rtx[i] != NULL
 554                 && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
 555               fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
 556
 557             class = reg_preferred_class (i);
 558             altclass = reg_alternate_class (i);
 559             if (class != GENERAL_REGS || altclass != ALL_REGS)
 560               {
 561                 if (altclass == ALL_REGS || class == ALL_REGS)
 562                   fprintf (file, "; pref %s", reg_class_names[(int) class]);
 563                 else if (altclass == NO_REGS)
 564                   fprintf (file, "; %s or none", reg_class_names[(int) class]);
 565                 else
 566                   fprintf (file, "; pref %s, else %s",
 567                            reg_class_names[(int) class],
 568                            reg_class_names[(int) altclass]);
 569               }
 570
 571             if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
 572               fprintf (file, "; pointer");
 573             fprintf (file, ".\n");
 574           }
 575     }
 576
 577   fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
 578   FOR_EACH_BB (bb)
 579     {
 580       edge e;
 581
 582       fprintf (file, "\nBasic block %d ", bb->index);
 583       fprintf (file, "prev %d, next %d, ",
 584                bb->prev_bb->index, bb->next_bb->index);
 585       fprintf (file, "loop_depth %d, count ", bb->loop_depth);
 586       fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
 587       fprintf (file, ", freq %i", bb->frequency);
 588       if (maybe_hot_bb_p (bb))
 589         fprintf (file, ", maybe hot");
 590       if (probably_never_executed_bb_p (bb))
 591         fprintf (file, ", probably never executed");
 592       fprintf (file, ".\n");
 593
 594       fprintf (file, "Predecessors: ");
 595       for (e = bb->pred; e; e = e->pred_next)
 596         dump_edge_info (file, e, 0);
 597
 598       fprintf (file, "\nSuccessors: ");
 599       for (e = bb->succ; e; e = e->succ_next)
 600         dump_edge_info (file, e, 1);
 601
 602       fprintf (file, "\nRegisters live at start:");
 603       dump_regset (bb->global_live_at_start, file);
 604
 605       fprintf (file, "\nRegisters live at end:");
 606       dump_regset (bb->global_live_at_end, file);
 607
 608       putc ('\n', file);
 609
 610       if (bb->global_live_at_start)
 611         {
 612           fprintf (file, "\nRegisters live at start:");
 613           dump_regset (bb->global_live_at_start, file);
 614         }
 615
 616       if (bb->global_live_at_end)
 617         {
 618           fprintf (file, "\nRegisters live at end:");
 619           dump_regset (bb->global_live_at_end, file);
 620         }
 621
 622       putc ('\n', file);
 623       check_bb_profile (bb, file);
 624     }
 625
 626   putc ('\n', file);
 627 }
 628
 629 void
 630 debug_flow_info (void)
 631 {
 632   dump_flow_info (stderr);
 633 }
 634
 635 void
 636 dump_edge_info (FILE *file, edge e, int do_succ)
 637 {
 638   basic_block side = (do_succ ? e->dest : e->src);
 639
 640   if (side == ENTRY_BLOCK_PTR)
 641     fputs (" ENTRY", file);
 642   else if (side == EXIT_BLOCK_PTR)
 643     fputs (" EXIT", file);
 644   else
 645     fprintf (file, " %d", side->index);
 646
 647   if (e->probability)
 648     fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
 649
 650   if (e->count)
 651     {
 652       fprintf (file, " count:");
 653       fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
 654     }
 655
 656   if (e->flags)
 657     {
 658       static const char * const bitnames[] = {
 659         "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
 660         "can_fallthru", "irreducible", "sibcall", "loop_exit",
 661         "true", "false", "exec"
 662       };
 663       int comma = 0;
 664       int i, flags = e->flags;
 665
 666       fputs (" (", file);
 667       for (i = 0; flags; i++)
 668         if (flags & (1 << i))
 669           {
 670             flags &= ~(1 << i);
 671
 672             if (comma)
 673               fputc (',', file);
 674             if (i < (int) ARRAY_SIZE (bitnames))
 675               fputs (bitnames[i], file);
 676             else
 677               fprintf (file, "%d", i);
 678             comma = 1;
 679           }
 680
 681       fputc (')', file);
 682     }
 683 }
 684 \f
 685 /* Simple routines to easily allocate AUX fields of basic blocks.  */
 686
 687 static struct obstack block_aux_obstack;
 688 static void *first_block_aux_obj = 0;
 689 static struct obstack edge_aux_obstack;
 690 static void *first_edge_aux_obj = 0;
 691
 692 /* Allocate a memory block of SIZE as BB->aux.  The obstack must
 693    be first initialized by alloc_aux_for_blocks.  */
 694
 695 inline void
 696 alloc_aux_for_block (basic_block bb, int size)
 697 {
 698   /* Verify that aux field is clear.  */
 699   if (bb->aux || !first_block_aux_obj)
 700     abort ();
 701   bb->aux = obstack_alloc (&block_aux_obstack, size);
 702   memset (bb->aux, 0, size);
 703 }
 704
 705 /* Initialize the block_aux_obstack and if SIZE is nonzero, call
 706    alloc_aux_for_block for each basic block.  */
 707
 708 void
 709 alloc_aux_for_blocks (int size)
 710 {
 711   static int initialized;
 712
 713   if (!initialized)
 714     {
 715       gcc_obstack_init (&block_aux_obstack);
 716       initialized = 1;
 717     }
 718
 719   /* Check whether AUX data are still allocated.  */
 720   else if (first_block_aux_obj)
 721     abort ();
 722   first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
 723   if (size)
 724     {
 725       basic_block bb;
 726
 727       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 728         alloc_aux_for_block (bb, size);
 729     }
 730 }
 731
 732 /* Clear AUX pointers of all blocks.  */
 733
 734 void
 735 clear_aux_for_blocks (void)
 736 {
 737   basic_block bb;
 738
 739   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 740     bb->aux = NULL;
 741 }
 742
 743 /* Free data allocated in block_aux_obstack and clear AUX pointers
 744    of all blocks.  */
 745
 746 void
 747 free_aux_for_blocks (void)
 748 {
 749   if (!first_block_aux_obj)
 750     abort ();
 751   obstack_free (&block_aux_obstack, first_block_aux_obj);
 752   first_block_aux_obj = NULL;
 753
 754   clear_aux_for_blocks ();
 755 }
 756
 757 /* Allocate a memory edge of SIZE as BB->aux.  The obstack must
 758    be first initialized by alloc_aux_for_edges.  */
 759
 760 inline void
 761 alloc_aux_for_edge (edge e, int size)
 762 {
 763   /* Verify that aux field is clear.  */
 764   if (e->aux || !first_edge_aux_obj)
 765     abort ();
 766   e->aux = obstack_alloc (&edge_aux_obstack, size);
 767   memset (e->aux, 0, size);
 768 }
 769
 770 /* Initialize the edge_aux_obstack and if SIZE is nonzero, call
 771    alloc_aux_for_edge for each basic edge.  */
 772
 773 void
 774 alloc_aux_for_edges (int size)
 775 {
 776   static int initialized;
 777
 778   if (!initialized)
 779     {
 780       gcc_obstack_init (&edge_aux_obstack);
 781       initialized = 1;
 782     }
 783
 784   /* Check whether AUX data are still allocated.  */
 785   else if (first_edge_aux_obj)
 786     abort ();
 787
 788   first_edge_aux_obj = obstack_alloc (&edge_aux_obstack, 0);
 789   if (size)
 790     {
 791       basic_block bb;
 792
 793       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
 794         {
 795           edge e;
 796
 797           for (e = bb->succ; e; e = e->succ_next)
 798             alloc_aux_for_edge (e, size);
 799         }
 800     }
 801 }
 802
 803 /* Clear AUX pointers of all edges.  */
 804
 805 void
 806 clear_aux_for_edges (void)
 807 {
 808   basic_block bb;
 809   edge e;
 810
 811   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
 812     {
 813       for (e = bb->succ; e; e = e->succ_next)
 814         e->aux = NULL;
 815     }
 816 }
 817
 818 /* Free data allocated in edge_aux_obstack and clear AUX pointers
 819    of all edges.  */
 820
 821 void
 822 free_aux_for_edges (void)
 823 {
 824   if (!first_edge_aux_obj)
 825     abort ();
 826   obstack_free (&edge_aux_obstack, first_edge_aux_obj);
 827   first_edge_aux_obj = NULL;
 828
 829   clear_aux_for_edges ();
 830 }
 831
 832 void
 833 debug_bb (basic_block bb)
 834 {
 835   dump_bb (bb, stderr, 0);
 836 }
 837
 838 basic_block
 839 debug_bb_n (int n)
 840 {
 841   basic_block bb = BASIC_BLOCK (n);
 842   dump_bb (bb, stderr, 0);
 843   return bb;
 844 }
 845
 846 /* Dumps cfg related information about basic block BB to FILE.  */
 847
 848 static void
 849 dump_cfg_bb_info (FILE *file, basic_block bb)
 850 {
 851   unsigned i;
 852   bool first = true;
 853   static const char * const bb_bitnames[] =
 854     {
 855       "dirty", "new", "reachable", "visited", "irreducible_loop", "superblock"
 856     };
 857   const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
 858   edge e;
 859
 860   fprintf (file, "Basic block %d", bb->index);
 861   for (i = 0; i < n_bitnames; i++)
 862     if (bb->flags & (1 << i))
 863       {
 864         if (first)
 865           fprintf (file, " (");
 866         else
 867           fprintf (file, ", ");
 868         first = false;
 869         fprintf (file, bb_bitnames[i]);
 870       }
 871   if (!first)
 872     fprintf (file, ")");
 873   fprintf (file, "\n");
 874
 875   fprintf (file, "Predecessors: ");
 876   for (e = bb->pred; e; e = e->pred_next)
 877     dump_edge_info (file, e, 0);
 878
 879   fprintf (file, "\nSuccessors: ");
 880   for (e = bb->succ; e; e = e->succ_next)
 881     dump_edge_info (file, e, 1);
 882   fprintf (file, "\n\n");
 883 }
 884
 885 /* Dumps a brief description of cfg to FILE.  */
 886
 887 void
 888 brief_dump_cfg (FILE *file)
 889 {
 890   basic_block bb;
 891
 892   FOR_EACH_BB (bb)
 893     {
 894       dump_cfg_bb_info (file, bb);
 895     }
 896 }