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