gcc/sched-vis.c

   1 /* Printing of RTL in "slim", mnemonic like form.
   2    Copyright (C) 1992-2014 Free Software Foundation, Inc.
   3    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
   4    and currently maintained by, Jim Wilson (wilson@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /* Historically this form of RTL dumping was introduced along with
  23    the Haifa instruction scheduling pass, hence the name of this file.
  24    But there is nothing in this file left that is scheduler-specific.  */
  25 \f
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "rtl.h"
  31 #include "tree.h"       /* FIXME: To dump INSN_VAR_LOCATION_DECL.  */
  32 #include "basic-block.h"
  33 #include "dumpfile.h"   /* for the TDF_* flags */
  34 #include "pretty-print.h"
  35
  36 /* The functions in this file try to print RTL in a form resembling assembler
  37    mnemonics.  Because this form is more concise than the "traditional" form
  38    of RTL printing in Lisp-style, the form printed by this file is called
  39    "slim".  RTL dumps in slim format can be obtained by appending the "-slim"
  40    option to -fdump-rtl-<pass>.  Control flow graph output as a DOT file is
  41    always printed in slim form.
  42
  43    The normal interface to the functionality provided in this pretty-printer
  44    is through the dump_*_slim functions to print to a stream, or via the
  45    print_*_slim functions to print into a user's pretty-printer.
  46
  47    It is also possible to obtain a string for a single pattern as a string
  48    pointer, via str_pattern_slim, but this usage is discouraged.  */
  49
  50 /* For insns we print patterns, and for some patterns we print insns...  */
  51 static void print_insn_with_notes (pretty_printer *, const_rtx);
  52
  53 /* This recognizes rtx'en classified as expressions.  These are always
  54    represent some action on values or results of other expression, that
  55    may be stored in objects representing values.  */
  56
  57 static void
  58 print_exp (pretty_printer *pp, const_rtx x, int verbose)
  59 {
  60   const char *st[4];
  61   const char *fun;
  62   rtx op[4];
  63   int i;
  64
  65   fun = (char *) 0;
  66   for (i = 0; i < 4; i++)
  67     {
  68       st[i] = (char *) 0;
  69       op[i] = NULL_RTX;
  70     }
  71
  72   switch (GET_CODE (x))
  73     {
  74     case PLUS:
  75       op[0] = XEXP (x, 0);
  76       if (CONST_INT_P (XEXP (x, 1))
  77           && INTVAL (XEXP (x, 1)) < 0)
  78         {
  79           st[1] = "-";
  80           op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
  81         }
  82       else
  83         {
  84           st[1] = "+";
  85           op[1] = XEXP (x, 1);
  86         }
  87       break;
  88     case LO_SUM:
  89       op[0] = XEXP (x, 0);
  90       st[1] = "+low(";
  91       op[1] = XEXP (x, 1);
  92       st[2] = ")";
  93       break;
  94     case MINUS:
  95       op[0] = XEXP (x, 0);
  96       st[1] = "-";
  97       op[1] = XEXP (x, 1);
  98       break;
  99     case COMPARE:
 100       fun = "cmp";
 101       op[0] = XEXP (x, 0);
 102       op[1] = XEXP (x, 1);
 103       break;
 104     case NEG:
 105       st[0] = "-";
 106       op[0] = XEXP (x, 0);
 107       break;
 108     case FMA:
 109       st[0] = "{";
 110       op[0] = XEXP (x, 0);
 111       st[1] = "*";
 112       op[1] = XEXP (x, 1);
 113       st[2] = "+";
 114       op[2] = XEXP (x, 2);
 115       st[3] = "}";
 116       break;
 117     case MULT:
 118       op[0] = XEXP (x, 0);
 119       st[1] = "*";
 120       op[1] = XEXP (x, 1);
 121       break;
 122     case DIV:
 123       op[0] = XEXP (x, 0);
 124       st[1] = "/";
 125       op[1] = XEXP (x, 1);
 126       break;
 127     case UDIV:
 128       fun = "udiv";
 129       op[0] = XEXP (x, 0);
 130       op[1] = XEXP (x, 1);
 131       break;
 132     case MOD:
 133       op[0] = XEXP (x, 0);
 134       st[1] = "%";
 135       op[1] = XEXP (x, 1);
 136       break;
 137     case UMOD:
 138       fun = "umod";
 139       op[0] = XEXP (x, 0);
 140       op[1] = XEXP (x, 1);
 141       break;
 142     case SMIN:
 143       fun = "smin";
 144       op[0] = XEXP (x, 0);
 145       op[1] = XEXP (x, 1);
 146       break;
 147     case SMAX:
 148       fun = "smax";
 149       op[0] = XEXP (x, 0);
 150       op[1] = XEXP (x, 1);
 151       break;
 152     case UMIN:
 153       fun = "umin";
 154       op[0] = XEXP (x, 0);
 155       op[1] = XEXP (x, 1);
 156       break;
 157     case UMAX:
 158       fun = "umax";
 159       op[0] = XEXP (x, 0);
 160       op[1] = XEXP (x, 1);
 161       break;
 162     case NOT:
 163       st[0] = "!";
 164       op[0] = XEXP (x, 0);
 165       break;
 166     case AND:
 167       op[0] = XEXP (x, 0);
 168       st[1] = "&";
 169       op[1] = XEXP (x, 1);
 170       break;
 171     case IOR:
 172       op[0] = XEXP (x, 0);
 173       st[1] = "|";
 174       op[1] = XEXP (x, 1);
 175       break;
 176     case XOR:
 177       op[0] = XEXP (x, 0);
 178       st[1] = "^";
 179       op[1] = XEXP (x, 1);
 180       break;
 181     case ASHIFT:
 182       op[0] = XEXP (x, 0);
 183       st[1] = "<<";
 184       op[1] = XEXP (x, 1);
 185       break;
 186     case LSHIFTRT:
 187       op[0] = XEXP (x, 0);
 188       st[1] = " 0>>";
 189       op[1] = XEXP (x, 1);
 190       break;
 191     case ASHIFTRT:
 192       op[0] = XEXP (x, 0);
 193       st[1] = ">>";
 194       op[1] = XEXP (x, 1);
 195       break;
 196     case ROTATE:
 197       op[0] = XEXP (x, 0);
 198       st[1] = "<-<";
 199       op[1] = XEXP (x, 1);
 200       break;
 201     case ROTATERT:
 202       op[0] = XEXP (x, 0);
 203       st[1] = ">->";
 204       op[1] = XEXP (x, 1);
 205       break;
 206     case NE:
 207       op[0] = XEXP (x, 0);
 208       st[1] = "!=";
 209       op[1] = XEXP (x, 1);
 210       break;
 211     case EQ:
 212       op[0] = XEXP (x, 0);
 213       st[1] = "==";
 214       op[1] = XEXP (x, 1);
 215       break;
 216     case GE:
 217       op[0] = XEXP (x, 0);
 218       st[1] = ">=";
 219       op[1] = XEXP (x, 1);
 220       break;
 221     case GT:
 222       op[0] = XEXP (x, 0);
 223       st[1] = ">";
 224       op[1] = XEXP (x, 1);
 225       break;
 226     case LE:
 227       op[0] = XEXP (x, 0);
 228       st[1] = "<=";
 229       op[1] = XEXP (x, 1);
 230       break;
 231     case LT:
 232       op[0] = XEXP (x, 0);
 233       st[1] = "<";
 234       op[1] = XEXP (x, 1);
 235       break;
 236     case SIGN_EXTRACT:
 237       fun = (verbose) ? "sign_extract" : "sxt";
 238       op[0] = XEXP (x, 0);
 239       op[1] = XEXP (x, 1);
 240       op[2] = XEXP (x, 2);
 241       break;
 242     case ZERO_EXTRACT:
 243       fun = (verbose) ? "zero_extract" : "zxt";
 244       op[0] = XEXP (x, 0);
 245       op[1] = XEXP (x, 1);
 246       op[2] = XEXP (x, 2);
 247       break;
 248     case SIGN_EXTEND:
 249       fun = (verbose) ? "sign_extend" : "sxn";
 250       op[0] = XEXP (x, 0);
 251       break;
 252     case ZERO_EXTEND:
 253       fun = (verbose) ? "zero_extend" : "zxn";
 254       op[0] = XEXP (x, 0);
 255       break;
 256     case FLOAT_EXTEND:
 257       fun = (verbose) ? "float_extend" : "fxn";
 258       op[0] = XEXP (x, 0);
 259       break;
 260     case TRUNCATE:
 261       fun = (verbose) ? "trunc" : "trn";
 262       op[0] = XEXP (x, 0);
 263       break;
 264     case FLOAT_TRUNCATE:
 265       fun = (verbose) ? "float_trunc" : "ftr";
 266       op[0] = XEXP (x, 0);
 267       break;
 268     case FLOAT:
 269       fun = (verbose) ? "float" : "flt";
 270       op[0] = XEXP (x, 0);
 271       break;
 272     case UNSIGNED_FLOAT:
 273       fun = (verbose) ? "uns_float" : "ufl";
 274       op[0] = XEXP (x, 0);
 275       break;
 276     case FIX:
 277       fun = "fix";
 278       op[0] = XEXP (x, 0);
 279       break;
 280     case UNSIGNED_FIX:
 281       fun = (verbose) ? "uns_fix" : "ufx";
 282       op[0] = XEXP (x, 0);
 283       break;
 284     case PRE_DEC:
 285       st[0] = "--";
 286       op[0] = XEXP (x, 0);
 287       break;
 288     case PRE_INC:
 289       st[0] = "++";
 290       op[0] = XEXP (x, 0);
 291       break;
 292     case POST_DEC:
 293       op[0] = XEXP (x, 0);
 294       st[1] = "--";
 295       break;
 296     case POST_INC:
 297       op[0] = XEXP (x, 0);
 298       st[1] = "++";
 299       break;
 300     case PRE_MODIFY:
 301       st[0] = "pre ";
 302       op[0] = XEXP (XEXP (x, 1), 0);
 303       st[1] = "+=";
 304       op[1] = XEXP (XEXP (x, 1), 1);
 305       break;
 306     case POST_MODIFY:
 307       st[0] = "post ";
 308       op[0] = XEXP (XEXP (x, 1), 0);
 309       st[1] = "+=";
 310       op[1] = XEXP (XEXP (x, 1), 1);
 311       break;
 312     case CALL:
 313       st[0] = "call ";
 314       op[0] = XEXP (x, 0);
 315       if (verbose)
 316         {
 317           st[1] = " argc:";
 318           op[1] = XEXP (x, 1);
 319         }
 320       break;
 321     case IF_THEN_ELSE:
 322       st[0] = "{(";
 323       op[0] = XEXP (x, 0);
 324       st[1] = ")?";
 325       op[1] = XEXP (x, 1);
 326       st[2] = ":";
 327       op[2] = XEXP (x, 2);
 328       st[3] = "}";
 329       break;
 330     case TRAP_IF:
 331       fun = "trap_if";
 332       op[0] = TRAP_CONDITION (x);
 333       break;
 334     case PREFETCH:
 335       fun = "prefetch";
 336       op[0] = XEXP (x, 0);
 337       op[1] = XEXP (x, 1);
 338       op[2] = XEXP (x, 2);
 339       break;
 340     case UNSPEC:
 341     case UNSPEC_VOLATILE:
 342       {
 343         pp_string (pp, "unspec");
 344         if (GET_CODE (x) == UNSPEC_VOLATILE)
 345           pp_string (pp, "/v");
 346         pp_left_bracket (pp);
 347         for (i = 0; i < XVECLEN (x, 0); i++)
 348           {
 349             if (i != 0)
 350               pp_comma (pp);
 351             print_pattern (pp, XVECEXP (x, 0, i), verbose);
 352           }
 353         pp_string (pp, "] ");
 354         pp_decimal_int (pp, XINT (x, 1));
 355       }
 356       break;
 357     default:
 358       {
 359         /* Most unhandled codes can be printed as pseudo-functions.  */
 360         if (GET_RTX_CLASS (GET_CODE (x)) == RTX_UNARY)
 361           {
 362             fun = GET_RTX_NAME (GET_CODE (x));
 363             op[0] = XEXP (x, 0);
 364           }
 365         else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_COMPARE
 366                  || GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_COMPARE
 367                  || GET_RTX_CLASS (GET_CODE (x)) == RTX_BIN_ARITH
 368                  || GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_ARITH)
 369           {
 370             fun = GET_RTX_NAME (GET_CODE (x));
 371             op[0] = XEXP (x, 0);
 372             op[1] = XEXP (x, 1);
 373           }
 374         else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_TERNARY)
 375           {
 376             fun = GET_RTX_NAME (GET_CODE (x));
 377             op[0] = XEXP (x, 0);
 378             op[1] = XEXP (x, 1);
 379             op[2] = XEXP (x, 2);
 380           }
 381         else
 382           /* Give up, just print the RTX name.  */
 383           st[0] = GET_RTX_NAME (GET_CODE (x));
 384       }
 385       break;
 386     }
 387
 388   /* Print this as a function?  */
 389   if (fun)
 390     {
 391       pp_string (pp, fun);
 392       pp_left_paren (pp);
 393     }
 394
 395   for (i = 0; i < 4; i++)
 396     {
 397       if (st[i])
 398         pp_string (pp, st[i]);
 399
 400       if (op[i])
 401         {
 402           if (fun && i != 0)
 403             pp_comma (pp);
 404           print_value (pp, op[i], verbose);
 405         }
 406     }
 407
 408   if (fun)
 409     pp_right_paren (pp);
 410 }               /* print_exp */
 411
 412 /* Prints rtxes, I customarily classified as values.  They're constants,
 413    registers, labels, symbols and memory accesses.  */
 414
 415 void
 416 print_value (pretty_printer *pp, const_rtx x, int verbose)
 417 {
 418   char tmp[1024];
 419
 420   if (!x)
 421     {
 422       pp_string (pp, "(nil)");
 423       return;
 424     }
 425   switch (GET_CODE (x))
 426     {
 427     case CONST_INT:
 428       pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
 429                  (unsigned HOST_WIDE_INT) INTVAL (x));
 430       break;
 431
 432     case CONST_WIDE_INT:
 433       {
 434         const char *sep = "<";
 435         int i;
 436         for (i = CONST_WIDE_INT_NUNITS (x) - 1; i >= 0; i--)
 437           {
 438             pp_string (pp, sep);
 439             sep = ",";
 440             sprintf (tmp, HOST_WIDE_INT_PRINT_HEX,
 441                      (unsigned HOST_WIDE_INT) CONST_WIDE_INT_ELT (x, i));
 442             pp_string (pp, tmp);
 443           }
 444         pp_greater (pp);
 445       }
 446       break;
 447
 448     case CONST_DOUBLE:
 449       if (FLOAT_MODE_P (GET_MODE (x)))
 450         {
 451           real_to_decimal (tmp, CONST_DOUBLE_REAL_VALUE (x),
 452                            sizeof (tmp), 0, 1);
 453           pp_string (pp, tmp);
 454         }
 455       else
 456         pp_printf (pp, "<%wx,%wx>",
 457                    (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
 458                    (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
 459       break;
 460     case CONST_FIXED:
 461       fixed_to_decimal (tmp, CONST_FIXED_VALUE (x), sizeof (tmp));
 462       pp_string (pp, tmp);
 463       break;
 464     case CONST_STRING:
 465       pp_printf (pp, "\"%s\"", XSTR (x, 0));
 466       break;
 467     case SYMBOL_REF:
 468       pp_printf (pp, "`%s'", XSTR (x, 0));
 469       break;
 470     case LABEL_REF:
 471       pp_printf (pp, "L%d", INSN_UID (XEXP (x, 0)));
 472       break;
 473     case CONST:
 474     case HIGH:
 475     case STRICT_LOW_PART:
 476       pp_printf (pp, "%s(", GET_RTX_NAME (GET_CODE (x)));
 477       print_value (pp, XEXP (x, 0), verbose);
 478       pp_right_paren (pp);
 479       break;
 480     case REG:
 481       if (REGNO (x) < FIRST_PSEUDO_REGISTER)
 482         {
 483           if (ISDIGIT (reg_names[REGNO (x)][0]))
 484             pp_modulo (pp);
 485           pp_string (pp, reg_names[REGNO (x)]);
 486         }
 487       else
 488         pp_printf (pp, "r%d", REGNO (x));
 489       if (verbose)
 490         pp_printf (pp, ":%s", GET_MODE_NAME (GET_MODE (x)));
 491       break;
 492     case SUBREG:
 493       print_value (pp, SUBREG_REG (x), verbose);
 494       pp_printf (pp, "#%d", SUBREG_BYTE (x));
 495       break;
 496     case SCRATCH:
 497     case CC0:
 498     case PC:
 499       pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
 500       break;
 501     case MEM:
 502       pp_left_bracket (pp);
 503       print_value (pp, XEXP (x, 0), verbose);
 504       pp_right_bracket (pp);
 505       break;
 506     case DEBUG_EXPR:
 507       pp_printf (pp, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
 508       break;
 509     default:
 510       print_exp (pp, x, verbose);
 511       break;
 512     }
 513 }                               /* print_value */
 514
 515 /* The next step in insn detalization, its pattern recognition.  */
 516
 517 void
 518 print_pattern (pretty_printer *pp, const_rtx x, int verbose)
 519 {
 520   if (! x)
 521     {
 522       pp_string (pp, "(nil)");
 523       return;
 524     }
 525
 526   switch (GET_CODE (x))
 527     {
 528     case SET:
 529       print_value (pp, SET_DEST (x), verbose);
 530       pp_equal (pp);
 531       print_value (pp, SET_SRC (x), verbose);
 532       break;
 533     case RETURN:
 534     case SIMPLE_RETURN:
 535     case EH_RETURN:
 536       pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
 537       break;
 538     case CALL:
 539       print_exp (pp, x, verbose);
 540       break;
 541     case CLOBBER:
 542     case USE:
 543       pp_printf (pp, "%s ", GET_RTX_NAME (GET_CODE (x)));
 544       print_value (pp, XEXP (x, 0), verbose);
 545       break;
 546     case VAR_LOCATION:
 547       pp_string (pp, "loc ");
 548       print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose);
 549       break;
 550     case COND_EXEC:
 551       pp_left_paren (pp);
 552       if (GET_CODE (COND_EXEC_TEST (x)) == NE
 553           && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 554         print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
 555       else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
 556                && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 557         {
 558           pp_exclamation (pp);
 559           print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
 560         }
 561       else
 562         print_value (pp, COND_EXEC_TEST (x), verbose);
 563       pp_string (pp, ") ");
 564       print_pattern (pp, COND_EXEC_CODE (x), verbose);
 565       break;
 566     case PARALLEL:
 567       {
 568         int i;
 569
 570         pp_left_brace (pp);
 571         for (i = 0; i < XVECLEN (x, 0); i++)
 572           {
 573             print_pattern (pp, XVECEXP (x, 0, i), verbose);
 574             pp_semicolon (pp);
 575           }
 576         pp_right_brace (pp);
 577       }
 578       break;
 579     case SEQUENCE:
 580       {
 581         pp_string (pp, "sequence{");
 582         if (INSN_P (XVECEXP (x, 0, 0)))
 583           {
 584             /* Print the sequence insns indented.  */
 585             const char * save_print_rtx_head = print_rtx_head;
 586             char indented_print_rtx_head[32];
 587
 588             pp_newline (pp);
 589             gcc_assert (strlen (print_rtx_head) < sizeof (indented_print_rtx_head) - 4);
 590             snprintf (indented_print_rtx_head,
 591                       sizeof (indented_print_rtx_head),
 592                       "%s     ", print_rtx_head);
 593             print_rtx_head = indented_print_rtx_head;
 594             for (int i = 0; i < XVECLEN (x, 0); i++)
 595               print_insn_with_notes (pp, XVECEXP (x, 0, i));
 596             pp_printf (pp, "%s      ", save_print_rtx_head);
 597             print_rtx_head = save_print_rtx_head;
 598           }
 599         else
 600           {
 601             for (int i = 0; i < XVECLEN (x, 0); i++)
 602               {
 603                 print_pattern (pp, XVECEXP (x, 0, i), verbose);
 604                 pp_semicolon (pp);
 605               }
 606           }
 607         pp_right_brace (pp);
 608       }
 609       break;
 610     case ASM_INPUT:
 611       pp_printf (pp, "asm {%s}", XSTR (x, 0));
 612       break;
 613     case ADDR_VEC:
 614       for (int i = 0; i < XVECLEN (x, 0); i++)
 615         {
 616           print_value (pp, XVECEXP (x, 0, i), verbose);
 617           pp_semicolon (pp);
 618         }
 619       break;
 620     case ADDR_DIFF_VEC:
 621       for (int i = 0; i < XVECLEN (x, 1); i++)
 622         {
 623           print_value (pp, XVECEXP (x, 1, i), verbose);
 624           pp_semicolon (pp);
 625         }
 626       break;
 627     case TRAP_IF:
 628       pp_string (pp, "trap_if ");
 629       print_value (pp, TRAP_CONDITION (x), verbose);
 630       break;
 631     case UNSPEC:
 632     case UNSPEC_VOLATILE:
 633       /* Fallthru -- leave UNSPECs to print_exp.  */
 634     default:
 635       print_value (pp, x, verbose);
 636     }
 637 }                               /* print_pattern */
 638
 639 /* This is the main function in slim rtl visualization mechanism.
 640
 641    X is an insn, to be printed into PP.
 642
 643    This function tries to print it properly in human-readable form,
 644    resembling assembler mnemonics (instead of the older Lisp-style
 645    form).
 646
 647    If VERBOSE is TRUE, insns are printed with more complete (but
 648    longer) pattern names and with extra information, and prefixed
 649    with their INSN_UIDs.  */
 650
 651 void
 652 print_insn (pretty_printer *pp, const_rtx x, int verbose)
 653 {
 654   if (verbose)
 655     {
 656       /* Blech, pretty-print can't print integers with a specified width.  */
 657       char uid_prefix[32];
 658       snprintf (uid_prefix, sizeof uid_prefix, " %4d: ", INSN_UID (x));
 659       pp_string (pp, uid_prefix);
 660     }
 661
 662   switch (GET_CODE (x))
 663     {
 664     case INSN:
 665       print_pattern (pp, PATTERN (x), verbose);
 666       break;
 667
 668     case DEBUG_INSN:
 669       {
 670         const char *name = "?";
 671
 672         if (DECL_P (INSN_VAR_LOCATION_DECL (x)))
 673           {
 674             tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (x));
 675             char idbuf[32];
 676             if (id)
 677               name = IDENTIFIER_POINTER (id);
 678             else if (TREE_CODE (INSN_VAR_LOCATION_DECL (x))
 679                      == DEBUG_EXPR_DECL)
 680               {
 681                 sprintf (idbuf, "D#%i",
 682                          DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (x)));
 683                 name = idbuf;
 684               }
 685             else
 686               {
 687                 sprintf (idbuf, "D.%i",
 688                          DECL_UID (INSN_VAR_LOCATION_DECL (x)));
 689                 name = idbuf;
 690               }
 691           }
 692         pp_printf (pp, "debug %s => ", name);
 693         if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (x)))
 694           pp_string (pp, "optimized away");
 695         else
 696           print_pattern (pp, INSN_VAR_LOCATION_LOC (x), verbose);
 697       }
 698       break;
 699
 700     case JUMP_INSN:
 701       print_pattern (pp, PATTERN (x), verbose);
 702       break;
 703     case CALL_INSN:
 704       if (GET_CODE (PATTERN (x)) == PARALLEL)
 705         print_pattern (pp, XVECEXP (PATTERN (x), 0, 0), verbose);
 706       else
 707         print_pattern (pp, PATTERN (x), verbose);
 708       break;
 709     case CODE_LABEL:
 710       pp_printf (pp, "L%d:", INSN_UID (x));
 711       break;
 712     case JUMP_TABLE_DATA:
 713       pp_string (pp, "jump_table_data{\n");
 714       print_pattern (pp, PATTERN (x), verbose);
 715       pp_right_brace (pp);
 716       break;
 717     case BARRIER:
 718       pp_string (pp, "barrier");
 719       break;
 720     case NOTE:
 721       {
 722         pp_string (pp, GET_NOTE_INSN_NAME (NOTE_KIND (x)));
 723         switch (NOTE_KIND (x))
 724           {
 725           case NOTE_INSN_EH_REGION_BEG:
 726           case NOTE_INSN_EH_REGION_END:
 727             pp_printf (pp, " %d", NOTE_EH_HANDLER (x));
 728             break;
 729
 730           case NOTE_INSN_BLOCK_BEG:
 731           case NOTE_INSN_BLOCK_END:
 732             pp_printf (pp, " %d", BLOCK_NUMBER (NOTE_BLOCK (x)));
 733             break;
 734
 735           case NOTE_INSN_BASIC_BLOCK:
 736             pp_printf (pp, " %d", NOTE_BASIC_BLOCK (x)->index);
 737             break;
 738
 739           case NOTE_INSN_DELETED_LABEL:
 740           case NOTE_INSN_DELETED_DEBUG_LABEL:
 741             {
 742               const char *label = NOTE_DELETED_LABEL_NAME (x);
 743               if (label == NULL)
 744                 label = "";
 745               pp_printf (pp, " (\"%s\")", label);
 746             }
 747             break;
 748
 749           case NOTE_INSN_VAR_LOCATION:
 750           case NOTE_INSN_CALL_ARG_LOCATION:
 751             pp_left_brace (pp);
 752             print_pattern (pp, NOTE_VAR_LOCATION (x), verbose);
 753             pp_right_brace (pp);
 754             break;
 755
 756           default:
 757             break;
 758           }
 759         break;
 760       }
 761     default:
 762       gcc_unreachable ();
 763     }
 764 }                               /* print_insn */
 765
 766 /* Pretty-print a slim dump of X (an insn) to PP, including any register
 767    note attached to the instruction.  */
 768
 769 static void
 770 print_insn_with_notes (pretty_printer *pp, const_rtx x)
 771 {
 772   pp_string (pp, print_rtx_head);
 773   print_insn (pp, x, 1);
 774   pp_newline (pp);
 775   if (INSN_P (x) && REG_NOTES (x))
 776     for (rtx note = REG_NOTES (x); note; note = XEXP (note, 1))
 777       {
 778         pp_printf (pp, "%s      %s ", print_rtx_head,
 779                    GET_REG_NOTE_NAME (REG_NOTE_KIND (note)));
 780         if (GET_CODE (note) == INT_LIST)
 781           pp_printf (pp, "%d", XINT (note, 0));
 782         else
 783           print_pattern (pp, XEXP (note, 0), 1);
 784         pp_newline (pp);
 785       }
 786 }
 787
 788 /* Print X, an RTL value node, to file F in slim format.  Include
 789    additional information if VERBOSE is nonzero.
 790
 791    Value nodes are constants, registers, labels, symbols and
 792    memory.  */
 793
 794 void
 795 dump_value_slim (FILE *f, const_rtx x, int verbose)
 796 {
 797   pretty_printer rtl_slim_pp;
 798   rtl_slim_pp.buffer->stream = f;
 799   print_value (&rtl_slim_pp, x, verbose);
 800   pp_flush (&rtl_slim_pp);
 801 }
 802
 803 /* Emit a slim dump of X (an insn) to the file F, including any register
 804    note attached to the instruction.  */
 805 void
 806 dump_insn_slim (FILE *f, const_rtx x)
 807 {
 808   pretty_printer rtl_slim_pp;
 809   rtl_slim_pp.buffer->stream = f;
 810   print_insn_with_notes (&rtl_slim_pp, x);
 811   pp_flush (&rtl_slim_pp);
 812 }
 813
 814 /* Same as above, but stop at LAST or when COUNT == 0.
 815    If COUNT < 0 it will stop only at LAST or NULL rtx.  */
 816
 817 void
 818 dump_rtl_slim (FILE *f, const_rtx first, const_rtx last,
 819                int count, int flags ATTRIBUTE_UNUSED)
 820 {
 821   const_rtx insn, tail;
 822   pretty_printer rtl_slim_pp;
 823   rtl_slim_pp.buffer->stream = f;
 824
 825   tail = last ? NEXT_INSN (last) : NULL_RTX;
 826   for (insn = first;
 827        (insn != NULL) && (insn != tail) && (count != 0);
 828        insn = NEXT_INSN (insn))
 829     {
 830       print_insn_with_notes (&rtl_slim_pp, insn);
 831       if (count > 0)
 832         count--;
 833     }
 834
 835   pp_flush (&rtl_slim_pp);
 836 }
 837
 838 /* Dumps basic block BB to pretty-printer PP in slim form and without and
 839    no indentation, for use as a label of a DOT graph record-node.  */
 840
 841 void
 842 rtl_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
 843 {
 844   rtx insn;
 845   bool first = true;
 846
 847   /* TODO: inter-bb stuff.  */
 848   FOR_BB_INSNS (bb, insn)
 849     {
 850       if (! first)
 851         {
 852           pp_bar (pp);
 853           pp_write_text_to_stream (pp);
 854         }
 855       first = false;
 856       print_insn_with_notes (pp, insn);
 857       pp_write_text_as_dot_label_to_stream (pp, /*for_record=*/true);
 858     }
 859 }
 860
 861 /* Pretty-print pattern X of some insn in non-verbose mode.
 862    Return a string pointer to the pretty-printer buffer.
 863
 864    This function is only exported exists only to accommodate some older users
 865    of the slim RTL pretty printers.  Please do not use it for new code.  */
 866
 867 const char *
 868 str_pattern_slim (const_rtx x)
 869 {
 870   pretty_printer rtl_slim_pp;
 871   print_pattern (&rtl_slim_pp, x, 0);
 872   return ggc_strdup (pp_formatted_text (&rtl_slim_pp));
 873 }
 874
 875 /* Emit a slim dump of X (an insn) to stderr.  */
 876 extern void debug_insn_slim (const_rtx);
 877 DEBUG_FUNCTION void
 878 debug_insn_slim (const_rtx x)
 879 {
 880   dump_insn_slim (stderr, x);
 881 }
 882
 883 /* Same as above, but using dump_rtl_slim.  */
 884 extern void debug_rtl_slim (FILE *, const_rtx, const_rtx, int, int);
 885 DEBUG_FUNCTION void
 886 debug_rtl_slim (const_rtx first, const_rtx last, int count, int flags)
 887 {
 888   dump_rtl_slim (stderr, first, last, count, flags);
 889 }
 890
 891 extern void debug_bb_slim (basic_block);
 892 DEBUG_FUNCTION void
 893 debug_bb_slim (basic_block bb)
 894 {
 895   dump_bb (stderr, bb, 0, TDF_SLIM | TDF_BLOCKS);
 896 }
 897
 898 extern void debug_bb_n_slim (int);
 899 DEBUG_FUNCTION void
 900 debug_bb_n_slim (int n)
 901 {
 902   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, n);
 903   debug_bb_slim (bb);
 904 }
 905