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 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 2, 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 COPYING.  If not, write to the Free
  21 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  22 02110-1301, USA.  */
  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 "real.h"
  33 #include "sched-int.h"
  34 #include "tree-pass.h"
  35
  36 static char *safe_concat (char *, char *, const char *);
  37 static void print_exp (char *, rtx, int);
  38 static void print_value (char *, rtx, int);
  39 static void print_pattern (char *, rtx, int);
  40
  41 #define BUF_LEN 2048
  42
  43 static char *
  44 safe_concat (char *buf, char *cur, const char *str)
  45 {
  46   char *end = buf + BUF_LEN - 2;        /* Leave room for null.  */
  47   int c;
  48
  49   if (cur > end)
  50     {
  51       *end = '\0';
  52       return end;
  53     }
  54
  55   while (cur < end && (c = *str++) != '\0')
  56     *cur++ = c;
  57
  58   *cur = '\0';
  59   return cur;
  60 }
  61
  62 /* This recognizes rtx, I classified as expressions.  These are always
  63    represent some action on values or results of other expression, that
  64    may be stored in objects representing values.  */
  65
  66 static void
  67 print_exp (char *buf, rtx x, int verbose)
  68 {
  69   char tmp[BUF_LEN];
  70   const char *st[4];
  71   char *cur = buf;
  72   const char *fun = (char *) 0;
  73   const char *sep;
  74   rtx op[4];
  75   int i;
  76
  77   for (i = 0; i < 4; i++)
  78     {
  79       st[i] = (char *) 0;
  80       op[i] = NULL_RTX;
  81     }
  82
  83   switch (GET_CODE (x))
  84     {
  85     case PLUS:
  86       op[0] = XEXP (x, 0);
  87       if (GET_CODE (XEXP (x, 1)) == CONST_INT
  88           && INTVAL (XEXP (x, 1)) < 0)
  89         {
  90           st[1] = "-";
  91           op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
  92         }
  93       else
  94         {
  95           st[1] = "+";
  96           op[1] = XEXP (x, 1);
  97         }
  98       break;
  99     case LO_SUM:
 100       op[0] = XEXP (x, 0);
 101       st[1] = "+low(";
 102       op[1] = XEXP (x, 1);
 103       st[2] = ")";
 104       break;
 105     case MINUS:
 106       op[0] = XEXP (x, 0);
 107       st[1] = "-";
 108       op[1] = XEXP (x, 1);
 109       break;
 110     case COMPARE:
 111       fun = "cmp";
 112       op[0] = XEXP (x, 0);
 113       op[1] = XEXP (x, 1);
 114       break;
 115     case NEG:
 116       st[0] = "-";
 117       op[0] = XEXP (x, 0);
 118       break;
 119     case MULT:
 120       op[0] = XEXP (x, 0);
 121       st[1] = "*";
 122       op[1] = XEXP (x, 1);
 123       break;
 124     case DIV:
 125       op[0] = XEXP (x, 0);
 126       st[1] = "/";
 127       op[1] = XEXP (x, 1);
 128       break;
 129     case UDIV:
 130       fun = "udiv";
 131       op[0] = XEXP (x, 0);
 132       op[1] = XEXP (x, 1);
 133       break;
 134     case MOD:
 135       op[0] = XEXP (x, 0);
 136       st[1] = "%";
 137       op[1] = XEXP (x, 1);
 138       break;
 139     case UMOD:
 140       fun = "umod";
 141       op[0] = XEXP (x, 0);
 142       op[1] = XEXP (x, 1);
 143       break;
 144     case SMIN:
 145       fun = "smin";
 146       op[0] = XEXP (x, 0);
 147       op[1] = XEXP (x, 1);
 148       break;
 149     case SMAX:
 150       fun = "smax";
 151       op[0] = XEXP (x, 0);
 152       op[1] = XEXP (x, 1);
 153       break;
 154     case UMIN:
 155       fun = "umin";
 156       op[0] = XEXP (x, 0);
 157       op[1] = XEXP (x, 1);
 158       break;
 159     case UMAX:
 160       fun = "umax";
 161       op[0] = XEXP (x, 0);
 162       op[1] = XEXP (x, 1);
 163       break;
 164     case NOT:
 165       st[0] = "!";
 166       op[0] = XEXP (x, 0);
 167       break;
 168     case AND:
 169       op[0] = XEXP (x, 0);
 170       st[1] = "&";
 171       op[1] = XEXP (x, 1);
 172       break;
 173     case IOR:
 174       op[0] = XEXP (x, 0);
 175       st[1] = "|";
 176       op[1] = XEXP (x, 1);
 177       break;
 178     case XOR:
 179       op[0] = XEXP (x, 0);
 180       st[1] = "^";
 181       op[1] = XEXP (x, 1);
 182       break;
 183     case ASHIFT:
 184       op[0] = XEXP (x, 0);
 185       st[1] = "<<";
 186       op[1] = XEXP (x, 1);
 187       break;
 188     case LSHIFTRT:
 189       op[0] = XEXP (x, 0);
 190       st[1] = " 0>>";
 191       op[1] = XEXP (x, 1);
 192       break;
 193     case ASHIFTRT:
 194       op[0] = XEXP (x, 0);
 195       st[1] = ">>";
 196       op[1] = XEXP (x, 1);
 197       break;
 198     case ROTATE:
 199       op[0] = XEXP (x, 0);
 200       st[1] = "<-<";
 201       op[1] = XEXP (x, 1);
 202       break;
 203     case ROTATERT:
 204       op[0] = XEXP (x, 0);
 205       st[1] = ">->";
 206       op[1] = XEXP (x, 1);
 207       break;
 208     case ABS:
 209       fun = "abs";
 210       op[0] = XEXP (x, 0);
 211       break;
 212     case SQRT:
 213       fun = "sqrt";
 214       op[0] = XEXP (x, 0);
 215       break;
 216     case FFS:
 217       fun = "ffs";
 218       op[0] = XEXP (x, 0);
 219       break;
 220     case EQ:
 221       op[0] = XEXP (x, 0);
 222       st[1] = "==";
 223       op[1] = XEXP (x, 1);
 224       break;
 225     case NE:
 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 GTU:
 236       fun = "gtu";
 237       op[0] = XEXP (x, 0);
 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 LTU:
 246       fun = "ltu";
 247       op[0] = XEXP (x, 0);
 248       op[1] = XEXP (x, 1);
 249       break;
 250     case GE:
 251       op[0] = XEXP (x, 0);
 252       st[1] = ">=";
 253       op[1] = XEXP (x, 1);
 254       break;
 255     case GEU:
 256       fun = "geu";
 257       op[0] = XEXP (x, 0);
 258       op[1] = XEXP (x, 1);
 259       break;
 260     case LE:
 261       op[0] = XEXP (x, 0);
 262       st[1] = "<=";
 263       op[1] = XEXP (x, 1);
 264       break;
 265     case LEU:
 266       fun = "leu";
 267       op[0] = XEXP (x, 0);
 268       op[1] = XEXP (x, 1);
 269       break;
 270     case SIGN_EXTRACT:
 271       fun = (verbose) ? "sign_extract" : "sxt";
 272       op[0] = XEXP (x, 0);
 273       op[1] = XEXP (x, 1);
 274       op[2] = XEXP (x, 2);
 275       break;
 276     case ZERO_EXTRACT:
 277       fun = (verbose) ? "zero_extract" : "zxt";
 278       op[0] = XEXP (x, 0);
 279       op[1] = XEXP (x, 1);
 280       op[2] = XEXP (x, 2);
 281       break;
 282     case SIGN_EXTEND:
 283       fun = (verbose) ? "sign_extend" : "sxn";
 284       op[0] = XEXP (x, 0);
 285       break;
 286     case ZERO_EXTEND:
 287       fun = (verbose) ? "zero_extend" : "zxn";
 288       op[0] = XEXP (x, 0);
 289       break;
 290     case FLOAT_EXTEND:
 291       fun = (verbose) ? "float_extend" : "fxn";
 292       op[0] = XEXP (x, 0);
 293       break;
 294     case TRUNCATE:
 295       fun = (verbose) ? "trunc" : "trn";
 296       op[0] = XEXP (x, 0);
 297       break;
 298     case FLOAT_TRUNCATE:
 299       fun = (verbose) ? "float_trunc" : "ftr";
 300       op[0] = XEXP (x, 0);
 301       break;
 302     case FLOAT:
 303       fun = (verbose) ? "float" : "flt";
 304       op[0] = XEXP (x, 0);
 305       break;
 306     case UNSIGNED_FLOAT:
 307       fun = (verbose) ? "uns_float" : "ufl";
 308       op[0] = XEXP (x, 0);
 309       break;
 310     case FIX:
 311       fun = "fix";
 312       op[0] = XEXP (x, 0);
 313       break;
 314     case UNSIGNED_FIX:
 315       fun = (verbose) ? "uns_fix" : "ufx";
 316       op[0] = XEXP (x, 0);
 317       break;
 318     case PRE_DEC:
 319       st[0] = "--";
 320       op[0] = XEXP (x, 0);
 321       break;
 322     case PRE_INC:
 323       st[0] = "++";
 324       op[0] = XEXP (x, 0);
 325       break;
 326     case POST_DEC:
 327       op[0] = XEXP (x, 0);
 328       st[1] = "--";
 329       break;
 330     case POST_INC:
 331       op[0] = XEXP (x, 0);
 332       st[1] = "++";
 333       break;
 334     case PRE_MODIFY:
 335       st[0] = "pre ";
 336       op[0] = XEXP (XEXP (x, 1), 0);
 337       st[1] = "+=";
 338       op[1] = XEXP (XEXP (x, 1), 1);
 339       break;
 340     case POST_MODIFY:
 341       st[0] = "post ";
 342       op[0] = XEXP (XEXP (x, 1), 0);
 343       st[1] = "+=";
 344       op[1] = XEXP (XEXP (x, 1), 1);
 345       break;
 346     case CALL:
 347       st[0] = "call ";
 348       op[0] = XEXP (x, 0);
 349       if (verbose)
 350         {
 351           st[1] = " argc:";
 352           op[1] = XEXP (x, 1);
 353         }
 354       break;
 355     case IF_THEN_ELSE:
 356       st[0] = "{(";
 357       op[0] = XEXP (x, 0);
 358       st[1] = ")?";
 359       op[1] = XEXP (x, 1);
 360       st[2] = ":";
 361       op[2] = XEXP (x, 2);
 362       st[3] = "}";
 363       break;
 364     case TRAP_IF:
 365       fun = "trap_if";
 366       op[0] = TRAP_CONDITION (x);
 367       break;
 368     case PREFETCH:
 369       fun = "prefetch";
 370       op[0] = XEXP (x, 0);
 371       op[1] = XEXP (x, 1);
 372       op[2] = XEXP (x, 2);
 373       break;
 374     case UNSPEC:
 375     case UNSPEC_VOLATILE:
 376       {
 377         cur = safe_concat (buf, cur, "unspec");
 378         if (GET_CODE (x) == UNSPEC_VOLATILE)
 379           cur = safe_concat (buf, cur, "/v");
 380         cur = safe_concat (buf, cur, "[");
 381         sep = "";
 382         for (i = 0; i < XVECLEN (x, 0); i++)
 383           {
 384             print_pattern (tmp, XVECEXP (x, 0, i), verbose);
 385             cur = safe_concat (buf, cur, sep);
 386             cur = safe_concat (buf, cur, tmp);
 387             sep = ",";
 388           }
 389         cur = safe_concat (buf, cur, "] ");
 390         sprintf (tmp, "%d", XINT (x, 1));
 391         cur = safe_concat (buf, cur, tmp);
 392       }
 393       break;
 394     default:
 395       /* If (verbose) debug_rtx (x);  */
 396       st[0] = GET_RTX_NAME (GET_CODE (x));
 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 static void
 430 print_value (char *buf, rtx x, int verbose)
 431 {
 432   char t[BUF_LEN];
 433   char *cur = buf;
 434
 435   switch (GET_CODE (x))
 436     {
 437     case CONST_INT:
 438       sprintf (t, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
 439       cur = safe_concat (buf, cur, t);
 440       break;
 441     case CONST_DOUBLE:
 442       if (FLOAT_MODE_P (GET_MODE (x)))
 443         real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
 444       else
 445         sprintf (t,
 446                  "<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">",
 447                  (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
 448                  (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
 449       cur = safe_concat (buf, cur, t);
 450       break;
 451     case CONST_STRING:
 452       cur = safe_concat (buf, cur, "\"");
 453       cur = safe_concat (buf, cur, XSTR (x, 0));
 454       cur = safe_concat (buf, cur, "\"");
 455       break;
 456     case SYMBOL_REF:
 457       cur = safe_concat (buf, cur, "`");
 458       cur = safe_concat (buf, cur, XSTR (x, 0));
 459       cur = safe_concat (buf, cur, "'");
 460       break;
 461     case LABEL_REF:
 462       sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
 463       cur = safe_concat (buf, cur, t);
 464       break;
 465     case CONST:
 466       print_value (t, XEXP (x, 0), verbose);
 467       cur = safe_concat (buf, cur, "const(");
 468       cur = safe_concat (buf, cur, t);
 469       cur = safe_concat (buf, cur, ")");
 470       break;
 471     case HIGH:
 472       print_value (t, XEXP (x, 0), verbose);
 473       cur = safe_concat (buf, cur, "high(");
 474       cur = safe_concat (buf, cur, t);
 475       cur = safe_concat (buf, cur, ")");
 476       break;
 477     case REG:
 478       if (REGNO (x) < FIRST_PSEUDO_REGISTER)
 479         {
 480           int c = reg_names[REGNO (x)][0];
 481           if (ISDIGIT (c))
 482             cur = safe_concat (buf, cur, "%");
 483
 484           cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
 485         }
 486       else
 487         {
 488           sprintf (t, "r%d", REGNO (x));
 489           cur = safe_concat (buf, cur, t);
 490         }
 491       if (verbose
 492 #ifdef INSN_SCHEDULING
 493           && !current_sched_info
 494 #endif
 495          )
 496         {
 497           sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x)));
 498           cur = safe_concat (buf, cur, t);
 499         }
 500       break;
 501     case SUBREG:
 502       print_value (t, SUBREG_REG (x), verbose);
 503       cur = safe_concat (buf, cur, t);
 504       sprintf (t, "#%d", SUBREG_BYTE (x));
 505       cur = safe_concat (buf, cur, t);
 506       break;
 507     case SCRATCH:
 508       cur = safe_concat (buf, cur, "scratch");
 509       break;
 510     case CC0:
 511       cur = safe_concat (buf, cur, "cc0");
 512       break;
 513     case PC:
 514       cur = safe_concat (buf, cur, "pc");
 515       break;
 516     case MEM:
 517       print_value (t, XEXP (x, 0), verbose);
 518       cur = safe_concat (buf, cur, "[");
 519       cur = safe_concat (buf, cur, t);
 520       cur = safe_concat (buf, cur, "]");
 521       break;
 522     default:
 523       print_exp (t, x, verbose);
 524       cur = safe_concat (buf, cur, t);
 525       break;
 526     }
 527 }                               /* print_value */
 528
 529 /* The next step in insn detalization, its pattern recognition.  */
 530
 531 static void
 532 print_pattern (char *buf, rtx x, int verbose)
 533 {
 534   char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
 535
 536   switch (GET_CODE (x))
 537     {
 538     case SET:
 539       print_value (t1, SET_DEST (x), verbose);
 540       print_value (t2, SET_SRC (x), verbose);
 541       sprintf (buf, "%s=%s", t1, t2);
 542       break;
 543     case RETURN:
 544       sprintf (buf, "return");
 545       break;
 546     case CALL:
 547       print_exp (buf, x, verbose);
 548       break;
 549     case CLOBBER:
 550       print_value (t1, XEXP (x, 0), verbose);
 551       sprintf (buf, "clobber %s", t1);
 552       break;
 553     case USE:
 554       print_value (t1, XEXP (x, 0), verbose);
 555       sprintf (buf, "use %s", t1);
 556       break;
 557     case COND_EXEC:
 558       if (GET_CODE (COND_EXEC_TEST (x)) == NE
 559           && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 560         print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
 561       else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
 562                && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 563         {
 564           t1[0] = '!';
 565           print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
 566         }
 567       else
 568         print_value (t1, COND_EXEC_TEST (x), verbose);
 569       print_pattern (t2, COND_EXEC_CODE (x), verbose);
 570       sprintf (buf, "(%s) %s", t1, t2);
 571       break;
 572     case PARALLEL:
 573       {
 574         int i;
 575
 576         sprintf (t1, "{");
 577         for (i = 0; i < XVECLEN (x, 0); i++)
 578           {
 579             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 580             sprintf (t3, "%s%s;", t1, t2);
 581             strcpy (t1, t3);
 582           }
 583         sprintf (buf, "%s}", t1);
 584       }
 585       break;
 586     case SEQUENCE:
 587       /* Should never see SEQUENCE codes until after reorg.  */
 588       gcc_unreachable ();
 589     case ASM_INPUT:
 590       sprintf (buf, "asm {%s}", XSTR (x, 0));
 591       break;
 592     case ADDR_VEC:
 593       break;
 594     case ADDR_DIFF_VEC:
 595       print_value (buf, XEXP (x, 0), verbose);
 596       break;
 597     case TRAP_IF:
 598       print_value (t1, TRAP_CONDITION (x), verbose);
 599       sprintf (buf, "trap_if %s", t1);
 600       break;
 601     case UNSPEC:
 602       {
 603         int i;
 604
 605         sprintf (t1, "unspec{");
 606         for (i = 0; i < XVECLEN (x, 0); i++)
 607           {
 608             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 609             sprintf (t3, "%s%s;", t1, t2);
 610             strcpy (t1, t3);
 611           }
 612         sprintf (buf, "%s}", t1);
 613       }
 614       break;
 615     case UNSPEC_VOLATILE:
 616       {
 617         int i;
 618
 619         sprintf (t1, "unspec/v{");
 620         for (i = 0; i < XVECLEN (x, 0); i++)
 621           {
 622             print_pattern (t2, XVECEXP (x, 0, i), verbose);
 623             sprintf (t3, "%s%s;", t1, t2);
 624             strcpy (t1, t3);
 625           }
 626         sprintf (buf, "%s}", t1);
 627       }
 628       break;
 629     default:
 630       print_value (buf, x, verbose);
 631     }
 632 }                               /* print_pattern */
 633
 634 /* This is the main function in rtl visualization mechanism. It
 635    accepts an rtx and tries to recognize it as an insn, then prints it
 636    properly in human readable form, resembling assembler mnemonics.
 637    For every insn it prints its UID and BB the insn belongs too.
 638    (Probably the last "option" should be extended somehow, since it
 639    depends now on sched.c inner variables ...)  */
 640
 641 void
 642 print_insn (char *buf, rtx x, int verbose)
 643 {
 644   char t[BUF_LEN];
 645   rtx insn = x;
 646
 647   switch (GET_CODE (x))
 648     {
 649     case INSN:
 650       print_pattern (t, PATTERN (x), verbose);
 651 #ifdef INSN_SCHEDULING
 652       if (verbose && current_sched_info)
 653         sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
 654                  t);
 655       else
 656 #endif
 657         sprintf (buf, " %4d %s", INSN_UID (x), t);
 658       break;
 659     case JUMP_INSN:
 660       print_pattern (t, PATTERN (x), verbose);
 661 #ifdef INSN_SCHEDULING
 662       if (verbose && current_sched_info)
 663         sprintf (buf, "%s: jump %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     case CALL_INSN:
 670       x = PATTERN (insn);
 671       if (GET_CODE (x) == PARALLEL)
 672         {
 673           x = XVECEXP (x, 0, 0);
 674           print_pattern (t, x, verbose);
 675         }
 676       else
 677         strcpy (t, "call <...>");
 678 #ifdef INSN_SCHEDULING
 679       if (verbose && current_sched_info)
 680         sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1), t);
 681       else
 682 #endif
 683         sprintf (buf, " %4d %s", INSN_UID (insn), t);
 684       break;
 685     case CODE_LABEL:
 686       sprintf (buf, "L%d:", INSN_UID (x));
 687       break;
 688     case BARRIER:
 689       sprintf (buf, "i%4d: barrier", INSN_UID (x));
 690       break;
 691     case NOTE:
 692       sprintf (buf, " %4d %s", INSN_UID (x),
 693                GET_NOTE_INSN_NAME (NOTE_KIND (x)));
 694       break;
 695     default:
 696       sprintf (buf, "i%4d  <What %s?>", INSN_UID (x),
 697                GET_RTX_NAME (GET_CODE (x)));
 698     }
 699 }                               /* print_insn */
 700
 701
 702 /* Emit a slim dump of X (an insn) to the file F, including any register
 703    note attached to the instruction.  */
 704 void
 705 dump_insn_slim (FILE *f, rtx x)
 706 {
 707   char t[BUF_LEN + 32];
 708   rtx note;
 709
 710   print_insn (t, x, 1);
 711   fputs (t, f);
 712   putc ('\n', f);
 713   if (INSN_P (x) && REG_NOTES (x))
 714     for (note = REG_NOTES (x); note; note = XEXP (note, 1))
 715       {
 716         print_value (t, XEXP (note, 0), 1);
 717         fprintf (f, "      %s: %s\n",
 718                  GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t);
 719       }
 720 }
 721
 722 /* Emit a slim dump of X (an insn) to stderr.  */
 723 void
 724 debug_insn_slim (rtx x)
 725 {
 726   dump_insn_slim (stderr, x);
 727 }
 728
 729 /* Provide a slim dump the instruction chain starting at FIRST to F, honoring
 730    the dump flags given in FLAGS.  Currently, TDF_BLOCKS and TDF_DETAILS
 731    include more information on the basic blocks.  */
 732 void
 733 print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
 734 {
 735   basic_block current_bb = NULL;
 736   rtx insn;
 737
 738   for (insn = first; NULL != insn; insn = NEXT_INSN (insn))
 739     {
 740       if ((flags & TDF_BLOCKS)
 741           && (INSN_P (insn) || GET_CODE (insn) == NOTE)
 742           && BLOCK_FOR_INSN (insn)
 743           && !current_bb)
 744         {
 745           current_bb = BLOCK_FOR_INSN (insn);
 746           dump_bb_info (current_bb, true, false, flags, ";; ", f);
 747         }
 748
 749       dump_insn_slim (f, insn);
 750
 751       if ((flags & TDF_BLOCKS)
 752           && current_bb
 753           && insn == BB_END (current_bb))
 754         {
 755           dump_bb_info (current_bb, false, true, flags, ";; ", f);
 756           current_bb = NULL;
 757         }
 758     }
 759 }
 760