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   gcc_assert (!n_edges);
 177 }
 178 \f
 179 /* Allocate memory for basic_block.  */
 180
 181 basic_block
 182 alloc_block (void)
 183 {
 184   basic_block bb;
 185   bb = ggc_alloc_cleared (sizeof (*bb));
 186   return bb;
 187 }
 188
 189 /* Create memory pool for rbi_pool.  */
 190
 191 void
 192 alloc_rbi_pool (void)
 193 {
 194   rbi_pool = create_alloc_pool ("rbi pool",
 195                                 sizeof (struct reorder_block_def),
 196                                 n_basic_blocks + 2);
 197 }
 198
 199 /* Free rbi_pool.  */
 200
 201 void
 202 free_rbi_pool (void)
 203 {
 204   free_alloc_pool (rbi_pool);
 205 }
 206
 207 /* Initialize rbi (the structure containing data used by basic block
 208    duplication and reordering) for the given basic block.  */
 209
 210 void
 211 initialize_bb_rbi (basic_block bb)
 212 {
 213   gcc_assert (!bb->rbi);
 214   bb->rbi = pool_alloc (rbi_pool);
 215   memset (bb->rbi, 0, sizeof (struct reorder_block_def));
 216 }
 217
 218 /* Link block B to chain after AFTER.  */
 219 void
 220 link_block (basic_block b, basic_block after)
 221 {
 222   b->next_bb = after->next_bb;
 223   b->prev_bb = after;
 224   after->next_bb = b;
 225   b->next_bb->prev_bb = b;
 226 }
 227
 228 /* Unlink block B from chain.  */
 229 void
 230 unlink_block (basic_block b)
 231 {
 232   b->next_bb->prev_bb = b->prev_bb;
 233   b->prev_bb->next_bb = b->next_bb;
 234   b->prev_bb = NULL;
 235   b->next_bb = NULL;
 236 }
 237
 238 /* Sequentially order blocks and compact the arrays.  */
 239 void
 240 compact_blocks (void)
 241 {
 242   int i;
 243   basic_block bb;
 244
 245   i = 0;
 246   FOR_EACH_BB (bb)
 247     {
 248       BASIC_BLOCK (i) = bb;
 249       bb->index = i;
 250       i++;
 251     }
 252
 253   gcc_assert (i == n_basic_blocks);
 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   gcc_assert (tmp);
 378   if (last_succ)
 379     last_succ->succ_next = e->succ_next;
 380   else
 381     src->succ = e->succ_next;
 382
 383   for (tmp = dest->pred; tmp && tmp != e; tmp = tmp->pred_next)
 384     last_pred = tmp;
 385
 386   gcc_assert (tmp);
 387   if (last_pred)
 388     last_pred->pred_next = e->pred_next;
 389   else
 390     dest->pred = e->pred_next;
 391
 392   free_edge (e);
 393 }
 394
 395 /* Redirect an edge's successor from one block to another.  */
 396
 397 void
 398 redirect_edge_succ (edge e, basic_block new_succ)
 399 {
 400   edge *pe;
 401
 402   /* Disconnect the edge from the old successor block.  */
 403   for (pe = &e->dest->pred; *pe != e; pe = &(*pe)->pred_next)
 404     continue;
 405   *pe = (*pe)->pred_next;
 406
 407   /* Reconnect the edge to the new successor block.  */
 408   e->pred_next = new_succ->pred;
 409   new_succ->pred = e;
 410   e->dest = new_succ;
 411 }
 412
 413 /* Like previous but avoid possible duplicate edge.  */
 414
 415 edge
 416 redirect_edge_succ_nodup (edge e, basic_block new_succ)
 417 {
 418   edge s;
 419
 420   /* Check whether the edge is already present.  */
 421   for (s = e->src->succ; s; s = s->succ_next)
 422     if (s->dest == new_succ && s != e)
 423       break;
 424
 425   if (s)
 426     {
 427       s->flags |= e->flags;
 428       s->probability += e->probability;
 429       if (s->probability > REG_BR_PROB_BASE)
 430         s->probability = REG_BR_PROB_BASE;
 431       s->count += e->count;
 432       remove_edge (e);
 433       e = s;
 434     }
 435   else
 436     redirect_edge_succ (e, new_succ);
 437
 438   return e;
 439 }
 440
 441 /* Redirect an edge's predecessor from one block to another.  */
 442
 443 void
 444 redirect_edge_pred (edge e, basic_block new_pred)
 445 {
 446   edge *pe;
 447
 448   /* Disconnect the edge from the old predecessor block.  */
 449   for (pe = &e->src->succ; *pe != e; pe = &(*pe)->succ_next)
 450     continue;
 451
 452   *pe = (*pe)->succ_next;
 453
 454   /* Reconnect the edge to the new predecessor block.  */
 455   e->succ_next = new_pred->succ;
 456   new_pred->succ = e;
 457   e->src = new_pred;
 458 }
 459
 460 /* Clear all basic block flags, with the exception of partitioning.  */
 461 void
 462 clear_bb_flags (void)
 463 {
 464   basic_block bb;
 465
 466   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 467     bb->flags = BB_PARTITION (bb);
 468 }
 469 \f
 470 /* Check the consistency of profile information.  We can't do that
 471    in verify_flow_info, as the counts may get invalid for incompletely
 472    solved graphs, later eliminating of conditionals or roundoff errors.
 473    It is still practical to have them reported for debugging of simple
 474    testcases.  */
 475 void
 476 check_bb_profile (basic_block bb, FILE * file)
 477 {
 478   edge e;
 479   int sum = 0;
 480   gcov_type lsum;
 481
 482   if (profile_status == PROFILE_ABSENT)
 483     return;
 484
 485   if (bb != EXIT_BLOCK_PTR)
 486     {
 487       for (e = bb->succ; e; e = e->succ_next)
 488         sum += e->probability;
 489       if (bb->succ && abs (sum - REG_BR_PROB_BASE) > 100)
 490         fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
 491                  sum * 100.0 / REG_BR_PROB_BASE);
 492       lsum = 0;
 493       for (e = bb->succ; e; e = e->succ_next)
 494         lsum += e->count;
 495       if (bb->succ && (lsum - bb->count > 100 || lsum - bb->count < -100))
 496         fprintf (file, "Invalid sum of outgoing counts %i, should be %i\n",
 497                  (int) lsum, (int) bb->count);
 498     }
 499   if (bb != ENTRY_BLOCK_PTR)
 500     {
 501       sum = 0;
 502       for (e = bb->pred; e; e = e->pred_next)
 503         sum += EDGE_FREQUENCY (e);
 504       if (abs (sum - bb->frequency) > 100)
 505         fprintf (file,
 506                  "Invalid sum of incoming frequencies %i, should be %i\n",
 507                  sum, bb->frequency);
 508       lsum = 0;
 509       for (e = bb->pred; e; e = e->pred_next)
 510         lsum += e->count;
 511       if (lsum - bb->count > 100 || lsum - bb->count < -100)
 512         fprintf (file, "Invalid sum of incoming counts %i, should be %i\n",
 513                  (int) lsum, (int) bb->count);
 514     }
 515 }
 516 \f
 517 void
 518 dump_flow_info (FILE *file)
 519 {
 520   int i;
 521   basic_block bb;
 522   static const char * const reg_class_names[] = REG_CLASS_NAMES;
 523
 524   if (reg_n_info)
 525     {
 526       int max_regno = max_reg_num ();
 527       fprintf (file, "%d registers.\n", max_regno);
 528       for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
 529         if (REG_N_REFS (i))
 530           {
 531             enum reg_class class, altclass;
 532
 533             fprintf (file, "\nRegister %d used %d times across %d insns",
 534                      i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
 535             if (REG_BASIC_BLOCK (i) >= 0)
 536               fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
 537             if (REG_N_SETS (i))
 538               fprintf (file, "; set %d time%s", REG_N_SETS (i),
 539                        (REG_N_SETS (i) == 1) ? "" : "s");
 540             if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
 541               fprintf (file, "; user var");
 542             if (REG_N_DEATHS (i) != 1)
 543               fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
 544             if (REG_N_CALLS_CROSSED (i) == 1)
 545               fprintf (file, "; crosses 1 call");
 546             else if (REG_N_CALLS_CROSSED (i))
 547               fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
 548             if (regno_reg_rtx[i] != NULL
 549                 && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
 550               fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
 551
 552             class = reg_preferred_class (i);
 553             altclass = reg_alternate_class (i);
 554             if (class != GENERAL_REGS || altclass != ALL_REGS)
 555               {
 556                 if (altclass == ALL_REGS || class == ALL_REGS)
 557                   fprintf (file, "; pref %s", reg_class_names[(int) class]);
 558                 else if (altclass == NO_REGS)
 559                   fprintf (file, "; %s or none", reg_class_names[(int) class]);
 560                 else
 561                   fprintf (file, "; pref %s, else %s",
 562                            reg_class_names[(int) class],
 563                            reg_class_names[(int) altclass]);
 564               }
 565
 566             if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
 567               fprintf (file, "; pointer");
 568             fprintf (file, ".\n");
 569           }
 570     }
 571
 572   fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
 573   FOR_EACH_BB (bb)
 574     {
 575       edge e;
 576
 577       fprintf (file, "\nBasic block %d ", bb->index);
 578       fprintf (file, "prev %d, next %d, ",
 579                bb->prev_bb->index, bb->next_bb->index);
 580       fprintf (file, "loop_depth %d, count ", bb->loop_depth);
 581       fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
 582       fprintf (file, ", freq %i", bb->frequency);
 583       if (maybe_hot_bb_p (bb))
 584         fprintf (file, ", maybe hot");
 585       if (probably_never_executed_bb_p (bb))
 586         fprintf (file, ", probably never executed");
 587       fprintf (file, ".\n");
 588
 589       fprintf (file, "Predecessors: ");
 590       for (e = bb->pred; e; e = e->pred_next)
 591         dump_edge_info (file, e, 0);
 592
 593       fprintf (file, "\nSuccessors: ");
 594       for (e = bb->succ; e; e = e->succ_next)
 595         dump_edge_info (file, e, 1);
 596
 597       fprintf (file, "\nRegisters live at start:");
 598       dump_regset (bb->global_live_at_start, file);
 599
 600       fprintf (file, "\nRegisters live at end:");
 601       dump_regset (bb->global_live_at_end, file);
 602
 603       putc ('\n', file);
 604
 605       if (bb->global_live_at_start)
 606         {
 607           fprintf (file, "\nRegisters live at start:");
 608           dump_regset (bb->global_live_at_start, file);
 609         }
 610
 611       if (bb->global_live_at_end)
 612         {
 613           fprintf (file, "\nRegisters live at end:");
 614           dump_regset (bb->global_live_at_end, file);
 615         }
 616
 617       putc ('\n', file);
 618       check_bb_profile (bb, file);
 619     }
 620
 621   putc ('\n', file);
 622 }
 623
 624 void
 625 debug_flow_info (void)
 626 {
 627   dump_flow_info (stderr);
 628 }
 629
 630 void
 631 dump_edge_info (FILE *file, edge e, int do_succ)
 632 {
 633   basic_block side = (do_succ ? e->dest : e->src);
 634
 635   if (side == ENTRY_BLOCK_PTR)
 636     fputs (" ENTRY", file);
 637   else if (side == EXIT_BLOCK_PTR)
 638     fputs (" EXIT", file);
 639   else
 640     fprintf (file, " %d", side->index);
 641
 642   if (e->probability)
 643     fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
 644
 645   if (e->count)
 646     {
 647       fprintf (file, " count:");
 648       fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
 649     }
 650
 651   if (e->flags)
 652     {
 653       static const char * const bitnames[] = {
 654         "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
 655         "can_fallthru", "irreducible", "sibcall", "loop_exit",
 656         "true", "false", "exec"
 657       };
 658       int comma = 0;
 659       int i, flags = e->flags;
 660
 661       fputs (" (", file);
 662       for (i = 0; flags; i++)
 663         if (flags & (1 << i))
 664           {
 665             flags &= ~(1 << i);
 666
 667             if (comma)
 668               fputc (',', file);
 669             if (i < (int) ARRAY_SIZE (bitnames))
 670               fputs (bitnames[i], file);
 671             else
 672               fprintf (file, "%d", i);
 673             comma = 1;
 674           }
 675
 676       fputc (')', file);
 677     }
 678 }
 679 \f
 680 /* Simple routines to easily allocate AUX fields of basic blocks.  */
 681
 682 static struct obstack block_aux_obstack;
 683 static void *first_block_aux_obj = 0;
 684 static struct obstack edge_aux_obstack;
 685 static void *first_edge_aux_obj = 0;
 686
 687 /* Allocate a memory block of SIZE as BB->aux.  The obstack must
 688    be first initialized by alloc_aux_for_blocks.  */
 689
 690 inline void
 691 alloc_aux_for_block (basic_block bb, int size)
 692 {
 693   /* Verify that aux field is clear.  */
 694   gcc_assert (!bb->aux && first_block_aux_obj);
 695   bb->aux = obstack_alloc (&block_aux_obstack, size);
 696   memset (bb->aux, 0, size);
 697 }
 698
 699 /* Initialize the block_aux_obstack and if SIZE is nonzero, call
 700    alloc_aux_for_block for each basic block.  */
 701
 702 void
 703 alloc_aux_for_blocks (int size)
 704 {
 705   static int initialized;
 706
 707   if (!initialized)
 708     {
 709       gcc_obstack_init (&block_aux_obstack);
 710       initialized = 1;
 711     }
 712   else
 713     /* Check whether AUX data are still allocated.  */
 714     gcc_assert (!first_block_aux_obj);
 715
 716   first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
 717   if (size)
 718     {
 719       basic_block bb;
 720
 721       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 722         alloc_aux_for_block (bb, size);
 723     }
 724 }
 725
 726 /* Clear AUX pointers of all blocks.  */
 727
 728 void
 729 clear_aux_for_blocks (void)
 730 {
 731   basic_block bb;
 732
 733   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 734     bb->aux = NULL;
 735 }
 736
 737 /* Free data allocated in block_aux_obstack and clear AUX pointers
 738    of all blocks.  */
 739
 740 void
 741 free_aux_for_blocks (void)
 742 {
 743   gcc_assert (first_block_aux_obj);
 744   obstack_free (&block_aux_obstack, first_block_aux_obj);
 745   first_block_aux_obj = NULL;
 746
 747   clear_aux_for_blocks ();
 748 }
 749
 750 /* Allocate a memory edge of SIZE as BB->aux.  The obstack must
 751    be first initialized by alloc_aux_for_edges.  */
 752
 753 inline void
 754 alloc_aux_for_edge (edge e, int size)
 755 {
 756   /* Verify that aux field is clear.  */
 757   gcc_assert (!e->aux && first_edge_aux_obj);
 758   e->aux = obstack_alloc (&edge_aux_obstack, size);
 759   memset (e->aux, 0, size);
 760 }
 761
 762 /* Initialize the edge_aux_obstack and if SIZE is nonzero, call
 763    alloc_aux_for_edge for each basic edge.  */
 764
 765 void
 766 alloc_aux_for_edges (int size)
 767 {
 768   static int initialized;
 769
 770   if (!initialized)
 771     {
 772       gcc_obstack_init (&edge_aux_obstack);
 773       initialized = 1;
 774     }
 775   else
 776     /* Check whether AUX data are still allocated.  */
 777     gcc_assert (!first_edge_aux_obj);
 778
 779   first_edge_aux_obj = obstack_alloc (&edge_aux_obstack, 0);
 780   if (size)
 781     {
 782       basic_block bb;
 783
 784       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
 785         {
 786           edge e;
 787
 788           for (e = bb->succ; e; e = e->succ_next)
 789             alloc_aux_for_edge (e, size);
 790         }
 791     }
 792 }
 793
 794 /* Clear AUX pointers of all edges.  */
 795
 796 void
 797 clear_aux_for_edges (void)
 798 {
 799   basic_block bb;
 800   edge e;
 801
 802   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
 803     {
 804       for (e = bb->succ; e; e = e->succ_next)
 805         e->aux = NULL;
 806     }
 807 }
 808
 809 /* Free data allocated in edge_aux_obstack and clear AUX pointers
 810    of all edges.  */
 811
 812 void
 813 free_aux_for_edges (void)
 814 {
 815   gcc_assert (first_edge_aux_obj);
 816   obstack_free (&edge_aux_obstack, first_edge_aux_obj);
 817   first_edge_aux_obj = NULL;
 818
 819   clear_aux_for_edges ();
 820 }
 821
 822 void
 823 debug_bb (basic_block bb)
 824 {
 825   dump_bb (bb, stderr, 0);
 826 }
 827
 828 basic_block
 829 debug_bb_n (int n)
 830 {
 831   basic_block bb = BASIC_BLOCK (n);
 832   dump_bb (bb, stderr, 0);
 833   return bb;
 834 }
 835
 836 /* Dumps cfg related information about basic block BB to FILE.  */
 837
 838 static void
 839 dump_cfg_bb_info (FILE *file, basic_block bb)
 840 {
 841   unsigned i;
 842   bool first = true;
 843   static const char * const bb_bitnames[] =
 844     {
 845       "dirty", "new", "reachable", "visited", "irreducible_loop", "superblock"
 846     };
 847   const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
 848   edge e;
 849
 850   fprintf (file, "Basic block %d", bb->index);
 851   for (i = 0; i < n_bitnames; i++)
 852     if (bb->flags & (1 << i))
 853       {
 854         if (first)
 855           fprintf (file, " (");
 856         else
 857           fprintf (file, ", ");
 858         first = false;
 859         fprintf (file, bb_bitnames[i]);
 860       }
 861   if (!first)
 862     fprintf (file, ")");
 863   fprintf (file, "\n");
 864
 865   fprintf (file, "Predecessors: ");
 866   for (e = bb->pred; e; e = e->pred_next)
 867     dump_edge_info (file, e, 0);
 868
 869   fprintf (file, "\nSuccessors: ");
 870   for (e = bb->succ; e; e = e->succ_next)
 871     dump_edge_info (file, e, 1);
 872   fprintf (file, "\n\n");
 873 }
 874
 875 /* Dumps a brief description of cfg to FILE.  */
 876
 877 void
 878 brief_dump_cfg (FILE *file)
 879 {
 880   basic_block bb;
 881
 882   FOR_EACH_BB (bb)
 883     {
 884       dump_cfg_bb_info (file, bb);
 885     }
 886 }