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 void
 466 clear_bb_flags (void)
 467 {
 468   basic_block bb;
 469
 470   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 471     bb->flags = 0;
 472 }
 473 \f
 474 /* Check the consistency of profile information.  We can't do that
 475    in verify_flow_info, as the counts may get invalid for incompletely
 476    solved graphs, later eliminating of conditionals or roundoff errors.
 477    It is still practical to have them reported for debugging of simple
 478    testcases.  */
 479 void
 480 check_bb_profile (basic_block bb, FILE * file)
 481 {
 482   edge e;
 483   int sum = 0;
 484   gcov_type lsum;
 485
 486   if (profile_status == PROFILE_ABSENT)
 487     return;
 488
 489   if (bb != EXIT_BLOCK_PTR)
 490     {
 491       for (e = bb->succ; e; e = e->succ_next)
 492         sum += e->probability;
 493       if (bb->succ && abs (sum - REG_BR_PROB_BASE) > 100)
 494         fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
 495                  sum * 100.0 / REG_BR_PROB_BASE);
 496       lsum = 0;
 497       for (e = bb->succ; e; e = e->succ_next)
 498         lsum += e->count;
 499       if (bb->succ && (lsum - bb->count > 100 || lsum - bb->count < -100))
 500         fprintf (file, "Invalid sum of outgoing counts %i, should be %i\n",
 501                  (int) lsum, (int) bb->count);
 502     }
 503   if (bb != ENTRY_BLOCK_PTR)
 504     {
 505       sum = 0;
 506       for (e = bb->pred; e; e = e->pred_next)
 507         sum += EDGE_FREQUENCY (e);
 508       if (abs (sum - bb->frequency) > 100)
 509         fprintf (file,
 510                  "Invalid sum of incomming frequencies %i, should be %i\n",
 511                  sum, bb->frequency);
 512       lsum = 0;
 513       for (e = bb->pred; e; e = e->pred_next)
 514         lsum += e->count;
 515       if (lsum - bb->count > 100 || lsum - bb->count < -100)
 516         fprintf (file, "Invalid sum of incomming counts %i, should be %i\n",
 517                  (int) lsum, (int) bb->count);
 518     }
 519 }
 520 \f
 521 void
 522 dump_flow_info (FILE *file)
 523 {
 524   int i;
 525   basic_block bb;
 526   static const char * const reg_class_names[] = REG_CLASS_NAMES;
 527
 528   if (reg_n_info)
 529     {
 530       int max_regno = max_reg_num ();
 531       fprintf (file, "%d registers.\n", max_regno);
 532       for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
 533         if (REG_N_REFS (i))
 534           {
 535             enum reg_class class, altclass;
 536
 537             fprintf (file, "\nRegister %d used %d times across %d insns",
 538                      i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
 539             if (REG_BASIC_BLOCK (i) >= 0)
 540               fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
 541             if (REG_N_SETS (i))
 542               fprintf (file, "; set %d time%s", REG_N_SETS (i),
 543                        (REG_N_SETS (i) == 1) ? "" : "s");
 544             if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
 545               fprintf (file, "; user var");
 546             if (REG_N_DEATHS (i) != 1)
 547               fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
 548             if (REG_N_CALLS_CROSSED (i) == 1)
 549               fprintf (file, "; crosses 1 call");
 550             else if (REG_N_CALLS_CROSSED (i))
 551               fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
 552             if (regno_reg_rtx[i] != NULL
 553                 && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
 554               fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
 555
 556             class = reg_preferred_class (i);
 557             altclass = reg_alternate_class (i);
 558             if (class != GENERAL_REGS || altclass != ALL_REGS)
 559               {
 560                 if (altclass == ALL_REGS || class == ALL_REGS)
 561                   fprintf (file, "; pref %s", reg_class_names[(int) class]);
 562                 else if (altclass == NO_REGS)
 563                   fprintf (file, "; %s or none", reg_class_names[(int) class]);
 564                 else
 565                   fprintf (file, "; pref %s, else %s",
 566                            reg_class_names[(int) class],
 567                            reg_class_names[(int) altclass]);
 568               }
 569
 570             if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
 571               fprintf (file, "; pointer");
 572             fprintf (file, ".\n");
 573           }
 574     }
 575
 576   fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
 577   FOR_EACH_BB (bb)
 578     {
 579       edge e;
 580
 581       fprintf (file, "\nBasic block %d ", bb->index);
 582       fprintf (file, "prev %d, next %d, ",
 583                bb->prev_bb->index, bb->next_bb->index);
 584       fprintf (file, "loop_depth %d, count ", bb->loop_depth);
 585       fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
 586       fprintf (file, ", freq %i", bb->frequency);
 587       if (maybe_hot_bb_p (bb))
 588         fprintf (file, ", maybe hot");
 589       if (probably_never_executed_bb_p (bb))
 590         fprintf (file, ", probably never executed");
 591       fprintf (file, ".\n");
 592
 593       fprintf (file, "Predecessors: ");
 594       for (e = bb->pred; e; e = e->pred_next)
 595         dump_edge_info (file, e, 0);
 596
 597       fprintf (file, "\nSuccessors: ");
 598       for (e = bb->succ; e; e = e->succ_next)
 599         dump_edge_info (file, e, 1);
 600
 601       fprintf (file, "\nRegisters live at start:");
 602       dump_regset (bb->global_live_at_start, file);
 603
 604       fprintf (file, "\nRegisters live at end:");
 605       dump_regset (bb->global_live_at_end, file);
 606
 607       putc ('\n', file);
 608
 609       if (bb->global_live_at_start)
 610         {
 611           fprintf (file, "\nRegisters live at start:");
 612           dump_regset (bb->global_live_at_start, file);
 613         }
 614
 615       if (bb->global_live_at_end)
 616         {
 617           fprintf (file, "\nRegisters live at end:");
 618           dump_regset (bb->global_live_at_end, file);
 619         }
 620
 621       putc ('\n', file);
 622       check_bb_profile (bb, file);
 623     }
 624
 625   putc ('\n', file);
 626 }
 627
 628 void
 629 debug_flow_info (void)
 630 {
 631   dump_flow_info (stderr);
 632 }
 633
 634 void
 635 dump_edge_info (FILE *file, edge e, int do_succ)
 636 {
 637   basic_block side = (do_succ ? e->dest : e->src);
 638
 639   if (side == ENTRY_BLOCK_PTR)
 640     fputs (" ENTRY", file);
 641   else if (side == EXIT_BLOCK_PTR)
 642     fputs (" EXIT", file);
 643   else
 644     fprintf (file, " %d", side->index);
 645
 646   if (e->probability)
 647     fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
 648
 649   if (e->count)
 650     {
 651       fprintf (file, " count:");
 652       fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
 653     }
 654
 655   if (e->flags)
 656     {
 657       static const char * const bitnames[] = {
 658         "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
 659         "can_fallthru", "irreducible", "sibcall", "loop_exit",
 660         "true", "false", "exec"
 661       };
 662       int comma = 0;
 663       int i, flags = e->flags;
 664
 665       fputs (" (", file);
 666       for (i = 0; flags; i++)
 667         if (flags & (1 << i))
 668           {
 669             flags &= ~(1 << i);
 670
 671             if (comma)
 672               fputc (',', file);
 673             if (i < (int) ARRAY_SIZE (bitnames))
 674               fputs (bitnames[i], file);
 675             else
 676               fprintf (file, "%d", i);
 677             comma = 1;
 678           }
 679
 680       fputc (')', file);
 681     }
 682 }
 683 \f
 684 /* Simple routines to easily allocate AUX fields of basic blocks.  */
 685
 686 static struct obstack block_aux_obstack;
 687 static void *first_block_aux_obj = 0;
 688 static struct obstack edge_aux_obstack;
 689 static void *first_edge_aux_obj = 0;
 690
 691 /* Allocate a memory block of SIZE as BB->aux.  The obstack must
 692    be first initialized by alloc_aux_for_blocks.  */
 693
 694 inline void
 695 alloc_aux_for_block (basic_block bb, int size)
 696 {
 697   /* Verify that aux field is clear.  */
 698   if (bb->aux || !first_block_aux_obj)
 699     abort ();
 700   bb->aux = obstack_alloc (&block_aux_obstack, size);
 701   memset (bb->aux, 0, size);
 702 }
 703
 704 /* Initialize the block_aux_obstack and if SIZE is nonzero, call
 705    alloc_aux_for_block for each basic block.  */
 706
 707 void
 708 alloc_aux_for_blocks (int size)
 709 {
 710   static int initialized;
 711
 712   if (!initialized)
 713     {
 714       gcc_obstack_init (&block_aux_obstack);
 715       initialized = 1;
 716     }
 717
 718   /* Check whether AUX data are still allocated.  */
 719   else if (first_block_aux_obj)
 720     abort ();
 721   first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
 722   if (size)
 723     {
 724       basic_block bb;
 725
 726       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 727         alloc_aux_for_block (bb, size);
 728     }
 729 }
 730
 731 /* Clear AUX pointers of all blocks.  */
 732
 733 void
 734 clear_aux_for_blocks (void)
 735 {
 736   basic_block bb;
 737
 738   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
 739     bb->aux = NULL;
 740 }
 741
 742 /* Free data allocated in block_aux_obstack and clear AUX pointers
 743    of all blocks.  */
 744
 745 void
 746 free_aux_for_blocks (void)
 747 {
 748   if (!first_block_aux_obj)
 749     abort ();
 750   obstack_free (&block_aux_obstack, first_block_aux_obj);
 751   first_block_aux_obj = NULL;
 752
 753   clear_aux_for_blocks ();
 754 }
 755
 756 /* Allocate a memory edge of SIZE as BB->aux.  The obstack must
 757    be first initialized by alloc_aux_for_edges.  */
 758
 759 inline void
 760 alloc_aux_for_edge (edge e, int size)
 761 {
 762   /* Verify that aux field is clear.  */
 763   if (e->aux || !first_edge_aux_obj)
 764     abort ();
 765   e->aux = obstack_alloc (&edge_aux_obstack, size);
 766   memset (e->aux, 0, size);
 767 }
 768
 769 /* Initialize the edge_aux_obstack and if SIZE is nonzero, call
 770    alloc_aux_for_edge for each basic edge.  */
 771
 772 void
 773 alloc_aux_for_edges (int size)
 774 {
 775   static int initialized;
 776
 777   if (!initialized)
 778     {
 779       gcc_obstack_init (&edge_aux_obstack);
 780       initialized = 1;
 781     }
 782
 783   /* Check whether AUX data are still allocated.  */
 784   else if (first_edge_aux_obj)
 785     abort ();
 786
 787   first_edge_aux_obj = obstack_alloc (&edge_aux_obstack, 0);
 788   if (size)
 789     {
 790       basic_block bb;
 791
 792       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
 793         {
 794           edge e;
 795
 796           for (e = bb->succ; e; e = e->succ_next)
 797             alloc_aux_for_edge (e, size);
 798         }
 799     }
 800 }
 801
 802 /* Clear AUX pointers of all edges.  */
 803
 804 void
 805 clear_aux_for_edges (void)
 806 {
 807   basic_block bb;
 808   edge e;
 809
 810   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
 811     {
 812       for (e = bb->succ; e; e = e->succ_next)
 813         e->aux = NULL;
 814     }
 815 }
 816
 817 /* Free data allocated in edge_aux_obstack and clear AUX pointers
 818    of all edges.  */
 819
 820 void
 821 free_aux_for_edges (void)
 822 {
 823   if (!first_edge_aux_obj)
 824     abort ();
 825   obstack_free (&edge_aux_obstack, first_edge_aux_obj);
 826   first_edge_aux_obj = NULL;
 827
 828   clear_aux_for_edges ();
 829 }
 830
 831 void
 832 debug_bb (basic_block bb)
 833 {
 834   dump_bb (bb, stderr, 0);
 835 }
 836
 837 basic_block
 838 debug_bb_n (int n)
 839 {
 840   basic_block bb = BASIC_BLOCK (n);
 841   dump_bb (bb, stderr, 0);
 842   return bb;
 843 }
 844
 845 /* Dumps cfg related information about basic block BB to FILE.  */
 846
 847 static void
 848 dump_cfg_bb_info (FILE *file, basic_block bb)
 849 {
 850   unsigned i;
 851   bool first = true;
 852   static const char * const bb_bitnames[] =
 853     {
 854       "dirty", "new", "reachable", "visited", "irreducible_loop", "superblock"
 855     };
 856   const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
 857   edge e;
 858
 859   fprintf (file, "Basic block %d", bb->index);
 860   for (i = 0; i < n_bitnames; i++)
 861     if (bb->flags & (1 << i))
 862       {
 863         if (first)
 864           fprintf (file, " (");
 865         else
 866           fprintf (file, ", ");
 867         first = false;
 868         fprintf (file, bb_bitnames[i]);
 869       }
 870   if (!first)
 871     fprintf (file, ")");
 872   fprintf (file, "\n");
 873
 874   fprintf (file, "Predecessors: ");
 875   for (e = bb->pred; e; e = e->pred_next)
 876     dump_edge_info (file, e, 0);
 877
 878   fprintf (file, "\nSuccessors: ");
 879   for (e = bb->succ; e; e = e->succ_next)
 880     dump_edge_info (file, e, 1);
 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 }