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