gcc/sched-vis.c

   1 /* Instruction scheduling pass.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
   5    and currently maintained by, Jim Wilson (wilson@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22 \f
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "rtl.h"
  28 #include "obstack.h"
  29 #include "hard-reg-set.h"
  30 #include "basic-block.h"
  31 #include "real.h"
  32 #include "insn-attr.h"
  33 #include "sched-int.h"
  34 #include "tree-pass.h"
  35
  36 static char *safe_concat (char *, char *, const char *);
  37
  38 #define BUF_LEN 2048
  39
  40 static char *
  41 safe_concat (char *buf, char *cur, const char *str)
  42 {
  43   char *end = buf + BUF_LEN - 2;        /* Leave room for null.  */
  44   int c;
  45
  46   if (cur > end)
  47     {
  48       *end = '\0';
  49       return end;
  50     }
  51
  52   while (cur < end && (c = *str++) != '\0')
  53     *cur++ = c;
  54
  55   *cur = '\0';
  56   return cur;
  57 }
  58
  59 /* This recognizes rtx, I classified as expressions.  These are always
  60    represent some action on values or results of other expression, that
  61    may be stored in objects representing values.  */
  62
  63 static void
  64 print_exp (char *buf, const_rtx x, int verbose)
  65 {
  66   char tmp[BUF_LEN];
  67   const char *st[4];
  68   char *cur = buf;
  69   const char *fun = (char *) 0;
  70   const char *sep;
  71   rtx op[4];
  72   int i;
  73
  74   for (i = 0; i < 4; i++)
  75     {
  76       st[i] = (char *) 0;
  77       op[i] = NULL_RTX;
  78     }
  79
  80   switch (GET_CODE (x))
  81     {
  82     case PLUS:
  83       op[0] = XEXP (x, 0);
  84       if (CONST_INT_P (XEXP (x, 1))
  85           && INTVAL (XEXP (x, 1)) < 0)
  86         {
  87           st[1] = "-";
  88           op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
  89         }
  90       else
  91         {
  92           st[1] = "+";
  93           op[1] = XEXP (x, 1);
  94         }
  95       break;
  96     case LO_SUM:
  97       op[0] = XEXP (x, 0);
  98       st[1] = "+low(";
  99       op[1] = XEXP (x, 1);
 100       st[2] = ")";
 101       break;
 102     case MINUS:
 103       op[0] = XEXP (x, 0);
 104       st[1] = "-";
 105       op[1] = XEXP (x, 1);
 106       break;
 107     case COMPARE:
 108       fun = "cmp";
 109       op[0] = XEXP (x, 0);
 110       op[1] = XEXP (x, 1);
 111       break;
 112     case NEG:
 113       st[0] = "-";
 114       op[0] = XEXP (x, 0);
 115       break;
 116     case MULT:
 117       op[0] = XEXP (x, 0);
 118       st[1] = "*";
 119       op[1] = XEXP (x, 1);
 120       break;
 121     case DIV:
 122       op[0] = XEXP (x, 0);
 123       st[1] = "/";
 124       op[1] = XEXP (x, 1);
 125       break;
 126     case UDIV:
 127       fun = "udiv";
 128       op[0] = XEXP (x, 0);
 129       op[1] = XEXP (x, 1);
 130       break;
 131     case MOD:
 132       op[0] = XEXP (x, 0);
 133       st[1] = "%";
 134       op[1] = XEXP (x, 1);
 135       break;
 136     case UMOD:
 137       fun = "umod";
 138       op[0] = XEXP (x, 0);
 139       op[1] = XEXP (x, 1);
 140       break;
 141     case SMIN:
 142       fun = "smin";
 143       op[0] = XEXP (x, 0);
 144       op[1] = XEXP (x, 1);
 145       break;
 146     case SMAX:
 147       fun = "smax";
 148       op[0] = XEXP (x, 0);
 149       op[1] = XEXP (x, 1);
 150       break;
 151     case UMIN:
 152       fun = "umin";
 153       op[0] = XEXP (x, 0);
 154       op[1] = XEXP (x, 1);
 155       break;
 156     case UMAX:
 157       fun = "umax";
 158       op[0] = XEXP (x, 0);
 159       op[1] = XEXP (x, 1);
 160       break;
 161     case NOT:
 162       st[0] = "!";
 163       op[0] = XEXP (x, 0);
 164       break;
 165     case AND:
 166       op[0] = XEXP (x, 0);
 167       st[1] = "&";
 168       op[1] = XEXP (x, 1);
 169       break;
 170     case IOR:
 171       op[0] = XEXP (x, 0);
 172       st[1] = "|";
 173       op[1] = XEXP (x, 1);
 174       break;
 175     case XOR:
 176       op[0] = XEXP (x, 0);
 177       st[1] = "^";
 178       op[1] = XEXP (x, 1);
 179       break;
 180     case ASHIFT:
 181       op[0] = XEXP (x, 0);
 182       st[1] = "<<";
 183       op[1] = XEXP (x, 1);
 184       break;
 185     case LSHIFTRT:
 186       op[0] = XEXP (x, 0);
 187       st[1] = " 0>>";
 188       op[1] = XEXP (x, 1);
 189       break;
 190     case ASHIFTRT:
 191       op[0] = XEXP (x, 0);
 192       st[1] = ">>";
 193       op[1] = XEXP (x, 1);
 194       break;
 195     case ROTATE:
 196       op[0] = XEXP (x, 0);
 197       st[1] = "<-<";
 198       op[1] = XEXP (x, 1);
 199       break;
 200     case ROTATERT:
 201       op[0] = XEXP (x, 0);
 202       st[1] = ">->";
 203       op[1] = XEXP (x, 1);
 204       break;
 205     case ABS:
 206       fun = "abs";
 207       op[0] = XEXP (x, 0);
 208       break;
 209     case SQRT:
 210       fun = "sqrt";
 211       op[0] = XEXP (x, 0);
 212       break;
 213     case FFS:
 214       fun = "ffs";
 215       op[0] = XEXP (x, 0);
 216       break;
 217     case EQ:
 218       op[0] = XEXP (x, 0);
 219       st[1] = "==";
 220       op[1] = XEXP (x, 1);
 221       break;
 222     case NE:
 223       op[0] = XEXP (x, 0);
 224       st[1] = "!=";
 225       op[1] = XEXP (x, 1);
 226       break;
 227     case GT:
 228       op[0] = XEXP (x, 0);
 229       st[1] = ">";
 230       op[1] = XEXP (x, 1);
 231       break;
 232     case GTU:
 233       fun = "gtu";
 234       op[0] = XEXP (x, 0);
 235       op[1] = XEXP (x, 1);
 236       break;
 237     case LT:
 238       op[0] = XEXP (x, 0);
 239       st[1] = "<";
 240       op[1] = XEXP (x, 1);
 241       break;
 242     case LTU:
 243       fun = "ltu";
 244       op[0] = XEXP (x, 0);
 245       op[1] = XEXP (x, 1);
 246       break;
 247     case GE:
 248       op[0] = XEXP (x, 0);
 249       st[1] = ">=";
 250       op[1] = XEXP (x, 1);
 251       break;
 252     case GEU:
 253       fun = "geu";
 254       op[0] = XEXP (x, 0);
 255       op[1] = XEXP (x, 1);
 256       break;
 257     case LE:
 258       op[0] = XEXP (x, 0);
 259       st[1] = "<=";
 260       op[1] = XEXP (x, 1);
 261       break;
 262     case LEU:
 263       fun = "leu";
 264       op[0] = XEXP (x, 0);
 265       op[1] = XEXP (x, 1);
 266       break;
 267     case SIGN_EXTRACT:
 268       fun = (verbose) ? "sign_extract" : "sxt";
 269       op[0] = XEXP (x, 0);
 270       op[1] = XEXP (x, 1);
 271       op[2] = XEXP (x, 2);
 272       break;
 273     case ZERO_EXTRACT:
 274       fun = (verbose) ? "zero_extract" : "zxt";
 275       op[0] = XEXP (x, 0);
 276       op[1] = XEXP (x, 1);
 277       op[2] = XEXP (x, 2);
 278       break;
 279     case SIGN_EXTEND:
 280       fun = (verbose) ? "sign_extend" : "sxn";
 281       op[0] = XEXP (x, 0);
 282       break;
 283     case ZERO_EXTEND:
 284       fun = (verbose) ? "zero_extend" : "zxn";
 285       op[0] = XEXP (x, 0);
 286       break;
 287     case FLOAT_EXTEND:
 288       fun = (verbose) ? "float_extend" : "fxn";
 289       op[0] = XEXP (x, 0);
 290       break;
 291     case TRUNCATE:
 292       fun = (verbose) ? "trunc" : "trn";
 293       op[0] = XEXP (x, 0);
 294       break;
 295     case FLOAT_TRUNCATE:
 296       fun = (verbose) ? "float_trunc" : "ftr";
 297       op[0] = XEXP (x, 0);
 298       break;
 299     case FLOAT:
 300       fun = (verbose) ? "float" : "flt";
 301       op[0] = XEXP (x, 0);
 302       break;
 303     case UNSIGNED_FLOAT:
 304       fun = (verbose) ? "uns_float" : "ufl";
 305       op[0] = XEXP (x, 0);
 306       break;
 307     case FIX:
 308       fun = "fix";
 309       op[0] = XEXP (x, 0);
 310       break;
 311     case UNSIGNED_FIX:
 312       fun = (verbose) ? "uns_fix" : "ufx";
 313       op[0] = XEXP (x, 0);
 314       break;
 315     case PRE_DEC:
 316       st[0] = "--";
 317       op[0] = XEXP (x, 0);
 318       break;
 319     case PRE_INC:
 320       st[0] = "++";
 321       op[0] = XEXP (x, 0);
 322       break;
 323     case POST_DEC:
 324       op[0] = XEXP (x, 0);
 325       st[1] = "--";
 326       break;
 327     case POST_INC:
 328       op[0] = XEXP (x, 0);
 329       st[1] = "++";
 330       break;
 331     case PRE_MODIFY:
 332       st[0] = "pre ";
 333       op[0] = XEXP (XEXP (x, 1), 0);
 334       st[1] = "+=";
 335       op[1] = XEXP (XEXP (x, 1), 1);
 336       break;
 337     case POST_MODIFY:
 338       st[0] = "post ";
 339       op[0] = XEXP (XEXP (x, 1), 0);
 340       st[1] = "+=";
 341       op[1] = XEXP (XEXP (x, 1), 1);
 342       break;
 343     case CALL:
 344       st[0] = "call ";
 345       op[0] = XEXP (x, 0);
 346       if (verbose)
 347         {
 348           st[1] = " argc:";
 349           op[1] = XEXP (x, 1);
 350         }
 351       break;
 352     case IF_THEN_ELSE:
 353       st[0] = "{(";
 354       op[0] = XEXP (x, 0);
 355       st[1] = ")?";
 356       op[1] = XEXP (x, 1);
 357       st[2] = ":";
 358       op[2] = XEXP (x, 2);
 359       st[3] = "}";
 360       break;
 361     case TRAP_IF:
 362       fun = "trap_if";
 363       op[0] = TRAP_CONDITION (x);
 364       break;
 365     case PREFETCH:
 366       fun = "prefetch";
 367       op[0] = XEXP (x, 0);
 368       op[1] = XEXP (x, 1);
 369       op[2] = XEXP (x, 2);
 370       break;
 371     case UNSPEC:
 372     case UNSPEC_VOLATILE:
 373       {
 374         cur = safe_concat (buf, cur, "unspec");
 375         if (GET_CODE (x) == UNSPEC_VOLATILE)
 376           cur = safe_concat (buf, cur, "/v");
 377         cur = safe_concat (buf, cur, "[");
 378         sep = "";
 379         for (i = 0; i < XVECLEN (x, 0); i++)
 380           {
 381             print_pattern (tmp, XVECEXP (x, 0, i), verbose);
 382             cur = safe_concat (buf, cur, sep);
 383             cur = safe_concat (buf, cur, tmp);
 384             sep = ",";
 385           }
 386         cur = safe_concat (buf, cur, "] ");
 387         sprintf (tmp, "%d", XINT (x, 1));
 388         cur = safe_concat (buf, cur, tmp);
 389       }
 390       break;
 391     default:
 392       /* If (verbose) debug_rtx (x);  */
 393       st[0] = GET_RTX_NAME (GET_CODE (x));
 394       break;
 395     }
 396
 397   /* Print this as a function?  */
 398   if (fun)
 399     {
 400       cur = safe_concat (buf, cur, fun);
 401       cur = safe_concat (buf, cur, "(");
 402     }
 403
 404   for (i = 0; i < 4; i++)
 405     {
 406       if (st[i])
 407         cur = safe_concat (buf, cur, st[i]);
 408
 409       if (op[i])
 410         {
 411           if (fun && i != 0)
 412             cur = safe_concat (buf, cur, ",");
 413
 414           print_value (tmp, op[i], verbose);
 415           cur = safe_concat (buf, cur, tmp);
 416         }
 417     }
 418
 419   if (fun)
 420     cur = safe_concat (buf, cur, ")");
 421 }               /* print_exp */
 422
 423 /* Prints rtxes, I customarily classified as values.  They're constants,
 424    registers, labels, symbols and memory accesses.  */
 425
 426 void
 427 print_value (char *buf, const_rtx x, int verbose)
 428 {
 429   char t[BUF_LEN];
 430   char *cur = buf;
 431
 432   switch (GET_CODE (x))
 433     {
 434     case CONST_INT:
 435       sprintf (t, HOST_WIDE_INT_PRINT_HEX,
 436                (unsigned HOST_WIDE_INT) INTVAL (x));
 437       cur = safe_concat (buf, cur, t);
 438       break;
 439     case CONST_DOUBLE:
 440       if (FLOAT_MODE_P (GET_MODE (x)))
 441         real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
 442       else
 443         sprintf (t,
 444                  "<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">",
 445                  (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
 446                  (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
 447       cur = safe_concat (buf, cur, t);
 448       break;
 449     case CONST_FIXED:
 450       fixed_to_decimal (t, CONST_FIXED_VALUE (x), sizeof (t));
 451       cur = safe_concat (buf, cur, t);
 452       break;
 453     case CONST_STRING:
 454       cur = safe_concat (buf, cur, "\"");
 455       cur = safe_concat (buf, cur, XSTR (x, 0));
 456       cur = safe_concat (buf, cur, "\"");
 457       break;
 458     case SYMBOL_REF:
 459       cur = safe_concat (buf, cur, "`");
 460       cur = safe_concat (buf, cur, XSTR (x, 0));
 461       cur = safe_concat (buf, cur, "'");
 462       break;
 463     case LABEL_REF:
 464       sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
 465       cur = safe_concat (buf, cur, t);
 466       break;
 467     case CONST:
 468       print_value (t, XEXP (x, 0), verbose);
 469       cur = safe_concat (buf, cur, "const(");
 470       cur = safe_concat (buf, cur, t);
 471       cur = safe_concat (buf, cur, ")");
 472       break;
 473     case HIGH:
 474       print_value (t, XEXP (x, 0), verbose);
 475       cur = safe_concat (buf, cur, "high(");
 476       cur = safe_concat (buf, cur, t);
 477       cur = safe_concat (buf, cur, ")");
 478       break;
 479     case REG:
 480       if (REGNO (x) < FIRST_PSEUDO_REGISTER)
 481         {
 482           int c = reg_names[REGNO (x)][0];
 483           if (ISDIGIT (c))
 484             cur = safe_concat (buf, cur, "%");
 485
 486           cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
 487         }
 488       else
 489         {
 490           sprintf (t, "r%d", REGNO (x));
 491           cur = safe_concat (buf, cur, t);
 492         }
 493       if (verbose
 494 #ifdef INSN_SCHEDULING
 495           && !current_sched_info
 496 #endif
 497          )
 498         {
 499           sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x)));
 500           cur = safe_concat (buf, cur, t);
 501         }
 502       break;
 503     case SUBREG:
 504       print_value (t, SUBREG_REG (x), verbose);
 505       cur = safe_concat (buf, cur, t);
 506       sprintf (t, "#%d", SUBREG_BYTE (x));
 507       cur = safe_concat (buf, cur, t);
 508       break;
 509     case SCRATCH:
 510       cur = safe_concat (buf, cur, "scratch");
 511       break;
 512     case CC0:
 513       cur = safe_concat (buf, cur, "cc0");
 514       break;
 515     case PC:
 516       cur = safe_concat (buf, cur, "pc");
 517       break;
 518     case MEM:
 519       print_value (t, XEXP (x, 0), verbose);
 520       cur = safe_concat (buf, cur, "[");
 521       cur = safe_concat (buf, cur, t);
 522       cur = safe_concat (buf, cur, "]");
 523       break;
 524     default:
 525       print_exp (t, x, verbose);
 526       cur = safe_concat (buf, cur, t);
 527       break;
 528     }
 529 }                               /* print_value */
 530
 531 /* The next step in insn detalization, its pattern recognition.  */
 532
 533 void
 534 print_pattern (char *buf, const_rtx x, int verbose)
 535 {
 536   char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
 537
 538   switch (GET_CODE (x))
 539     {
 540     case SET:
 541       print_value (t1, SET_DEST (x), verbose);
 542       print_value (t2, SET_SRC (x), verbose);
 543       sprintf (buf, "%s=%s", t1, t2);
 544       break;
 545     case RETURN:
 546       sprintf (buf, "return");
 547       break;
 548     case CALL:
 549       print_exp (buf, x, verbose);
 550       break;
 551     case CLOBBER:
 552       print_value (t1, XEXP (x, 0), verbose);
 553       sprintf (buf, "clobber %s", t1);
 554       break;
 555     case USE:
 556       print_value (t1, XEXP (x, 0), verbose);
 557       sprintf (buf, "use %s", t1);
 558       break;
 559     case VAR_LOCATION:
 560       print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose);
 561       sprintf (buf, "loc %s", t1);
 562       break;
 563     case COND_EXEC:
 564       if (GET_CODE (COND_EXEC_TEST (x)) == NE
 565           && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 566         print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
 567       else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
 568                && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 569         {
 570           t1[0] = '!';
 571           print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
 572         }
 573       else
 574         print_value (t1, COND_EXEC_TEST (x), verbose);
 575       print_pattern (t2, COND_EXEC_CODE (x), verbose);
 576       sprintf (buf, "(%s) %s", t1, t2);
 577       break;
 578     case PARALLEL:
 579       {
 580         int i;
 581
 582         sprintf (t1, "{");
 583         for (i = 0; i < XVECLEN (x, 0); i++)
 584           {
 585             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 586             sprintf (t3, "%s%s;", t1, t2);
 587             strcpy (t1, t3);
 588           }
 589         sprintf (buf, "%s}", t1);
 590       }
 591       break;
 592     case SEQUENCE:
 593       /* Should never see SEQUENCE codes until after reorg.  */
 594       gcc_unreachable ();
 595     case ASM_INPUT:
 596       sprintf (buf, "asm {%s}", XSTR (x, 0));
 597       break;
 598     case ADDR_VEC:
 599       break;
 600     case ADDR_DIFF_VEC:
 601       print_value (buf, XEXP (x, 0), verbose);
 602       break;
 603     case TRAP_IF:
 604       print_value (t1, TRAP_CONDITION (x), verbose);
 605       sprintf (buf, "trap_if %s", t1);
 606       break;
 607     case UNSPEC:
 608       {
 609         int i;
 610
 611         sprintf (t1, "unspec{");
 612         for (i = 0; i < XVECLEN (x, 0); i++)
 613           {
 614             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 615             sprintf (t3, "%s%s;", t1, t2);
 616             strcpy (t1, t3);
 617           }
 618         sprintf (buf, "%s}", t1);
 619       }
 620       break;
 621     case UNSPEC_VOLATILE:
 622       {
 623         int i;
 624
 625         sprintf (t1, "unspec/v{");
 626         for (i = 0; i < XVECLEN (x, 0); i++)
 627           {
 628             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 629             sprintf (t3, "%s%s;", t1, t2);
 630             strcpy (t1, t3);
 631           }
 632         sprintf (buf, "%s}", t1);
 633       }
 634       break;
 635     default:
 636       print_value (buf, x, verbose);
 637     }
 638 }                               /* print_pattern */
 639
 640 /* This is the main function in rtl visualization mechanism. It
 641    accepts an rtx and tries to recognize it as an insn, then prints it
 642    properly in human readable form, resembling assembler mnemonics.
 643    For every insn it prints its UID and BB the insn belongs too.
 644    (Probably the last "option" should be extended somehow, since it
 645    depends now on sched.c inner variables ...)  */
 646
 647 void
 648 print_insn (char *buf, const_rtx x, int verbose)
 649 {
 650   char t[BUF_LEN];
 651   const_rtx insn = x;
 652
 653   switch (GET_CODE (x))
 654     {
 655     case INSN:
 656       print_pattern (t, PATTERN (x), verbose);
 657 #ifdef INSN_SCHEDULING
 658       if (verbose && current_sched_info)
 659         sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
 660                  t);
 661       else
 662 #endif
 663         sprintf (buf, " %4d %s", INSN_UID (x), t);
 664       break;
 665
 666     case DEBUG_INSN:
 667       {
 668         const char *name = "?";
 669
 670         if (DECL_P (INSN_VAR_LOCATION_DECL (insn)))
 671           {
 672             tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn));
 673             if (id)
 674               name = IDENTIFIER_POINTER (id);
 675             else
 676               {
 677                 char idbuf[32];
 678                 sprintf (idbuf, "D.%i",
 679                          DECL_UID (INSN_VAR_LOCATION_DECL (insn)));
 680                 name = idbuf;
 681               }
 682           }
 683         if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)))
 684           sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name);
 685         else
 686           {
 687             print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose);
 688             sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t);
 689           }
 690       }
 691       break;
 692
 693     case JUMP_INSN:
 694       print_pattern (t, PATTERN (x), verbose);
 695 #ifdef INSN_SCHEDULING
 696       if (verbose && current_sched_info)
 697         sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
 698                  t);
 699       else
 700 #endif
 701         sprintf (buf, " %4d %s", INSN_UID (x), t);
 702       break;
 703     case CALL_INSN:
 704       x = PATTERN (insn);
 705       if (GET_CODE (x) == PARALLEL)
 706         {
 707           x = XVECEXP (x, 0, 0);
 708           print_pattern (t, x, verbose);
 709         }
 710       else
 711         strcpy (t, "call <...>");
 712 #ifdef INSN_SCHEDULING
 713       if (verbose && current_sched_info)
 714         sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
 715       else
 716 #endif
 717         sprintf (buf, " %4d %s", INSN_UID (insn), t);
 718       break;
 719     case CODE_LABEL:
 720       sprintf (buf, "L%d:", INSN_UID (x));
 721       break;
 722     case BARRIER:
 723       sprintf (buf, "i%4d: barrier", INSN_UID (x));
 724       break;
 725     case NOTE:
 726       sprintf (buf, " %4d %s", INSN_UID (x),
 727                GET_NOTE_INSN_NAME (NOTE_KIND (x)));
 728       break;
 729     default:
 730       sprintf (buf, "i%4d  <What %s?>", INSN_UID (x),
 731                GET_RTX_NAME (GET_CODE (x)));
 732     }
 733 }                               /* print_insn */
 734
 735 /* Emit a slim dump of X (an insn) to the file F, including any register
 736    note attached to the instruction.  */
 737 void
 738 dump_insn_slim (FILE *f, rtx x)
 739 {
 740   char t[BUF_LEN + 32];
 741   rtx note;
 742
 743   print_insn (t, x, 1);
 744   fputs (t, f);
 745   putc ('\n', f);
 746   if (INSN_P (x) && REG_NOTES (x))
 747     for (note = REG_NOTES (x); note; note = XEXP (note, 1))
 748       {
 749         print_value (t, XEXP (note, 0), 1);
 750         fprintf (f, "      %s: %s\n",
 751                  GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t);
 752       }
 753 }
 754
 755 /* Emit a slim dump of X (an insn) to stderr.  */
 756 void
 757 debug_insn_slim (rtx x)
 758 {
 759   dump_insn_slim (stderr, x);
 760 }
 761
 762 /* Provide a slim dump the instruction chain starting at FIRST to F, honoring
 763    the dump flags given in FLAGS.  Currently, TDF_BLOCKS and TDF_DETAILS
 764    include more information on the basic blocks.  */
 765 void
 766 print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
 767 {
 768   print_rtl_slim (f, first, NULL, -1, flags);
 769 }
 770
 771 /* Same as above, but stop at LAST or when COUNT == 0.
 772    If COUNT < 0 it will stop only at LAST or NULL rtx.  */
 773 void
 774 print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags)
 775 {
 776   basic_block current_bb = NULL;
 777   rtx insn, tail;
 778
 779   tail = last ? NEXT_INSN (last) : NULL_RTX;
 780   for (insn = first;
 781        (insn != NULL) && (insn != tail) && (count != 0);
 782        insn = NEXT_INSN (insn))
 783     {
 784       if ((flags & TDF_BLOCKS)
 785           && (INSN_P (insn) || NOTE_P (insn))
 786           && BLOCK_FOR_INSN (insn)
 787           && !current_bb)
 788         {
 789           current_bb = BLOCK_FOR_INSN (insn);
 790           dump_bb_info (current_bb, true, false, flags, ";; ", f);
 791         }
 792
 793       dump_insn_slim (f, insn);
 794
 795       if ((flags & TDF_BLOCKS)
 796           && current_bb
 797           && insn == BB_END (current_bb))
 798         {
 799           dump_bb_info (current_bb, false, true, flags, ";; ", f);
 800           current_bb = NULL;
 801         }
 802       if (count > 0)
 803         count--;
 804     }
 805 }
 806
 807 void
 808 debug_bb_slim (struct basic_block_def *bb)
 809 {
 810   print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
 811 }
 812
 813 void
 814 debug_bb_n_slim (int n)
 815 {
 816   struct basic_block_def *bb = BASIC_BLOCK (n);
 817   debug_bb_slim (bb);
 818 }
 819