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