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