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