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     case DEBUG_EXPR:
 525       sprintf (t, "D#%i", DEBUG_TEMP_UID (XTREE (x, 0)));
 526       cur = safe_concat (buf, cur, t);
 527       break;
 528     default:
 529       print_exp (t, x, verbose);
 530       cur = safe_concat (buf, cur, t);
 531       break;
 532     }
 533 }                               /* print_value */
 534
 535 /* The next step in insn detalization, its pattern recognition.  */
 536
 537 void
 538 print_pattern (char *buf, const_rtx x, int verbose)
 539 {
 540   char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
 541
 542   switch (GET_CODE (x))
 543     {
 544     case SET:
 545       print_value (t1, SET_DEST (x), verbose);
 546       print_value (t2, SET_SRC (x), verbose);
 547       sprintf (buf, "%s=%s", t1, t2);
 548       break;
 549     case RETURN:
 550       sprintf (buf, "return");
 551       break;
 552     case CALL:
 553       print_exp (buf, x, verbose);
 554       break;
 555     case CLOBBER:
 556       print_value (t1, XEXP (x, 0), verbose);
 557       sprintf (buf, "clobber %s", t1);
 558       break;
 559     case USE:
 560       print_value (t1, XEXP (x, 0), verbose);
 561       sprintf (buf, "use %s", t1);
 562       break;
 563     case VAR_LOCATION:
 564       print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose);
 565       sprintf (buf, "loc %s", t1);
 566       break;
 567     case COND_EXEC:
 568       if (GET_CODE (COND_EXEC_TEST (x)) == NE
 569           && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 570         print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
 571       else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
 572                && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 573         {
 574           t1[0] = '!';
 575           print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
 576         }
 577       else
 578         print_value (t1, COND_EXEC_TEST (x), verbose);
 579       print_pattern (t2, COND_EXEC_CODE (x), verbose);
 580       sprintf (buf, "(%s) %s", t1, t2);
 581       break;
 582     case PARALLEL:
 583       {
 584         int i;
 585
 586         sprintf (t1, "{");
 587         for (i = 0; i < XVECLEN (x, 0); i++)
 588           {
 589             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 590             sprintf (t3, "%s%s;", t1, t2);
 591             strcpy (t1, t3);
 592           }
 593         sprintf (buf, "%s}", t1);
 594       }
 595       break;
 596     case SEQUENCE:
 597       /* Should never see SEQUENCE codes until after reorg.  */
 598       gcc_unreachable ();
 599     case ASM_INPUT:
 600       sprintf (buf, "asm {%s}", XSTR (x, 0));
 601       break;
 602     case ADDR_VEC:
 603       break;
 604     case ADDR_DIFF_VEC:
 605       print_value (buf, XEXP (x, 0), verbose);
 606       break;
 607     case TRAP_IF:
 608       print_value (t1, TRAP_CONDITION (x), verbose);
 609       sprintf (buf, "trap_if %s", t1);
 610       break;
 611     case UNSPEC:
 612       {
 613         int i;
 614
 615         sprintf (t1, "unspec{");
 616         for (i = 0; i < XVECLEN (x, 0); i++)
 617           {
 618             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 619             sprintf (t3, "%s%s;", t1, t2);
 620             strcpy (t1, t3);
 621           }
 622         sprintf (buf, "%s}", t1);
 623       }
 624       break;
 625     case UNSPEC_VOLATILE:
 626       {
 627         int i;
 628
 629         sprintf (t1, "unspec/v{");
 630         for (i = 0; i < XVECLEN (x, 0); i++)
 631           {
 632             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 633             sprintf (t3, "%s%s;", t1, t2);
 634             strcpy (t1, t3);
 635           }
 636         sprintf (buf, "%s}", t1);
 637       }
 638       break;
 639     default:
 640       print_value (buf, x, verbose);
 641     }
 642 }                               /* print_pattern */
 643
 644 /* This is the main function in rtl visualization mechanism. It
 645    accepts an rtx and tries to recognize it as an insn, then prints it
 646    properly in human readable form, resembling assembler mnemonics.
 647    For every insn it prints its UID and BB the insn belongs too.
 648    (Probably the last "option" should be extended somehow, since it
 649    depends now on sched.c inner variables ...)  */
 650
 651 void
 652 print_insn (char *buf, const_rtx x, int verbose)
 653 {
 654   char t[BUF_LEN];
 655   const_rtx insn = x;
 656
 657   switch (GET_CODE (x))
 658     {
 659     case INSN:
 660       print_pattern (t, PATTERN (x), verbose);
 661 #ifdef INSN_SCHEDULING
 662       if (verbose && current_sched_info)
 663         sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
 664                  t);
 665       else
 666 #endif
 667         sprintf (buf, " %4d %s", INSN_UID (x), t);
 668       break;
 669
 670     case DEBUG_INSN:
 671       {
 672         const char *name = "?";
 673
 674         if (DECL_P (INSN_VAR_LOCATION_DECL (insn)))
 675           {
 676             tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn));
 677             char idbuf[32];
 678             if (id)
 679               name = IDENTIFIER_POINTER (id);
 680             else if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn))
 681                      == DEBUG_EXPR_DECL)
 682               {
 683                 sprintf (idbuf, "D#%i",
 684                          DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (insn)));
 685                 name = idbuf;
 686               }
 687             else
 688               {
 689                 sprintf (idbuf, "D.%i",
 690                          DECL_UID (INSN_VAR_LOCATION_DECL (insn)));
 691                 name = idbuf;
 692               }
 693           }
 694         if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)))
 695           sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name);
 696         else
 697           {
 698             print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose);
 699             sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t);
 700           }
 701       }
 702       break;
 703
 704     case JUMP_INSN:
 705       print_pattern (t, PATTERN (x), verbose);
 706 #ifdef INSN_SCHEDULING
 707       if (verbose && current_sched_info)
 708         sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
 709                  t);
 710       else
 711 #endif
 712         sprintf (buf, " %4d %s", INSN_UID (x), t);
 713       break;
 714     case CALL_INSN:
 715       x = PATTERN (insn);
 716       if (GET_CODE (x) == PARALLEL)
 717         {
 718           x = XVECEXP (x, 0, 0);
 719           print_pattern (t, x, verbose);
 720         }
 721       else
 722         strcpy (t, "call <...>");
 723 #ifdef INSN_SCHEDULING
 724       if (verbose && current_sched_info)
 725         sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
 726       else
 727 #endif
 728         sprintf (buf, " %4d %s", INSN_UID (insn), t);
 729       break;
 730     case CODE_LABEL:
 731       sprintf (buf, "L%d:", INSN_UID (x));
 732       break;
 733     case BARRIER:
 734       sprintf (buf, "i%4d: barrier", INSN_UID (x));
 735       break;
 736     case NOTE:
 737       sprintf (buf, " %4d %s", INSN_UID (x),
 738                GET_NOTE_INSN_NAME (NOTE_KIND (x)));
 739       break;
 740     default:
 741       sprintf (buf, "i%4d  <What %s?>", INSN_UID (x),
 742                GET_RTX_NAME (GET_CODE (x)));
 743     }
 744 }                               /* print_insn */
 745
 746 /* Emit a slim dump of X (an insn) to the file F, including any register
 747    note attached to the instruction.  */
 748 void
 749 dump_insn_slim (FILE *f, rtx x)
 750 {
 751   char t[BUF_LEN + 32];
 752   rtx note;
 753
 754   print_insn (t, x, 1);
 755   fputs (t, f);
 756   putc ('\n', f);
 757   if (INSN_P (x) && REG_NOTES (x))
 758     for (note = REG_NOTES (x); note; note = XEXP (note, 1))
 759       {
 760         print_value (t, XEXP (note, 0), 1);
 761         fprintf (f, "      %s: %s\n",
 762                  GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t);
 763       }
 764 }
 765
 766 /* Emit a slim dump of X (an insn) to stderr.  */
 767 void
 768 debug_insn_slim (rtx x)
 769 {
 770   dump_insn_slim (stderr, x);
 771 }
 772
 773 /* Provide a slim dump the instruction chain starting at FIRST to F, honoring
 774    the dump flags given in FLAGS.  Currently, TDF_BLOCKS and TDF_DETAILS
 775    include more information on the basic blocks.  */
 776 void
 777 print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
 778 {
 779   print_rtl_slim (f, first, NULL, -1, flags);
 780 }
 781
 782 /* Same as above, but stop at LAST or when COUNT == 0.
 783    If COUNT < 0 it will stop only at LAST or NULL rtx.  */
 784 void
 785 print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags)
 786 {
 787   basic_block current_bb = NULL;
 788   rtx insn, tail;
 789
 790   tail = last ? NEXT_INSN (last) : NULL_RTX;
 791   for (insn = first;
 792        (insn != NULL) && (insn != tail) && (count != 0);
 793        insn = NEXT_INSN (insn))
 794     {
 795       if ((flags & TDF_BLOCKS)
 796           && (INSN_P (insn) || NOTE_P (insn))
 797           && BLOCK_FOR_INSN (insn)
 798           && !current_bb)
 799         {
 800           current_bb = BLOCK_FOR_INSN (insn);
 801           dump_bb_info (current_bb, true, false, flags, ";; ", f);
 802         }
 803
 804       dump_insn_slim (f, insn);
 805
 806       if ((flags & TDF_BLOCKS)
 807           && current_bb
 808           && insn == BB_END (current_bb))
 809         {
 810           dump_bb_info (current_bb, false, true, flags, ";; ", f);
 811           current_bb = NULL;
 812         }
 813       if (count > 0)
 814         count--;
 815     }
 816 }
 817
 818 void
 819 debug_bb_slim (struct basic_block_def *bb)
 820 {
 821   print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
 822 }
 823
 824 void
 825 debug_bb_n_slim (int n)
 826 {
 827   struct basic_block_def *bb = BASIC_BLOCK (n);
 828   debug_bb_slim (bb);
 829 }
 830