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 "obstack.h"
  30 #include "hard-reg-set.h"
  31 #include "basic-block.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   if (!x)
 433     {
 434       safe_concat (buf, buf, "(nil)");
 435       return;
 436     }
 437   switch (GET_CODE (x))
 438     {
 439     case CONST_INT:
 440       sprintf (t, HOST_WIDE_INT_PRINT_HEX,
 441                (unsigned HOST_WIDE_INT) INTVAL (x));
 442       cur = safe_concat (buf, cur, t);
 443       break;
 444     case CONST_DOUBLE:
 445       if (FLOAT_MODE_P (GET_MODE (x)))
 446         real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
 447       else
 448         sprintf (t,
 449                  "<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">",
 450                  (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
 451                  (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
 452       cur = safe_concat (buf, cur, t);
 453       break;
 454     case CONST_FIXED:
 455       fixed_to_decimal (t, CONST_FIXED_VALUE (x), sizeof (t));
 456       cur = safe_concat (buf, cur, t);
 457       break;
 458     case CONST_STRING:
 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 SYMBOL_REF:
 464       cur = safe_concat (buf, cur, "`");
 465       cur = safe_concat (buf, cur, XSTR (x, 0));
 466       cur = safe_concat (buf, cur, "'");
 467       break;
 468     case LABEL_REF:
 469       sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
 470       cur = safe_concat (buf, cur, t);
 471       break;
 472     case CONST:
 473       print_value (t, XEXP (x, 0), verbose);
 474       cur = safe_concat (buf, cur, "const(");
 475       cur = safe_concat (buf, cur, t);
 476       cur = safe_concat (buf, cur, ")");
 477       break;
 478     case HIGH:
 479       print_value (t, XEXP (x, 0), verbose);
 480       cur = safe_concat (buf, cur, "high(");
 481       cur = safe_concat (buf, cur, t);
 482       cur = safe_concat (buf, cur, ")");
 483       break;
 484     case REG:
 485       if (REGNO (x) < FIRST_PSEUDO_REGISTER)
 486         {
 487           int c = reg_names[REGNO (x)][0];
 488           if (ISDIGIT (c))
 489             cur = safe_concat (buf, cur, "%");
 490
 491           cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
 492         }
 493       else
 494         {
 495           sprintf (t, "r%d", REGNO (x));
 496           cur = safe_concat (buf, cur, t);
 497         }
 498       if (verbose
 499 #ifdef INSN_SCHEDULING
 500           && !current_sched_info
 501 #endif
 502          )
 503         {
 504           sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x)));
 505           cur = safe_concat (buf, cur, t);
 506         }
 507       break;
 508     case SUBREG:
 509       print_value (t, SUBREG_REG (x), verbose);
 510       cur = safe_concat (buf, cur, t);
 511       sprintf (t, "#%d", SUBREG_BYTE (x));
 512       cur = safe_concat (buf, cur, t);
 513       break;
 514     case SCRATCH:
 515       cur = safe_concat (buf, cur, "scratch");
 516       break;
 517     case CC0:
 518       cur = safe_concat (buf, cur, "cc0");
 519       break;
 520     case PC:
 521       cur = safe_concat (buf, cur, "pc");
 522       break;
 523     case MEM:
 524       print_value (t, XEXP (x, 0), verbose);
 525       cur = safe_concat (buf, cur, "[");
 526       cur = safe_concat (buf, cur, t);
 527       cur = safe_concat (buf, cur, "]");
 528       break;
 529     case DEBUG_EXPR:
 530       sprintf (t, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
 531       cur = safe_concat (buf, cur, t);
 532       break;
 533     default:
 534       print_exp (t, x, verbose);
 535       cur = safe_concat (buf, cur, t);
 536       break;
 537     }
 538 }                               /* print_value */
 539
 540 /* The next step in insn detalization, its pattern recognition.  */
 541
 542 void
 543 print_pattern (char *buf, const_rtx x, int verbose)
 544 {
 545   char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
 546
 547   switch (GET_CODE (x))
 548     {
 549     case SET:
 550       print_value (t1, SET_DEST (x), verbose);
 551       print_value (t2, SET_SRC (x), verbose);
 552       sprintf (buf, "%s=%s", t1, t2);
 553       break;
 554     case RETURN:
 555       sprintf (buf, "return");
 556       break;
 557     case SIMPLE_RETURN:
 558       sprintf (buf, "simple_return");
 559       break;
 560     case CALL:
 561       print_exp (buf, x, verbose);
 562       break;
 563     case CLOBBER:
 564       print_value (t1, XEXP (x, 0), verbose);
 565       sprintf (buf, "clobber %s", t1);
 566       break;
 567     case USE:
 568       print_value (t1, XEXP (x, 0), verbose);
 569       sprintf (buf, "use %s", t1);
 570       break;
 571     case VAR_LOCATION:
 572       print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose);
 573       sprintf (buf, "loc %s", t1);
 574       break;
 575     case COND_EXEC:
 576       if (GET_CODE (COND_EXEC_TEST (x)) == NE
 577           && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 578         print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
 579       else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
 580                && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 581         {
 582           t1[0] = '!';
 583           print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
 584         }
 585       else
 586         print_value (t1, COND_EXEC_TEST (x), verbose);
 587       print_pattern (t2, COND_EXEC_CODE (x), verbose);
 588       sprintf (buf, "(%s) %s", t1, t2);
 589       break;
 590     case PARALLEL:
 591       {
 592         int i;
 593
 594         sprintf (t1, "{");
 595         for (i = 0; i < XVECLEN (x, 0); i++)
 596           {
 597             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 598             sprintf (t3, "%s%s;", t1, t2);
 599             strcpy (t1, t3);
 600           }
 601         sprintf (buf, "%s}", t1);
 602       }
 603       break;
 604     case SEQUENCE:
 605       /* Should never see SEQUENCE codes until after reorg.  */
 606       gcc_unreachable ();
 607     case ASM_INPUT:
 608       sprintf (buf, "asm {%s}", XSTR (x, 0));
 609       break;
 610     case ADDR_VEC:
 611       /* Fall through.  */
 612     case ADDR_DIFF_VEC:
 613       print_value (buf, XEXP (x, 0), verbose);
 614       break;
 615     case TRAP_IF:
 616       print_value (t1, TRAP_CONDITION (x), verbose);
 617       sprintf (buf, "trap_if %s", t1);
 618       break;
 619     case UNSPEC:
 620       {
 621         int i;
 622
 623         sprintf (t1, "unspec{");
 624         for (i = 0; i < XVECLEN (x, 0); i++)
 625           {
 626             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 627             sprintf (t3, "%s%s;", t1, t2);
 628             strcpy (t1, t3);
 629           }
 630         sprintf (buf, "%s}", t1);
 631       }
 632       break;
 633     case UNSPEC_VOLATILE:
 634       {
 635         int i;
 636
 637         sprintf (t1, "unspec/v{");
 638         for (i = 0; i < XVECLEN (x, 0); i++)
 639           {
 640             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 641             sprintf (t3, "%s%s;", t1, t2);
 642             strcpy (t1, t3);
 643           }
 644         sprintf (buf, "%s}", t1);
 645       }
 646       break;
 647     default:
 648       print_value (buf, x, verbose);
 649     }
 650 }                               /* print_pattern */
 651
 652 /* This is the main function in rtl visualization mechanism. It
 653    accepts an rtx and tries to recognize it as an insn, then prints it
 654    properly in human readable form, resembling assembler mnemonics.
 655    For every insn it prints its UID and BB the insn belongs too.
 656    (Probably the last "option" should be extended somehow, since it
 657    depends now on sched.c inner variables ...)  */
 658
 659 void
 660 print_insn (char *buf, const_rtx x, int verbose)
 661 {
 662   char t[BUF_LEN];
 663   const_rtx insn = x;
 664
 665   switch (GET_CODE (x))
 666     {
 667     case INSN:
 668       print_pattern (t, PATTERN (x), verbose);
 669 #ifdef INSN_SCHEDULING
 670       if (verbose && current_sched_info)
 671         sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
 672                  t);
 673       else
 674 #endif
 675         sprintf (buf, " %4d %s", INSN_UID (x), t);
 676       break;
 677
 678     case DEBUG_INSN:
 679       {
 680         const char *name = "?";
 681
 682         if (DECL_P (INSN_VAR_LOCATION_DECL (insn)))
 683           {
 684             tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn));
 685             char idbuf[32];
 686             if (id)
 687               name = IDENTIFIER_POINTER (id);
 688             else if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn))
 689                      == DEBUG_EXPR_DECL)
 690               {
 691                 sprintf (idbuf, "D#%i",
 692                          DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (insn)));
 693                 name = idbuf;
 694               }
 695             else
 696               {
 697                 sprintf (idbuf, "D.%i",
 698                          DECL_UID (INSN_VAR_LOCATION_DECL (insn)));
 699                 name = idbuf;
 700               }
 701           }
 702         if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)))
 703           sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name);
 704         else
 705           {
 706             print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose);
 707             sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t);
 708           }
 709       }
 710       break;
 711
 712     case JUMP_INSN:
 713       print_pattern (t, PATTERN (x), verbose);
 714 #ifdef INSN_SCHEDULING
 715       if (verbose && current_sched_info)
 716         sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
 717                  t);
 718       else
 719 #endif
 720         sprintf (buf, " %4d %s", INSN_UID (x), t);
 721       break;
 722     case CALL_INSN:
 723       x = PATTERN (insn);
 724       if (GET_CODE (x) == PARALLEL)
 725         {
 726           x = XVECEXP (x, 0, 0);
 727           print_pattern (t, x, verbose);
 728         }
 729       else
 730         strcpy (t, "call <...>");
 731 #ifdef INSN_SCHEDULING
 732       if (verbose && current_sched_info)
 733         sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
 734       else
 735 #endif
 736         sprintf (buf, " %4d %s", INSN_UID (insn), t);
 737       break;
 738     case CODE_LABEL:
 739       sprintf (buf, "L%d:", INSN_UID (x));
 740       break;
 741     case BARRIER:
 742       sprintf (buf, "i%4d: barrier", INSN_UID (x));
 743       break;
 744     case NOTE:
 745       sprintf (buf, " %4d %s", INSN_UID (x),
 746                GET_NOTE_INSN_NAME (NOTE_KIND (x)));
 747       break;
 748     default:
 749       sprintf (buf, "i%4d  <What %s?>", INSN_UID (x),
 750                GET_RTX_NAME (GET_CODE (x)));
 751     }
 752 }                               /* print_insn */
 753
 754 /* Emit a slim dump of X (an insn) to the file F, including any register
 755    note attached to the instruction.  */
 756 void
 757 dump_insn_slim (FILE *f, rtx x)
 758 {
 759   char t[BUF_LEN + 32];
 760   rtx note;
 761
 762   print_insn (t, x, 1);
 763   fputs (t, f);
 764   putc ('\n', f);
 765   if (INSN_P (x) && REG_NOTES (x))
 766     for (note = REG_NOTES (x); note; note = XEXP (note, 1))
 767       {
 768         print_value (t, XEXP (note, 0), 1);
 769         fprintf (f, "      %s: %s\n",
 770                  GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t);
 771       }
 772 }
 773
 774 /* Emit a slim dump of X (an insn) to stderr.  */
 775 DEBUG_FUNCTION void
 776 debug_insn_slim (rtx x)
 777 {
 778   dump_insn_slim (stderr, x);
 779 }
 780
 781 /* Provide a slim dump the instruction chain starting at FIRST to F, honoring
 782    the dump flags given in FLAGS.  Currently, TDF_BLOCKS and TDF_DETAILS
 783    include more information on the basic blocks.  */
 784 void
 785 print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
 786 {
 787   print_rtl_slim (f, first, NULL, -1, flags);
 788 }
 789
 790 /* Same as above, but stop at LAST or when COUNT == 0.
 791    If COUNT < 0 it will stop only at LAST or NULL rtx.  */
 792 void
 793 print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags)
 794 {
 795   basic_block current_bb = NULL;
 796   rtx insn, tail;
 797
 798   tail = last ? NEXT_INSN (last) : NULL_RTX;
 799   for (insn = first;
 800        (insn != NULL) && (insn != tail) && (count != 0);
 801        insn = NEXT_INSN (insn))
 802     {
 803       if ((flags & TDF_BLOCKS)
 804           && (INSN_P (insn) || NOTE_P (insn))
 805           && BLOCK_FOR_INSN (insn)
 806           && !current_bb)
 807         {
 808           current_bb = BLOCK_FOR_INSN (insn);
 809           dump_bb_info (current_bb, true, false, flags, ";; ", f);
 810         }
 811
 812       dump_insn_slim (f, insn);
 813
 814       if ((flags & TDF_BLOCKS)
 815           && current_bb
 816           && insn == BB_END (current_bb))
 817         {
 818           dump_bb_info (current_bb, false, true, flags, ";; ", f);
 819           current_bb = NULL;
 820         }
 821       if (count > 0)
 822         count--;
 823     }
 824 }
 825
 826 DEBUG_FUNCTION void
 827 debug_bb_slim (struct basic_block_def *bb)
 828 {
 829   print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
 830 }
 831
 832 DEBUG_FUNCTION void
 833 debug_bb_n_slim (int n)
 834 {
 835   struct basic_block_def *bb = BASIC_BLOCK (n);
 836   debug_bb_slim (bb);
 837 }
 838