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