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