gcc/refined-regions.c

   1 /* Refined Regions
   2    Copyright (C) 2010 Free Software Foundation, Inc.
   3    Contributed by Tobias Grosser <grosser@fim.uni-passau.de>.
   4                   Antoniu Pop  <antoniu.pop@gmail.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "basic-block.h"
  27 #include "timevar.h"
  28 #include "bitmap.h"
  29 #include "domwalk.h"
  30 #include "tree-pass.h"
  31 #include "refined-regions.h"
  32
  33 /* Auxiliary function for qsort () that compares two basic blocks
  34    according to the values of their indices.  */
  35
  36 static int
  37 bb_index_compare (const void *bbv1, const void *bbv2)
  38 {
  39   basic_block bb1 = *(const basic_block *)bbv1;
  40   basic_block bb2 = *(const basic_block *)bbv2;
  41
  42   gcc_assert (bbv1 && bbv2);
  43
  44   if (bb1->index < bb2->index)
  45     return -1;
  46   else
  47     return bb1->index > bb2->index;
  48 }
  49
  50 /* Put all the basic blocks contained in REGION into BBLIST
  51    The order in which BBs are put is not defined.  */
  52
  53 void
  54 get_bbs_in_region (refined_region_p region, VEC (basic_block, heap) **bblist)
  55 {
  56   basic_block bb_iter;
  57
  58   VEC (basic_block, heap) *bbstack = VEC_alloc (basic_block, heap, 3);
  59   VEC_safe_push (basic_block, heap, bbstack, region->entry);
  60
  61   while (VEC_length (basic_block, bbstack) != 0)
  62     {
  63       basic_block bb = VEC_pop (basic_block, bbstack);
  64       VEC_safe_push (basic_block, heap, *bblist, bb);
  65
  66       /* Push to stack all BB's successors.  */
  67       for (bb_iter = first_dom_son (CDI_DOMINATORS, bb);
  68            bb_iter != NULL;
  69            bb_iter = next_dom_son (CDI_DOMINATORS, bb_iter))
  70         if (bb_iter != region->exit)
  71           VEC_safe_push (basic_block, heap, bbstack, bb_iter);
  72     }
  73
  74   VEC_free (basic_block, heap, bbstack);
  75 }
  76
  77 /* Print all basic block indices of REGION into FILE.  */
  78
  79 static void
  80 print_bbs_in_region (FILE* file, refined_region_p region)
  81 {
  82   VEC (basic_block, heap) *bblist = VEC_alloc (basic_block, heap, 3);
  83   int i;
  84   basic_block bb_iter;
  85
  86   get_bbs_in_region (region, &bblist);
  87
  88   /* Sort all BBs in the region.  */
  89   qsort (VEC_address (basic_block, bblist), VEC_length (basic_block, bblist),
  90          sizeof (basic_block), bb_index_compare);
  91
  92   for (i = 0; VEC_iterate (basic_block, bblist, i, bb_iter); i++)
  93     if (i == 0)
  94       fprintf (file, "[%d", bb_iter->index);
  95     else
  96       fprintf (file, ", %d", bb_iter->index);
  97
  98   fprintf (file, "]\n");
  99
 100   VEC_free (basic_block, heap, bblist);
 101 }
 102
 103 /* Print REGION to F with indention level INDENT.  */
 104
 105 void
 106 print_refined_region (FILE *F, refined_region_p region, int indent, bool print_bbs)
 107 {
 108   int ix, i;
 109   refined_region_p subregion;
 110
 111   for (i = 0; i < indent * 2; ++i)
 112     fprintf (F, " ");
 113
 114   if (region->exit)
 115     fprintf (F, "%d => %d ", region->entry->index, region->exit->index);
 116   else
 117     fprintf (F, "%d => End ", region->entry->index);
 118
 119   if (print_bbs == true)
 120     print_bbs_in_region (F, region);
 121   else
 122     fprintf (F, "\n");
 123
 124   for (ix = 0; VEC_iterate (refined_region_p, region->children, ix, subregion);
 125        ix++)
 126     print_refined_region (F, subregion, indent + 1, print_bbs);
 127 }
 128
 129 /* Print REGION and all its subregions to stderr.  */
 130
 131 void
 132 debug_refined_region (refined_region_p region)
 133 {
 134   fprintf (stderr, "\n");
 135   print_refined_region (stderr, region, 0, true);
 136 }
 137
 138 /* Check that BB is contained in REGION.  */
 139
 140 bool
 141 refined_region_contains_bb_p (refined_region_p region, basic_block bb)
 142 {
 143   return dominated_by_p (CDI_DOMINATORS, bb, region->entry)
 144     && !(dominated_by_p (CDI_DOMINATORS, bb, region->exit)
 145          && dominated_by_p (CDI_DOMINATORS, region->exit, region->entry));
 146 }
 147
 148 /* Check that the INNER region is contained in the OUTER region.  */
 149
 150 bool
 151 refined_region_contains_region_p (refined_region_p outer,
 152                                   refined_region_p inner)
 153 {
 154   return refined_region_contains_bb_p (outer, inner->entry)
 155     && (refined_region_contains_bb_p (outer, inner->exit)
 156         || outer->exit == inner->exit);
 157 }
 158
 159 /* Check that BB is part of the dominance frontier of ENTRY, because it was
 160    inherited from the dominance frontier of EXIT.  */
 161
 162 static bool is_common_df (basic_block bb, basic_block entry, basic_block exit)
 163 {
 164   int i;
 165   edge e;
 166
 167   for (i = 0; VEC_iterate (edge, bb->preds, i, e); i++)
 168     if (dominated_by_p (CDI_DOMINATORS, e->src, entry)
 169         && !dominated_by_p (CDI_DOMINATORS, e->src, exit))
 170       return false;
 171
 172   return true;
 173 }
 174
 175 /* Data needed to calculate the refined regions.  */
 176
 177 struct find_regions_global_data {
 178
 179   /* The shortcut table keeps track of existing regions and saves shortcuts
 180      from the beginning of each region to the end of the largest possible
 181      region.  Canonical regions are attached to represent the largest possible
 182      region.  */
 183   htab_t shortcut;
 184
 185   /* A map from each basic block that is a region header to its surrounding
 186      region.  */
 187   htab_t bbmap;
 188
 189   /* An array that contains for each basic block its dominance frontier.  */
 190   bitmap *dfs;
 191 };
 192
 193 /* Check that ENTRY and EXIT form a refined region.  DFS contains the dominance
 194    frontier for all basic blocks.  */
 195
 196 static bool
 197 is_region (basic_block entry, basic_block exit, bitmap *dfs)
 198 {
 199   bitmap df_entry = BITMAP_ALLOC (NULL);
 200   bitmap df_exit = BITMAP_ALLOC (NULL);
 201   bitmap_iterator bi;
 202   unsigned bit = 0;
 203
 204   bitmap_copy (df_entry, dfs[entry->index]);
 205
 206   bitmap_clear_bit (df_entry, entry->index);
 207   bitmap_clear_bit (df_entry, exit->index);
 208
 209   if (entry == exit)
 210     return false;
 211
 212   if (!dominated_by_p (CDI_POST_DOMINATORS, entry, exit))
 213     return false;
 214
 215   if (!dominated_by_p (CDI_DOMINATORS, exit, entry))
 216     return bitmap_count_bits (df_entry) == 0;
 217
 218   bitmap_copy (df_exit, dfs[exit->index]);
 219   bitmap_clear_bit (df_exit, entry->index);
 220   bitmap_clear_bit (df_exit, exit->index);
 221
 222   if (bitmap_intersect_compl_p (df_entry, df_exit))
 223     return false;
 224
 225   EXECUTE_IF_SET_IN_BITMAP (df_entry, 0, bit, bi)
 226     if (!is_common_df (BASIC_BLOCK (bit), entry, exit))
 227       return false;
 228
 229   EXECUTE_IF_SET_IN_BITMAP (df_exit, 0, bit, bi)
 230     if (dominated_by_p (CDI_DOMINATORS, BASIC_BLOCK (bit), entry))
 231       return false;
 232
 233   bitmap_clear (df_entry);
 234   bitmap_clear (df_exit);
 235
 236   return true;
 237 }
 238
 239 /* Functions to map from one basic block to another.  */
 240
 241 typedef struct bb_bb_def
 242 {
 243   basic_block key;
 244   basic_block value;
 245 } bb_bb_def;
 246
 247 /* Allocate a new bb->bb object mapping from KEY to VALUE.  */
 248
 249 static bb_bb_def *
 250 new_bb_bb_def (basic_block key, basic_block value)
 251 {
 252   bb_bb_def *bb_bb_p;
 253   bb_bb_p = XNEW (bb_bb_def);
 254   bb_bb_p->key = key;
 255   bb_bb_p->value = value;
 256   return bb_bb_p;
 257 }
 258
 259 /* Calculate the hash code of the bb->bb object BB_BB.  */
 260
 261 static inline hashval_t
 262 bb_bb_map_hash (const void *bb_bb)
 263 {
 264   return (hashval_t)(((const bb_bb_def *)bb_bb)->key->index);
 265 }
 266
 267 /* Check that two bb->bb objects BB_BB1 and BB_BB2 are equal.  */
 268
 269 static inline int
 270 eq_bb_bb_map (const void *bb_bb1, const void *bb_bb2)
 271 {
 272   const bb_bb_def *bb1 = (const bb_bb_def *) bb_bb1;
 273   const bb_bb_def *bb2 = (const bb_bb_def *) bb_bb2;
 274   return (bb1->key->index == bb2->key->index);
 275 }
 276
 277 /* Find the value saved in BB_MAP at KEY.  If key is not available return NULL.
 278    */
 279
 280 static inline basic_block
 281 find_new_bb (basic_block key, htab_t bb_map)
 282 {
 283   bb_bb_def tmp;
 284   PTR *x;
 285
 286   tmp.key = key;
 287   x = htab_find_slot (bb_map, &tmp, NO_INSERT);
 288   if (!x || !*x)
 289     return NULL;
 290
 291   return ((bb_bb_def *) (*x))->value;
 292 }
 293
 294 /* Functions to map from a basic block to a region.  */
 295
 296 typedef struct bb_reg_def
 297 {
 298   basic_block bb;
 299   refined_region_p region;
 300 } bb_reg_def;
 301
 302 /* Create a bb to region map object mapping from BB to REGION.  */
 303
 304 static bb_reg_def *
 305 new_bb_reg_def (basic_block bb, refined_region_p region)
 306 {
 307   bb_reg_def *bb_reg_p;
 308   bb_reg_p = XNEW (bb_reg_def);
 309   bb_reg_p->bb = bb;
 310   bb_reg_p->region = region;
 311   return bb_reg_p;
 312 }
 313
 314 /* Calculate the hash value for BB_REG.  */
 315
 316 static inline hashval_t
 317 bb_reg_map_hash (const void *bb_reg)
 318 {
 319   return (hashval_t)(((const bb_reg_def *)bb_reg)->bb->index);
 320 }
 321
 322 /* Check that BB_REG1 and BB_REG2 are equal.  */
 323
 324 static inline int
 325 eq_bb_reg_map (const void *bb_reg1, const void *bb_reg2)
 326 {
 327   const bb_reg_def *bb1 = (const bb_reg_def *) bb_reg1;
 328   const bb_reg_def *bb2 = (const bb_reg_def *) bb_reg2;
 329   return (bb1->bb->index == bb2->bb->index);
 330 }
 331
 332 /* Search in BB_MAP for the region saved for BB.  If available return the
 333    region otherwise NULL.  */
 334
 335 static inline refined_region_p
 336 find_new_region (basic_block bb, htab_t bb_map)
 337 {
 338   bb_reg_def tmp;
 339   PTR *x;
 340
 341   tmp.bb = bb;
 342   x = htab_find_slot (bb_map, &tmp, NO_INSERT);
 343   if (!x || !*x)
 344     return NULL;
 345
 346   return ((bb_reg_def *) (*x))->region;
 347 }
 348
 349 /* Insert an object mapping from BB to REG into REGMAP.  Overwrite
 350    the old value if the BB already exists.  */
 351
 352 static inline void
 353 insert_new_reg (basic_block bb, refined_region_p reg, htab_t regmap)
 354 {
 355   bb_reg_def tmp;
 356   PTR *x;
 357
 358   tmp.bb = bb;
 359   x = htab_find_slot (regmap, &tmp, INSERT);
 360   if (x && !*x)
 361     *x = new_bb_reg_def (bb, reg);
 362   else if (x)
 363     {
 364       free (*x);
 365       *x = new_bb_reg_def (bb, reg);
 366     }
 367 }
 368
 369 /* Insert an object mapping from basic block KEY to VALUE into REGMAP.
 370    If KEY is already used overwrite the old value.  */
 371
 372 static inline void
 373 insert_new_bb (basic_block key, basic_block value, htab_t bb_map)
 374 {
 375   bb_bb_def tmp;
 376   PTR *x;
 377
 378   tmp.key = key;
 379   x = htab_find_slot (bb_map, &tmp, INSERT);
 380   if (x && !*x)
 381     *x = new_bb_bb_def (key, value);
 382   else if (x)
 383     *x = new_bb_bb_def (key, value);
 384 }
 385
 386 /* Insert a shortcut from ENTRY to EXIT into SHORTCUT.  If there is already
 387    a shortcut starting at EXIT, extend the shortcut to point to the same
 388    basic block EXIT is already pointing.  */
 389
 390 static void
 391 insert_shortcut (basic_block entry, basic_block exit, htab_t shortcut)
 392 {
 393   basic_block bb = find_new_bb (exit, shortcut);
 394
 395   if (!bb)
 396     insert_new_bb (entry, exit, shortcut);
 397   else
 398     insert_new_bb (entry, bb, shortcut);
 399 }
 400
 401 /* Get the next post dominator of BB, but skip all existing regions by looking
 402    at SHORTCUT.  */
 403
 404 static basic_block
 405 get_next_postdom (basic_block bb, htab_t shortcut)
 406 {
 407   basic_block bb_shortcut = find_new_bb (bb, shortcut);
 408
 409   if (bb_shortcut)
 410     bb = bb_shortcut;
 411
 412   return get_immediate_dominator (CDI_POST_DOMINATORS, bb);
 413 }
 414
 415 /* Create a new region starting at ENTRY and finishing at EXIT.  */
 416
 417 static refined_region_p
 418 create_region (basic_block entry, basic_block exit)
 419 {
 420   refined_region_p r = XNEW (struct refined_region);
 421   r->entry = entry;
 422   r->exit = exit;
 423   r->parent = 0;
 424   r->children = VEC_alloc (refined_region_p, heap, 16);
 425
 426   return r;
 427 }
 428
 429 /* Find all regions that start at ENTRY.  DFS is an array containing
 430    the dominance frontier for each basic block.  GD the global dom walk data
 431    storing some further information.  */
 432
 433 static void
 434 find_regions_with_entry (basic_block entry, struct find_regions_global_data *gd)
 435 {
 436   basic_block exit = entry;
 437   refined_region_p last_region = 0;
 438   basic_block last_exit = entry;
 439
 440   while ((exit = get_next_postdom (exit, gd->shortcut)))
 441     {
 442
 443       if (is_region (entry, exit, gd->dfs))
 444         {
 445           refined_region_p new_region = create_region (entry, exit);
 446
 447           /* new_region becomes the parent of last_region.  */
 448           if (last_region)
 449             {
 450               VEC_safe_push (refined_region_p, heap, new_region->children,
 451                              last_region);
 452               last_region->parent = new_region;
 453             }
 454           else
 455             insert_new_reg (entry, new_region, gd->bbmap);
 456
 457           last_region = new_region;
 458           last_exit = exit;
 459         }
 460
 461       /* This can never be a region, so stop the search.  */
 462       if (!dominated_by_p (CDI_DOMINATORS, exit, entry))
 463         break;
 464     }
 465
 466   /* Tried to create regions from entry to last_exit.  Next time take a
 467      shortcut from entry to last_exit.  */
 468   if (last_exit != entry)
 469     insert_shortcut (entry, last_exit, gd->shortcut);
 470 }
 471
 472 /* Execute this code after each element that was visited by the
 473    dominance tree walk.  It will find the regions starting
 474    at this element (BB),  while taking into account the global
 475    dom walk data DWD.  */
 476
 477 static void
 478 find_regions_adc (struct dom_walk_data *dwd, basic_block bb)
 479 {
 480   struct find_regions_global_data *gd =
 481     (struct find_regions_global_data *) dwd->global_data;
 482   find_regions_with_entry (bb, gd);
 483 }
 484
 485 /* Find all regions in the current function.  DFS is an array
 486    containing the dominance frontiers of all basic blocks.  BBMAP will contain
 487    the surrounding regions for all region header basic blocks.  */
 488
 489 static void
 490 find_regions (bitmap *dfs, htab_t bbmap)
 491 {
 492   struct dom_walk_data dwd;
 493   struct find_regions_global_data gd;
 494   gd.shortcut = htab_create (32, &bb_bb_map_hash, &eq_bb_bb_map, free);
 495   gd.bbmap = bbmap;
 496   gd.dfs = dfs;
 497
 498   /* Initialize the domtree walk.  */
 499   dwd.dom_direction = CDI_DOMINATORS;
 500   dwd.block_local_data_size = 0;
 501   dwd.global_data = &gd;
 502   dwd.after_dom_children = find_regions_adc;
 503   dwd.before_dom_children = 0;
 504   dwd.initialize_block_local_data = 0;
 505   init_walk_dominator_tree (&dwd);
 506
 507   /* To only get canonical regions we walk the dominator tree post order and
 508      skip already built regions using the shortcut map.  */
 509   walk_dominator_tree (&dwd, ENTRY_BLOCK_PTR);
 510   htab_delete (gd.shortcut);
 511 }
 512
 513 /* Get the topmost parent region of REGION.  */
 514
 515 static refined_region_p
 516 get_topmost_parent (refined_region_p region)
 517 {
 518   if (!region)
 519     return NULL;
 520
 521   while (region->parent)
 522     region = region->parent;
 523
 524   return region;
 525 }
 526
 527 /* Initialize the parent/child relations of the regions.  Starting at BB
 528    that is surrounded by OUTER_REGION.  BBMAP contains the surrounding regions
 529    for all basic blocks that are region headers.  */
 530
 531 static void
 532 build_regions_tree (basic_block bb, refined_region_p outer_region, htab_t bbmap)
 533 {
 534   int ix;
 535   basic_block child_bb;
 536   refined_region_p region;
 537   VEC (basic_block, heap) *dominated_bbs = get_dominated_by (CDI_DOMINATORS,
 538                                                              bb);
 539   /* Passed region exit.  */
 540   while (bb == outer_region->exit)
 541     outer_region = outer_region->parent;
 542
 543   region = find_new_region (bb, bbmap);
 544
 545   if (region)
 546     {
 547       refined_region_p topmost_parent = get_topmost_parent (region);
 548       VEC_safe_push (refined_region_p, heap, outer_region->children,
 549                      topmost_parent);
 550       topmost_parent->parent = outer_region;
 551       outer_region = region;
 552     }
 553
 554   for (ix = 0; VEC_iterate (basic_block, dominated_bbs, ix, child_bb); ix++)
 555     build_regions_tree (child_bb, outer_region, bbmap);
 556
 557   VEC_free (basic_block, heap, dominated_bbs);
 558 }
 559
 560 /* Calculate the refined region tree and return the root of the region
 561    tree.  */
 562
 563 refined_region_p
 564 calculate_region_tree (void)
 565 {
 566   bitmap *dfs;
 567   basic_block bb;
 568   refined_region_p outermost_region;
 569   htab_t bbmap =  htab_create (32, &bb_reg_map_hash, &eq_bb_reg_map, free);
 570   bool dom_available, postdom_available;
 571
 572   timevar_push (TV_REFINED_REGIONS);
 573
 574   /* Initialize dominance frontier.  */
 575   dfs = XNEWVEC (bitmap, last_basic_block);
 576   FOR_EACH_BB (bb)
 577     dfs[bb->index] = BITMAP_ALLOC (NULL);
 578
 579   /* Required analysis */
 580   dom_available = dom_info_available_p (CDI_DOMINATORS);
 581   postdom_available = dom_info_available_p (CDI_POST_DOMINATORS);
 582
 583   calculate_dominance_info (CDI_DOMINATORS);
 584   calculate_dominance_info (CDI_POST_DOMINATORS);
 585   compute_dominance_frontiers (dfs);
 586
 587   find_regions (dfs, bbmap);
 588   outermost_region = create_region (ENTRY_BLOCK_PTR, 0);
 589   build_regions_tree (ENTRY_BLOCK_PTR, outermost_region, bbmap);
 590
 591   /* Free dominance frontier */
 592   FOR_EACH_BB (bb)
 593     BITMAP_FREE (dfs[bb->index]);
 594   free (dfs);
 595
 596   if (!dom_available)
 597     free_dominance_info (CDI_DOMINATORS);
 598
 599   if (!postdom_available)
 600     free_dominance_info (CDI_POST_DOMINATORS);
 601
 602   htab_delete (bbmap);
 603
 604   timevar_pop (TV_REFINED_REGIONS);
 605   return outermost_region;
 606 }
 607
 608 /* Free REGION and all its subregions.  */
 609
 610 void
 611 free_region_tree (refined_region_p region)
 612 {
 613   int ix;
 614   refined_region_p subregion;
 615
 616   for (ix = 0; VEC_iterate (refined_region_p, region->children, ix, subregion);
 617        ix++)
 618     free_region_tree (subregion);
 619
 620   VEC_free (refined_region_p, heap, region->children);
 621   free (region);
 622 }
 623
 624 /* Pretty print to FILE all the REGIONS in DOT format and mark them with
 625    different colors.  The behavior is the same as in dot_all_scops_1.  */
 626
 627 static void
 628 dot_regions_1 (FILE *file, VEC (refined_region_p, heap) *regions)
 629 {
 630   basic_block bb;
 631   edge e;
 632   edge_iterator ei;
 633   refined_region_p region;
 634   const char* color;
 635   int i;
 636
 637   /* Disable debugging while printing graph.  */
 638   int tmp_dump_flags = dump_flags;
 639   dump_flags = 0;
 640
 641   fprintf (file, "digraph all {\n");
 642
 643   FOR_ALL_BB (bb)
 644     {
 645       int part_of_scop = false;
 646
 647       /* Use HTML for every bb label.  So we are able to print bbs
 648          which are part of two different SCoPs, with two different
 649          background colors.  */
 650       fprintf (file, "%d [label=<\n  <TABLE BORDER=\"0\" CELLBORDER=\"1\" ",
 651                bb->index);
 652       fprintf (file, "CELLSPACING=\"0\">\n");
 653
 654       /* Select color for SCoP.  */
 655       for (i = 0; VEC_iterate (refined_region_p, regions, i, region); i++)
 656         {
 657           if (refined_region_contains_bb_p (region, bb)
 658               || (region->exit == bb)
 659               || (region->entry == bb))
 660             {
 661               switch (i % 17)
 662                 {
 663                 case 0: /* red */
 664                   color = "#e41a1c";
 665                   break;
 666                 case 1: /* blue */
 667                   color = "#377eb8";
 668                   break;
 669                 case 2: /* green */
 670                   color = "#4daf4a";
 671                   break;
 672                 case 3: /* purple */
 673                   color = "#984ea3";
 674                   break;
 675                 case 4: /* orange */
 676                   color = "#ff7f00";
 677                   break;
 678                 case 5: /* yellow */
 679                   color = "#ffff33";
 680                   break;
 681                 case 6: /* brown */
 682                   color = "#a65628";
 683                   break;
 684                 case 7: /* rose */
 685                   color = "#f781bf";
 686                   break;
 687                 case 8:
 688                   color = "#8dd3c7";
 689                   break;
 690                 case 9:
 691                   color = "#ffffb3";
 692                   break;
 693                 case 10:
 694                   color = "#bebada";
 695                   break;
 696                 case 11:
 697                   color = "#fb8072";
 698                   break;
 699                 case 12:
 700                   color = "#80b1d3";
 701                   break;
 702                 case 13:
 703                   color = "#fdb462";
 704                   break;
 705                 case 14:
 706                   color = "#b3de69";
 707                   break;
 708                 case 15:
 709                   color = "#fccde5";
 710                   break;
 711                 case 16:
 712                   color = "#bc80bd";
 713                   break;
 714                 default: /* gray */
 715                   color = "#999999";
 716                 }
 717
 718               fprintf (file, "    <TR><TD WIDTH=\"50\" BGCOLOR=\"%s\">", color);
 719
 720               if (!refined_region_contains_bb_p (region, bb))
 721                 fprintf (file, " (");
 722
 723               if (bb == region->entry
 724                   && bb == region->exit)
 725                 fprintf (file, " %d*# ", bb->index);
 726               else if (bb == region->entry)
 727                 fprintf (file, " %d* ", bb->index);
 728               else if (bb == region->exit)
 729                 fprintf (file, " %d# ", bb->index);
 730               else
 731                 fprintf (file, " %d ", bb->index);
 732
 733               if (!refined_region_contains_bb_p (region, bb))
 734                 fprintf (file, ")");
 735
 736               fprintf (file, "</TD></TR>\n");
 737               part_of_scop  = true;
 738             }
 739         }
 740
 741       if (!part_of_scop)
 742         {
 743           fprintf (file, "    <TR><TD WIDTH=\"50\" BGCOLOR=\"#ffffff\">");
 744           fprintf (file, " %d </TD></TR>\n", bb->index);
 745         }
 746       fprintf (file, "  </TABLE>>, shape=box, style=\"setlinewidth(0)\"]\n");
 747     }
 748
 749   FOR_ALL_BB (bb)
 750   {
 751     FOR_EACH_EDGE (e, ei, bb->succs)
 752       fprintf (file, "%d -> %d;\n", bb->index, e->dest->index);
 753   }
 754
 755   fputs ("}\n\n", file);
 756
 757   /* Enable debugging again.  */
 758   dump_flags = tmp_dump_flags;
 759 }
 760
 761 /* Display refined REGIONS using dotty.  */
 762
 763 void
 764 dot_regions (VEC (refined_region_p, heap) *regions)
 765 {
 766   /* When debugging, enable the following code.  This cannot be used
 767      in production compilers because it calls "system".  */
 768 #if 1
 769   FILE *stream = fopen ("/tmp/regions.dot", "w");
 770   gcc_assert (stream);
 771
 772   dot_regions_1 (stream, regions);
 773   fclose (stream);
 774
 775   system ("dotty /tmp/regions.dot &");
 776 #else
 777   dot_all_scops_1 (stderr, regions);
 778 #endif
 779 }