gcc/sel-sched-dump.c

   1 /* Instruction scheduling pass.   Log dumping infrastructure.
   2    Copyright (C) 2006-2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "diagnostic-core.h"
  25 #include "rtl.h"
  26 #include "tm_p.h"
  27 #include "hard-reg-set.h"
  28 #include "regs.h"
  29 #include "hashtab.h"
  30 #include "hash-set.h"
  31 #include "vec.h"
  32 #include "machmode.h"
  33 #include "input.h"
  34 #include "function.h"
  35 #include "predict.h"
  36 #include "dominance.h"
  37 #include "cfg.h"
  38 #include "basic-block.h"
  39 #include "flags.h"
  40 #include "insn-config.h"
  41 #include "insn-attr.h"
  42 #include "params.h"
  43 #include "cselib.h"
  44 #include "target.h"
  45
  46 #ifdef INSN_SCHEDULING
  47 #include "sel-sched-ir.h"
  48 #include "sel-sched-dump.h"
  49 \f
  50
  51 /* These variables control high-level pretty printing.  */
  52 static int sel_dump_cfg_flags = SEL_DUMP_CFG_FLAGS;
  53 static int sel_debug_cfg_flags = SEL_DUMP_CFG_FLAGS;
  54
  55 /* True when a cfg should be dumped.  */
  56 static bool sel_dump_cfg_p;
  57
  58 /* Variables that are used to build the cfg dump file name.  */
  59 static const char * const sel_debug_cfg_root = "./";
  60 static const char * const sel_debug_cfg_root_postfix_default = "";
  61 static const char *sel_debug_cfg_root_postfix = "";
  62 static int sel_dump_cfg_fileno = -1;
  63 static int sel_debug_cfg_fileno = -1;
  64
  65 /* When this flag is on, we are dumping to the .dot file.
  66    When it is off, we are dumping to log.
  67    This is useful to differentiate formatting between log and .dot
  68    files.  */
  69 bool sched_dump_to_dot_p = false;
  70
  71 /* Controls how insns from a fence list should be dumped.  */
  72 static int dump_flist_insn_flags = (DUMP_INSN_UID | DUMP_INSN_BBN
  73                                     | DUMP_INSN_SEQNO);
  74 \f
  75
  76 /* The variable used to hold the value of sched_dump when temporarily
  77    switching dump output to the other source, e.g. the .dot file.  */
  78 static FILE *saved_sched_dump = NULL;
  79
  80 /* Switch sched_dump to TO.  It must not be called twice.  */
  81 static void
  82 switch_dump (FILE *to)
  83 {
  84   gcc_assert (saved_sched_dump == NULL);
  85
  86   saved_sched_dump = sched_dump;
  87   sched_dump = to;
  88 }
  89
  90 /* Restore previously switched dump.  */
  91 static void
  92 restore_dump (void)
  93 {
  94   sched_dump = saved_sched_dump;
  95   saved_sched_dump = NULL;
  96 }
  97 \f
  98
  99 /* Functions for dumping instructions, av sets, and exprs.  */
 100
 101 /* Default flags for dumping insns.  */
 102 static int dump_insn_rtx_flags = DUMP_INSN_RTX_UID | DUMP_INSN_RTX_PATTERN;
 103
 104 /* Default flags for dumping vinsns.  */
 105 static int dump_vinsn_flags = (DUMP_VINSN_INSN_RTX | DUMP_VINSN_TYPE
 106                                | DUMP_VINSN_COUNT);
 107
 108 /* Default flags for dumping expressions.  */
 109 static int dump_expr_flags = DUMP_EXPR_ALL;
 110
 111 /* Default flags for dumping insns when debugging.  */
 112 static int debug_insn_rtx_flags = DUMP_INSN_RTX_ALL;
 113
 114 /* Default flags for dumping vinsns when debugging.  */
 115 static int debug_vinsn_flags = DUMP_VINSN_ALL;
 116
 117 /* Default flags for dumping expressions when debugging.  */
 118 static int debug_expr_flags = DUMP_EXPR_ALL;
 119
 120 /* Controls how an insn from stream should be dumped when debugging.  */
 121 static int debug_insn_flags = DUMP_INSN_ALL;
 122
 123 /* Print an rtx X.  */
 124 void
 125 sel_print_rtl (rtx x)
 126 {
 127   print_rtl_single (sched_dump, x);
 128 }
 129
 130 /* Dump insn INSN honoring FLAGS.  */
 131 void
 132 dump_insn_rtx_1 (rtx insn, int flags)
 133 {
 134   int all;
 135
 136   /* flags == -1 also means dumping all.  */
 137   all = (flags & 1);;
 138   if (all)
 139     flags |= DUMP_INSN_RTX_ALL;
 140
 141   sel_print ("(");
 142
 143   if (flags & DUMP_INSN_RTX_UID)
 144     sel_print ("%d;", INSN_UID (insn));
 145
 146   if (flags & DUMP_INSN_RTX_PATTERN)
 147     sel_print ("%s;", str_pattern_slim (PATTERN (insn)));
 148
 149   if (flags & DUMP_INSN_RTX_BBN)
 150     {
 151       basic_block bb = BLOCK_FOR_INSN (insn);
 152
 153       sel_print ("bb:%d;", bb != NULL ? bb->index : -1);
 154     }
 155
 156   sel_print (")");
 157 }
 158
 159
 160 /* Dump INSN with default flags.  */
 161 void
 162 dump_insn_rtx (rtx insn)
 163 {
 164   dump_insn_rtx_1 (insn, dump_insn_rtx_flags);
 165 }
 166
 167
 168 /* Dump INSN to stderr.  */
 169 DEBUG_FUNCTION void
 170 debug_insn_rtx (rtx insn)
 171 {
 172   switch_dump (stderr);
 173   dump_insn_rtx_1 (insn, debug_insn_rtx_flags);
 174   sel_print ("\n");
 175   restore_dump ();
 176 }
 177
 178 /* Dump vinsn VI honoring flags.  */
 179 void
 180 dump_vinsn_1 (vinsn_t vi, int flags)
 181 {
 182   int all;
 183
 184   /* flags == -1 also means dumping all.  */
 185   all = flags & 1;
 186   if (all)
 187     flags |= DUMP_VINSN_ALL;
 188
 189   sel_print ("(");
 190
 191   if (flags & DUMP_VINSN_INSN_RTX)
 192     dump_insn_rtx_1 (VINSN_INSN_RTX (vi), dump_insn_rtx_flags | all);
 193
 194   if (flags & DUMP_VINSN_TYPE)
 195     sel_print ("type:%s;", GET_RTX_NAME (VINSN_TYPE (vi)));
 196
 197   if (flags & DUMP_VINSN_COUNT)
 198     sel_print ("count:%d;", VINSN_COUNT (vi));
 199
 200   if (flags & DUMP_VINSN_COST)
 201     {
 202       int cost = vi->cost;
 203
 204       if (cost != -1)
 205         sel_print ("cost:%d;", cost);
 206     }
 207
 208   sel_print (")");
 209 }
 210
 211 /* Dump vinsn VI with default flags.  */
 212 void
 213 dump_vinsn (vinsn_t vi)
 214 {
 215   dump_vinsn_1 (vi, dump_vinsn_flags);
 216 }
 217
 218 DEBUG_FUNCTION void
 219 debug (vinsn_def &ref)
 220 {
 221   switch_dump (stderr);
 222   dump_vinsn_1 (&ref, dump_vinsn_flags);
 223   sel_print ("\n");
 224   restore_dump ();
 225 }
 226
 227 DEBUG_FUNCTION void
 228 debug (vinsn_def *ptr)
 229 {
 230   if (ptr)
 231     debug (*ptr);
 232   else
 233     fprintf (stderr, "<nil>\n");
 234 }
 235
 236 DEBUG_FUNCTION void
 237 debug_verbose (vinsn_def &ref)
 238 {
 239   switch_dump (stderr);
 240   dump_vinsn_1 (&ref, debug_vinsn_flags);
 241   sel_print ("\n");
 242   restore_dump ();
 243 }
 244
 245 DEBUG_FUNCTION void
 246 debug_verbose (vinsn_def *ptr)
 247 {
 248   if (ptr)
 249     debug (*ptr);
 250   else
 251     fprintf (stderr, "<nil>\n");
 252 }
 253
 254 /* Dump vinsn VI to stderr.  */
 255 DEBUG_FUNCTION void
 256 debug_vinsn (vinsn_t vi)
 257 {
 258   switch_dump (stderr);
 259   dump_vinsn_1 (vi, debug_vinsn_flags);
 260   sel_print ("\n");
 261   restore_dump ();
 262 }
 263
 264 /* Dump EXPR honoring flags.  */
 265 void
 266 dump_expr_1 (expr_t expr, int flags)
 267 {
 268   int all;
 269
 270   /* flags == -1 also means dumping all.  */
 271   all = flags & 1;
 272   if (all)
 273     flags |= DUMP_EXPR_ALL;
 274
 275   sel_print ("[");
 276
 277   if (flags & DUMP_EXPR_VINSN)
 278     dump_vinsn_1 (EXPR_VINSN (expr), dump_vinsn_flags | all);
 279
 280   if (flags & DUMP_EXPR_SPEC)
 281     {
 282       int spec = EXPR_SPEC (expr);
 283
 284       if (spec != 0)
 285         sel_print ("spec:%d;", spec);
 286     }
 287
 288   if (flags & DUMP_EXPR_USEFULNESS)
 289     {
 290       int use = EXPR_USEFULNESS (expr);
 291
 292       if (use != REG_BR_PROB_BASE)
 293         sel_print ("use:%d;", use);
 294     }
 295
 296   if (flags & DUMP_EXPR_PRIORITY)
 297     sel_print ("prio:%d;", EXPR_PRIORITY (expr));
 298
 299   if (flags & DUMP_EXPR_SCHED_TIMES)
 300     {
 301       int times = EXPR_SCHED_TIMES (expr);
 302
 303       if (times != 0)
 304         sel_print ("times:%d;", times);
 305     }
 306
 307   if (flags & DUMP_EXPR_SPEC_DONE_DS)
 308     {
 309       ds_t spec_done_ds = EXPR_SPEC_DONE_DS (expr);
 310
 311       if (spec_done_ds != 0)
 312         sel_print ("ds:%d;", spec_done_ds);
 313     }
 314
 315   if (flags & DUMP_EXPR_ORIG_BB)
 316     {
 317       int orig_bb = EXPR_ORIG_BB_INDEX (expr);
 318
 319       if (orig_bb != 0)
 320         sel_print ("orig_bb:%d;", orig_bb);
 321     }
 322
 323   if (EXPR_TARGET_AVAILABLE (expr) < 1)
 324     sel_print ("target:%d;", EXPR_TARGET_AVAILABLE (expr));
 325   sel_print ("]");
 326 }
 327
 328 /* Dump expression EXPR with default flags.  */
 329 void
 330 dump_expr (expr_t expr)
 331 {
 332   dump_expr_1 (expr, dump_expr_flags);
 333 }
 334
 335 /* Dump expression EXPR to stderr.  */
 336 DEBUG_FUNCTION void
 337 debug_expr (expr_t expr)
 338 {
 339   switch_dump (stderr);
 340   dump_expr_1 (expr, debug_expr_flags);
 341   sel_print ("\n");
 342   restore_dump ();
 343 }
 344
 345 /* Dump expression REF.  */
 346
 347 DEBUG_FUNCTION void
 348 debug (expr_def &ref)
 349 {
 350   switch_dump (stderr);
 351   dump_expr_1 (&ref, 0);
 352   sel_print ("\n");
 353   restore_dump ();
 354 }
 355
 356 DEBUG_FUNCTION void
 357 debug (expr_def *ptr)
 358 {
 359   if (ptr)
 360     debug (*ptr);
 361   else
 362     fprintf (stderr, "<nil>\n");
 363 }
 364
 365 /* Dump expression REF verbosely.  */
 366
 367 DEBUG_FUNCTION void
 368 debug_verbose (expr_def &ref)
 369 {
 370   switch_dump (stderr);
 371   dump_expr_1 (&ref, DUMP_EXPR_ALL);
 372   sel_print ("\n");
 373   restore_dump ();
 374 }
 375
 376 DEBUG_FUNCTION void
 377 debug_verbose (expr_def *ptr)
 378 {
 379   if (ptr)
 380     debug_verbose (*ptr);
 381   else
 382     fprintf (stderr, "<nil>\n");
 383 }
 384
 385 /* Dump insn I honoring FLAGS.  */
 386 void
 387 dump_insn_1 (insn_t i, int flags)
 388 {
 389   int all;
 390
 391   all = flags & 1;
 392   if (all)
 393     flags |= DUMP_INSN_ALL;
 394
 395   if (!sched_dump_to_dot_p)
 396     sel_print ("(");
 397
 398   if (flags & DUMP_INSN_EXPR)
 399     {
 400       dump_expr_1 (INSN_EXPR (i), dump_expr_flags | all);
 401       sel_print (";");
 402     }
 403   else if (flags & DUMP_INSN_PATTERN)
 404     {
 405       dump_insn_rtx_1 (i, DUMP_INSN_RTX_PATTERN | all);
 406       sel_print (";");
 407     }
 408   else if (flags & DUMP_INSN_UID)
 409     sel_print ("uid:%d;", INSN_UID (i));
 410
 411   if (flags & DUMP_INSN_SEQNO)
 412     sel_print ("seqno:%d;", INSN_SEQNO (i));
 413
 414   if (flags & DUMP_INSN_SCHED_CYCLE)
 415     {
 416       int cycle = INSN_SCHED_CYCLE (i);
 417
 418       if (cycle != 0)
 419         sel_print ("cycle:%d;", cycle);
 420     }
 421
 422   if (!sched_dump_to_dot_p)
 423     sel_print (")");
 424 }
 425
 426 /* Dump insn I with default flags.  */
 427 void
 428 dump_insn (insn_t i)
 429 {
 430   dump_insn_1 (i, DUMP_INSN_EXPR | DUMP_INSN_SCHED_CYCLE);
 431 }
 432
 433 /* Dump INSN to stderr.  */
 434 DEBUG_FUNCTION void
 435 debug_insn (insn_t insn)
 436 {
 437   switch_dump (stderr);
 438   dump_insn_1 (insn, debug_insn_flags);
 439   sel_print ("\n");
 440   restore_dump ();
 441 }
 442
 443 /* Dumps av_set AV.  */
 444 void
 445 dump_av_set (av_set_t av)
 446 {
 447   av_set_iterator i;
 448   expr_t expr;
 449
 450   if (!sched_dump_to_dot_p)
 451     sel_print ("{");
 452
 453   FOR_EACH_EXPR (expr, i, av)
 454     {
 455       dump_expr (expr);
 456       if (!sched_dump_to_dot_p)
 457         sel_print (" ");
 458       else
 459         sel_print ("\n");
 460     }
 461
 462   if (!sched_dump_to_dot_p)
 463     sel_print ("}");
 464 }
 465
 466 /* Dumps lvset LV.  */
 467 void
 468 dump_lv_set (regset lv)
 469 {
 470   sel_print ("{");
 471
 472   /* This code was adapted from cfg.c: dump_regset ().  */
 473   if (lv == NULL)
 474     sel_print ("nil");
 475   else
 476     {
 477       unsigned i;
 478       reg_set_iterator rsi;
 479       int count = 0;
 480
 481       EXECUTE_IF_SET_IN_REG_SET (lv, 0, i, rsi)
 482         {
 483           sel_print (" %d", i);
 484           if (i < FIRST_PSEUDO_REGISTER)
 485             {
 486               sel_print (" [%s]", reg_names[i]);
 487               ++count;
 488             }
 489
 490           ++count;
 491
 492           if (sched_dump_to_dot_p && count == 12)
 493             {
 494               count = 0;
 495               sel_print ("\n");
 496             }
 497         }
 498     }
 499
 500   sel_print ("}\n");
 501 }
 502
 503 /* Dumps a list of instructions pointed to by P.  */
 504 static void
 505 dump_ilist (ilist_t p)
 506 {
 507   while (p)
 508     {
 509       dump_insn (ILIST_INSN (p));
 510       p = ILIST_NEXT (p);
 511     }
 512 }
 513
 514 /* Dumps a list of boundaries pointed to by BNDS.  */
 515 void
 516 dump_blist (blist_t bnds)
 517 {
 518   for (; bnds; bnds = BLIST_NEXT (bnds))
 519     {
 520       bnd_t bnd = BLIST_BND (bnds);
 521
 522       sel_print ("[to: %d; ptr: ", INSN_UID (BND_TO (bnd)));
 523       dump_ilist (BND_PTR (bnd));
 524       sel_print ("] ");
 525     }
 526 }
 527
 528 /* Dumps a list of fences pointed to by L.  */
 529 void
 530 dump_flist (flist_t l)
 531 {
 532   while (l)
 533     {
 534       dump_insn_1 (FENCE_INSN (FLIST_FENCE (l)), dump_flist_insn_flags);
 535       sel_print (" ");
 536       l = FLIST_NEXT (l);
 537     }
 538 }
 539
 540 /* Dumps an insn vector SUCCS.  */
 541 void
 542 dump_insn_vector (rtx_vec_t succs)
 543 {
 544   int i;
 545   rtx_insn *succ;
 546
 547   FOR_EACH_VEC_ELT (succs, i, succ)
 548     if (succ)
 549       dump_insn (succ);
 550     else
 551       sel_print ("NULL ");
 552 }
 553
 554 /* Dumps a hard reg set SET to FILE using PREFIX.  */
 555 static void
 556 print_hard_reg_set (FILE *file, const char *prefix, HARD_REG_SET set)
 557 {
 558   int i;
 559
 560   fprintf (file, "%s{ ", prefix);
 561   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 562     {
 563       if (TEST_HARD_REG_BIT (set, i))
 564         fprintf (file, "%d ", i);
 565     }
 566   fprintf (file, "}\n");
 567 }
 568
 569 /* Dumps a hard reg set SET using PREFIX.  */
 570 void
 571 dump_hard_reg_set (const char *prefix, HARD_REG_SET set)
 572 {
 573   print_hard_reg_set (sched_dump, prefix, set);
 574 }
 575
 576 /* Pretty print INSN.  This is used as a hook.  */
 577 const char *
 578 sel_print_insn (const rtx_insn *insn, int aligned ATTRIBUTE_UNUSED)
 579 {
 580   static char buf[80];
 581
 582   /* '+' before insn means it is a new cycle start and it's not been
 583      scheduled yet.  '>' - has been scheduled.  */
 584   if (s_i_d.exists () && INSN_LUID (insn) > 0)
 585     if (GET_MODE (insn) == TImode)
 586       sprintf (buf, "%s %4d",
 587                INSN_SCHED_TIMES (insn) > 0 ? "> " : "< ",
 588                INSN_UID (insn));
 589     else
 590       sprintf (buf, "%s %4d",
 591                INSN_SCHED_TIMES (insn) > 0 ? "! " : "  ",
 592                INSN_UID (insn));
 593   else
 594     if (GET_MODE (insn) == TImode)
 595       sprintf (buf, "+ %4d", INSN_UID (insn));
 596     else
 597       sprintf (buf, "  %4d", INSN_UID (insn));
 598
 599   return buf;
 600 }
 601 \f
 602
 603 /* Functions for pretty printing of CFG.  */
 604 /* FIXME: Using pretty-print here could simplify this stuff.  */
 605
 606 /* Replace all occurencies of STR1 to STR2 in BUF.
 607    The BUF must be large enough to hold the result.  */
 608 static void
 609 replace_str_in_buf (char *buf, const char *str1, const char *str2)
 610 {
 611   int buf_len = strlen (buf);
 612   int str1_len = strlen (str1);
 613   int str2_len = strlen (str2);
 614   int diff = str2_len - str1_len;
 615
 616   char *p = buf;
 617   do
 618     {
 619       p = strstr (p, str1);
 620       if (p)
 621         {
 622           char *p1 = p + str1_len;
 623           /* Copy the rest of buf and '\0'.  */
 624           int n = buf + buf_len - p1;
 625           int i;
 626
 627           /* Shift str by DIFF chars.  */
 628           if (diff > 0)
 629             for (i = n; i >= 0; i--)
 630               p1[i + diff] = p1[i];
 631           else
 632             for (i = 0; i <= n; i++)
 633               p1[i + diff] = p1[i];
 634
 635           /* Copy str2.  */
 636           for (i = 0; i < str2_len; i++)
 637             p[i] = str2[i];
 638
 639           p += str2_len;
 640           buf_len += diff;
 641         }
 642
 643     }
 644   while (p);
 645 }
 646
 647 /* Replace characters in BUF that have special meaning in .dot file.
 648    Similar to pp_write_text_as_dot_label_to_stream.  */
 649 static void
 650 sel_prepare_string_for_dot_label (char *buf)
 651 {
 652   static char specials_from[7][2] = { "<", ">", "{", "|", "}", "\"",
 653                                       "\n" };
 654   static char specials_to[7][3] = { "\\<", "\\>", "\\{", "\\|", "\\}",
 655                                     "\\\"", "\\l" };
 656   unsigned i;
 657
 658   for (i = 0; i < 7; i++)
 659     replace_str_in_buf (buf, specials_from[i], specials_to[i]);
 660 }
 661
 662 /* This function acts like printf but dumps to the sched_dump file.  */
 663 void
 664 sel_print (const char *fmt, ...)
 665 {
 666   va_list ap;
 667   va_start (ap, fmt);
 668   if (sched_dump_to_dot_p)
 669     {
 670       char *message;
 671       if (vasprintf (&message, fmt, ap) >= 0 && message != NULL)
 672         {
 673           message = (char *) xrealloc (message, 2 * strlen (message) + 1);
 674           sel_prepare_string_for_dot_label (message);
 675           fprintf (sched_dump, "%s", message);
 676           free (message);
 677         }
 678     }
 679   else
 680     vfprintf (sched_dump, fmt, ap);
 681   va_end (ap);
 682 }
 683
 684 /* Dump INSN with FLAGS.  */
 685 static void
 686 sel_dump_cfg_insn (insn_t insn, int flags)
 687 {
 688   int insn_flags = DUMP_INSN_UID | DUMP_INSN_PATTERN;
 689
 690   if (sched_luids.exists () && INSN_LUID (insn) > 0)
 691     {
 692       if (flags & SEL_DUMP_CFG_INSN_SEQNO)
 693         insn_flags |= DUMP_INSN_SEQNO | DUMP_INSN_SCHED_CYCLE | DUMP_INSN_EXPR;
 694     }
 695
 696   dump_insn_1 (insn, insn_flags);
 697 }
 698
 699 /* Dump E to the dot file F.  */
 700 static void
 701 sel_dump_cfg_edge (FILE *f, edge e)
 702 {
 703   int w;
 704   const char *color;
 705
 706   if (e->flags & EDGE_FALLTHRU)
 707     {
 708       w = 10;
 709       color = ", color = red";
 710     }
 711   else if (e->src->next_bb == e->dest)
 712     {
 713       w = 3;
 714       color = ", color = blue";
 715     }
 716   else
 717     {
 718       w = 1;
 719       color = "";
 720     }
 721
 722   fprintf (f, "\tbb%d -> bb%d [weight = %d%s];\n",
 723            e->src->index, e->dest->index, w, color);
 724 }
 725
 726
 727 /* Return true if BB has a predesessor from current region.
 728    TODO: Either make this function to trace back through empty block
 729    or just remove those empty blocks.  */
 730 static bool
 731 has_preds_in_current_region_p (basic_block bb)
 732 {
 733   edge e;
 734   edge_iterator ei;
 735
 736   gcc_assert (!in_current_region_p (bb));
 737
 738   FOR_EACH_EDGE (e, ei, bb->preds)
 739     if (in_current_region_p (e->src))
 740       return true;
 741
 742   return false;
 743 }
 744
 745 /* Dump a cfg region to the dot file F honoring FLAGS.  */
 746 static void
 747 sel_dump_cfg_2 (FILE *f, int flags)
 748 {
 749   basic_block bb;
 750
 751   sched_dump_to_dot_p = true;
 752   switch_dump (f);
 753
 754   fprintf (f, "digraph G {\n"
 755            "\tratio = 2.25;\n"
 756            "\tnode [shape = record, fontsize = 9];\n");
 757
 758   if (flags & SEL_DUMP_CFG_FUNCTION_NAME)
 759     fprintf (f, "function [label = \"%s\"];\n", current_function_name ());
 760
 761   FOR_EACH_BB_FN (bb, cfun)
 762     {
 763       insn_t insn = BB_HEAD (bb);
 764       insn_t next_tail = NEXT_INSN (BB_END (bb));
 765       edge e;
 766       edge_iterator ei;
 767       bool in_region_p = ((flags & SEL_DUMP_CFG_CURRENT_REGION)
 768                           && in_current_region_p (bb));
 769       bool full_p = (!(flags & SEL_DUMP_CFG_CURRENT_REGION)
 770                      || in_region_p);
 771       bool some_p = full_p || has_preds_in_current_region_p (bb);
 772       const char *color;
 773       const char *style;
 774
 775       if (!some_p)
 776         continue;
 777
 778       if ((flags & SEL_DUMP_CFG_CURRENT_REGION)
 779           && in_current_region_p (bb)
 780           && BLOCK_TO_BB (bb->index) == 0)
 781         color = "color = green, ";
 782       else
 783         color = "";
 784
 785       if ((flags & SEL_DUMP_CFG_FENCES)
 786           && in_region_p)
 787         {
 788           style = "";
 789
 790           if (!sel_bb_empty_p (bb))
 791             {
 792               bool first_p = true;
 793               insn_t tail = BB_END (bb);
 794               insn_t cur_insn;
 795
 796               cur_insn = bb_note (bb);
 797
 798               do
 799                 {
 800                   fence_t fence;
 801
 802                   cur_insn = NEXT_INSN (cur_insn);
 803                   fence = flist_lookup (fences, cur_insn);
 804
 805                   if (fence != NULL)
 806                     {
 807                       if (!FENCE_SCHEDULED_P (fence))
 808                         {
 809                           if (first_p)
 810                             color = "color = red, ";
 811                           else
 812                             color = "color = yellow, ";
 813                         }
 814                       else
 815                         color = "color = blue, ";
 816                     }
 817
 818                   first_p = false;
 819                 }
 820               while (cur_insn != tail);
 821             }
 822         }
 823       else if (!full_p)
 824         style = "style = dashed, ";
 825       else
 826         style = "";
 827
 828       fprintf (f, "\tbb%d [%s%slabel = \"{Basic block %d", bb->index,
 829                style, color, bb->index);
 830
 831       if ((flags & SEL_DUMP_CFG_BB_LOOP)
 832           && bb->loop_father != NULL)
 833         fprintf (f, ", loop %d", bb->loop_father->num);
 834
 835       if (full_p
 836           && (flags & SEL_DUMP_CFG_BB_NOTES_LIST))
 837         {
 838           insn_t notes = BB_NOTE_LIST (bb);
 839
 840           if (notes != NULL_RTX)
 841             {
 842               fprintf (f, "|");
 843
 844               /* For simplicity, we dump notes from note_list in reversed order
 845                  to that what they will appear in the code.  */
 846               while (notes != NULL_RTX)
 847                 {
 848                   sel_dump_cfg_insn (notes, flags);
 849                   fprintf (f, "\\l");
 850
 851                   notes = PREV_INSN (notes);
 852                 }
 853             }
 854         }
 855
 856       if (full_p
 857           && (flags & SEL_DUMP_CFG_AV_SET)
 858           && in_current_region_p (bb)
 859           && !sel_bb_empty_p (bb))
 860         {
 861           fprintf (f, "|");
 862
 863           if (BB_AV_SET_VALID_P (bb))
 864             dump_av_set (BB_AV_SET (bb));
 865           else if (BB_AV_LEVEL (bb) == -1)
 866             fprintf (f, "AV_SET needs update");
 867         }
 868
 869       if ((flags & SEL_DUMP_CFG_LV_SET)
 870           && !sel_bb_empty_p (bb))
 871         {
 872           fprintf (f, "|");
 873
 874           if (BB_LV_SET_VALID_P (bb))
 875             dump_lv_set (BB_LV_SET (bb));
 876           else
 877             fprintf (f, "LV_SET needs update");
 878         }
 879
 880       if (full_p
 881           && (flags & SEL_DUMP_CFG_BB_INSNS))
 882         {
 883           fprintf (f, "|");
 884           while (insn != next_tail)
 885             {
 886               sel_dump_cfg_insn (insn, flags);
 887               fprintf (f, "\\l");
 888
 889               insn = NEXT_INSN (insn);
 890             }
 891         }
 892
 893       fprintf (f, "}\"];\n");
 894
 895       FOR_EACH_EDGE (e, ei, bb->succs)
 896         if (full_p || in_current_region_p (e->dest))
 897           sel_dump_cfg_edge (f, e);
 898     }
 899
 900   fprintf (f, "}");
 901
 902   restore_dump ();
 903   sched_dump_to_dot_p = false;
 904 }
 905
 906 /* Dump a cfg region to the file specified by TAG honoring flags.
 907    The file is created by the function.  */
 908 static void
 909 sel_dump_cfg_1 (const char *tag, int flags)
 910 {
 911   char *buf;
 912   int i;
 913   FILE *f;
 914
 915   ++sel_dump_cfg_fileno;
 916
 917   if (!sel_dump_cfg_p)
 918     return;
 919
 920   i = 1 + snprintf (NULL, 0, "%s/%s%05d-%s.dot", sel_debug_cfg_root,
 921                     sel_debug_cfg_root_postfix, sel_dump_cfg_fileno, tag);
 922   buf = XNEWVEC (char, i);
 923   snprintf (buf, i, "%s/%s%05d-%s.dot", sel_debug_cfg_root,
 924             sel_debug_cfg_root_postfix, sel_dump_cfg_fileno, tag);
 925
 926   f = fopen (buf, "w");
 927
 928   if (f == NULL)
 929     fprintf (stderr, "Can't create file: %s.\n", buf);
 930   else
 931     {
 932       sel_dump_cfg_2 (f, flags);
 933
 934       fclose (f);
 935     }
 936
 937   free (buf);
 938 }
 939
 940 /* Setup cfg dumping flags.  Used for debugging.  */
 941 void
 942 setup_dump_cfg_params (void)
 943 {
 944   sel_dump_cfg_flags = SEL_DUMP_CFG_FLAGS;
 945   sel_dump_cfg_p = 0;
 946   sel_debug_cfg_root_postfix = sel_debug_cfg_root_postfix_default;
 947 }
 948
 949 /* Debug a cfg region with FLAGS.  */
 950 void
 951 sel_debug_cfg_1 (int flags)
 952 {
 953   bool t1 = sel_dump_cfg_p;
 954   int t2 = sel_dump_cfg_fileno;
 955
 956   sel_dump_cfg_p = true;
 957   sel_dump_cfg_fileno = ++sel_debug_cfg_fileno;
 958
 959   sel_dump_cfg_1 ("sel-debug-cfg", flags);
 960
 961   sel_dump_cfg_fileno = t2;
 962   sel_dump_cfg_p = t1;
 963 }
 964 \f
 965 /* Dumps av_set AV to stderr.  */
 966 DEBUG_FUNCTION void
 967 debug_av_set (av_set_t av)
 968 {
 969   switch_dump (stderr);
 970   dump_av_set (av);
 971   sel_print ("\n");
 972   restore_dump ();
 973 }
 974
 975 /* Dump LV to stderr.  */
 976 DEBUG_FUNCTION void
 977 debug_lv_set (regset lv)
 978 {
 979   switch_dump (stderr);
 980   dump_lv_set (lv);
 981   sel_print ("\n");
 982   restore_dump ();
 983 }
 984
 985 /* Dump an instruction list P to stderr.  */
 986 DEBUG_FUNCTION void
 987 debug_ilist (ilist_t p)
 988 {
 989   switch_dump (stderr);
 990   dump_ilist (p);
 991   sel_print ("\n");
 992   restore_dump ();
 993 }
 994
 995 /* Dump a boundary list BNDS to stderr.  */
 996 DEBUG_FUNCTION void
 997 debug_blist (blist_t bnds)
 998 {
 999   switch_dump (stderr);
1000   dump_blist (bnds);
1001   sel_print ("\n");
1002   restore_dump ();
1003 }
1004
1005 /* Dump a rtx vector REF.  */
1006 DEBUG_FUNCTION void
1007 debug (vec<rtx_insn *> &ref)
1008 {
1009   switch_dump (stderr);
1010   dump_insn_vector (ref);
1011   sel_print ("\n");
1012   restore_dump ();
1013 }
1014
1015 DEBUG_FUNCTION void
1016 debug (vec<rtx_insn *> *ptr)
1017 {
1018   if (ptr)
1019     debug (*ptr);
1020   else
1021     fprintf (stderr, "<nil>\n");
1022 }
1023
1024 /* Dump an insn vector SUCCS.  */
1025 DEBUG_FUNCTION void
1026 debug_insn_vector (rtx_vec_t succs)
1027 {
1028   switch_dump (stderr);
1029   dump_insn_vector (succs);
1030   sel_print ("\n");
1031   restore_dump ();
1032 }
1033
1034 /* Dump a hard reg set SET to stderr.  */
1035 DEBUG_FUNCTION void
1036 debug_hard_reg_set (HARD_REG_SET set)
1037 {
1038   switch_dump (stderr);
1039   dump_hard_reg_set ("", set);
1040   sel_print ("\n");
1041   restore_dump ();
1042 }
1043
1044 /* Debug a cfg region with default flags.  */
1045 void
1046 sel_debug_cfg (void)
1047 {
1048   sel_debug_cfg_1 (sel_debug_cfg_flags);
1049 }
1050
1051 /* Print a current cselib value for X's address to stderr.  */
1052 DEBUG_FUNCTION rtx
1053 debug_mem_addr_value (rtx x)
1054 {
1055   rtx t, addr;
1056   machine_mode address_mode;
1057
1058   gcc_assert (MEM_P (x));
1059   address_mode = get_address_mode (x);
1060
1061   t = shallow_copy_rtx (x);
1062   if (cselib_lookup (XEXP (t, 0), address_mode, 0, GET_MODE (t)))
1063     XEXP (t, 0) = cselib_subst_to_values (XEXP (t, 0), GET_MODE (t));
1064
1065   t = canon_rtx (t);
1066   addr = get_addr (XEXP (t, 0));
1067   debug_rtx (t);
1068   debug_rtx (addr);
1069   return t;
1070 }
1071 #endif
1072