gcc/tree-pretty-print.c

   1 /* Pretty formatting of GENERIC trees in C syntax.
   2    Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
   3    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "errors.h"
  27 #include "tree.h"
  28 #include "diagnostic.h"
  29 #include "real.h"
  30 #include "hashtab.h"
  31 #include "tree-flow.h"
  32 #include "langhooks.h"
  33 #include "tree-iterator.h"
  34 #include "tree-chrec.h"
  35
  36 /* Local functions, macros and variables.  */
  37 static int op_prio (tree);
  38 static const char *op_symbol (tree);
  39 static void pretty_print_string (pretty_printer *, const char*);
  40 static void print_call_name (pretty_printer *, tree);
  41 static void newline_and_indent (pretty_printer *, int);
  42 static void maybe_init_pretty_print (FILE *);
  43 static void print_declaration (pretty_printer *, tree, int, int);
  44 static void print_struct_decl (pretty_printer *, tree, int, int);
  45 static void do_niy (pretty_printer *, tree);
  46 static void dump_vops (pretty_printer *, tree, int, int);
  47 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
  48
  49 #define INDENT(SPACE) do { \
  50   int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
  51
  52 #define NIY do_niy(buffer,node)
  53
  54 #define PRINT_FUNCTION_NAME(NODE)  pp_printf             \
  55   (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ?              \
  56    lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
  57    lang_hooks.decl_printable_name (NODE, 1))
  58
  59 static pretty_printer buffer;
  60 static int initialized = 0;
  61 static bool dumping_stmts;
  62
  63 /* Try to print something for an unknown tree code.  */
  64
  65 static void
  66 do_niy (pretty_printer *buffer, tree node)
  67 {
  68   int i, len;
  69
  70   pp_string (buffer, "<<< Unknown tree: ");
  71   pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
  72
  73   if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (node))))
  74     {
  75       len = first_rtl_op (TREE_CODE (node));
  76       for (i = 0; i < len; ++i)
  77         {
  78           newline_and_indent (buffer, 2);
  79           dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
  80         }
  81     }
  82
  83   pp_string (buffer, " >>>\n");
  84 }
  85
  86 void
  87 debug_generic_expr (tree t)
  88 {
  89   print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
  90   fprintf (stderr, "\n");
  91 }
  92
  93 void
  94 debug_generic_stmt (tree t)
  95 {
  96   print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID);
  97   fprintf (stderr, "\n");
  98 }
  99
 100 /* Prints declaration DECL to the FILE with details specified by FLAGS.  */
 101 void
 102 print_generic_decl (FILE *file, tree decl, int flags)
 103 {
 104   maybe_init_pretty_print (file);
 105   dumping_stmts = true;
 106   print_declaration (&buffer, decl, 2, flags);
 107   pp_write_text_to_stream (&buffer);
 108 }
 109
 110 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 111    to show in the dump.  See TDF_* in tree.h.  */
 112
 113 void
 114 print_generic_stmt (FILE *file, tree t, int flags)
 115 {
 116   maybe_init_pretty_print (file);
 117   dumping_stmts = true;
 118   dump_generic_node (&buffer, t, 0, flags, true);
 119   pp_flush (&buffer);
 120 }
 121
 122 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 123    to show in the dump.  See TDF_* in tree.h.  The output is indented by
 124    INDENT spaces.  */
 125
 126 void
 127 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
 128 {
 129   int i;
 130
 131   maybe_init_pretty_print (file);
 132   dumping_stmts = true;
 133
 134   for (i = 0; i < indent; i++)
 135     pp_space (&buffer);
 136   dump_generic_node (&buffer, t, indent, flags, true);
 137   pp_flush (&buffer);
 138 }
 139
 140 /* Print a single expression T on file FILE.  FLAGS specifies details to show
 141    in the dump.  See TDF_* in tree.h.  */
 142
 143 void
 144 print_generic_expr (FILE *file, tree t, int flags)
 145 {
 146   maybe_init_pretty_print (file);
 147   dumping_stmts = false;
 148   dump_generic_node (&buffer, t, 0, flags, false);
 149 }
 150
 151 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
 152    in FLAGS.  */
 153
 154 static void
 155 dump_decl_name (pretty_printer *buffer, tree node, int flags)
 156 {
 157   if (DECL_NAME (node))
 158     pp_tree_identifier (buffer, DECL_NAME (node));
 159
 160   if ((flags & TDF_UID)
 161       || DECL_NAME (node) == NULL_TREE)
 162     {
 163       if (TREE_CODE (node) == LABEL_DECL
 164           && LABEL_DECL_UID (node) != -1)
 165         pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
 166                    LABEL_DECL_UID (node));
 167       else
 168         {
 169           char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';
 170           pp_printf (buffer, "%c.%u", c, DECL_UID (node));
 171         }
 172     }
 173 }
 174
 175 /* Like the above, but used for pretty printing function calls.  */
 176
 177 static void
 178 dump_function_name (pretty_printer *buffer, tree node)
 179 {
 180   if (DECL_NAME (node))
 181     PRINT_FUNCTION_NAME (node);
 182   else
 183     dump_decl_name (buffer, node, 0);
 184 }
 185
 186 /* Dump a function declaration.  NODE is the FUNCTION_TYPE.  BUFFER, SPC and
 187    FLAGS are as in dump_generic_node.  */
 188
 189 static void
 190 dump_function_declaration (pretty_printer *buffer, tree node,
 191                            int spc, int flags)
 192 {
 193   bool wrote_arg = false;
 194   tree arg;
 195
 196   pp_space (buffer);
 197   pp_character (buffer, '(');
 198
 199   /* Print the argument types.  The last element in the list is a VOID_TYPE.
 200      The following avoids printing the last element.  */
 201   arg = TYPE_ARG_TYPES (node);
 202   while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
 203     {
 204       wrote_arg = true;
 205       dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
 206       arg = TREE_CHAIN (arg);
 207       if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
 208         {
 209           pp_character (buffer, ',');
 210           pp_space (buffer);
 211         }
 212     }
 213
 214   if (!wrote_arg)
 215     pp_string (buffer, "void");
 216
 217   pp_character (buffer, ')');
 218 }
 219
 220 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
 221    FLAGS specifies details to show in the dump (see TDF_* in tree.h).  If
 222    IS_STMT is true, the object printed is considered to be a statement
 223    and it is terminated by ';' if appropriate.  */
 224
 225 int
 226 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 227                    bool is_stmt)
 228 {
 229   tree type;
 230   tree op0, op1;
 231   const char *str;
 232   bool is_expr;
 233
 234   if (node == NULL_TREE)
 235     return spc;
 236
 237   is_expr = EXPR_P (node);
 238
 239   if (TREE_CODE (node) != ERROR_MARK
 240       && is_gimple_stmt (node)
 241       && (flags & TDF_VOPS)
 242       && stmt_ann (node))
 243     dump_vops (buffer, node, spc, flags);
 244
 245   if (dumping_stmts
 246       && (flags & TDF_LINENO)
 247       && EXPR_HAS_LOCATION (node))
 248     {
 249       expanded_location xloc = expand_location (EXPR_LOCATION (node));
 250       pp_character (buffer, '[');
 251       if (xloc.file)
 252         {
 253           pp_string (buffer, xloc.file);
 254           pp_string (buffer, " : ");
 255         }
 256       pp_decimal_int (buffer, xloc.line);
 257       pp_string (buffer, "] ");
 258     }
 259
 260   switch (TREE_CODE (node))
 261     {
 262     case ERROR_MARK:
 263       pp_string (buffer, "<<< error >>>");
 264       break;
 265
 266     case IDENTIFIER_NODE:
 267       pp_tree_identifier (buffer, node);
 268       break;
 269
 270     case TREE_LIST:
 271       while (node && node != error_mark_node)
 272         {
 273           if (TREE_PURPOSE (node))
 274             {
 275               dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
 276               pp_space (buffer);
 277             }
 278           dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
 279           node = TREE_CHAIN (node);
 280           if (node && TREE_CODE (node) == TREE_LIST)
 281             {
 282               pp_character (buffer, ',');
 283               pp_space (buffer);
 284             }
 285         }
 286       break;
 287
 288     case TREE_VEC:
 289       dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
 290       break;
 291
 292     case BLOCK:
 293       NIY;
 294       break;
 295
 296     case VOID_TYPE:
 297     case INTEGER_TYPE:
 298     case REAL_TYPE:
 299     case COMPLEX_TYPE:
 300     case VECTOR_TYPE:
 301     case ENUMERAL_TYPE:
 302     case BOOLEAN_TYPE:
 303     case CHAR_TYPE:
 304       {
 305         unsigned int quals = TYPE_QUALS (node);
 306         char class;
 307
 308         if (quals & TYPE_QUAL_CONST)
 309           pp_string (buffer, "const ");
 310         else if (quals & TYPE_QUAL_VOLATILE)
 311           pp_string (buffer, "volatile ");
 312         else if (quals & TYPE_QUAL_RESTRICT)
 313           pp_string (buffer, "restrict ");
 314
 315         class = TREE_CODE_CLASS (TREE_CODE (node));
 316
 317         if (class == 'd')
 318           {
 319             if (DECL_NAME (node))
 320               dump_decl_name (buffer, node, flags);
 321             else
 322               pp_string (buffer, "<unnamed type decl>");
 323           }
 324         else if (class == 't')
 325           {
 326             if (TYPE_NAME (node))
 327               {
 328                 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
 329                   pp_tree_identifier (buffer, TYPE_NAME (node));
 330                 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
 331                          && DECL_NAME (TYPE_NAME (node)))
 332                   dump_decl_name (buffer, TYPE_NAME (node), flags);
 333                 else
 334                   pp_string (buffer, "<unnamed type>");
 335               }
 336             else
 337               pp_string (buffer, "<unnamed type>");
 338           }
 339         break;
 340       }
 341
 342     case POINTER_TYPE:
 343     case REFERENCE_TYPE:
 344       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
 345
 346       if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
 347         {
 348           tree fnode = TREE_TYPE (node);
 349
 350           dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
 351           pp_space (buffer);
 352           pp_character (buffer, '(');
 353           pp_string (buffer, str);
 354           if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
 355             dump_decl_name (buffer, TYPE_NAME (node), flags);
 356           else
 357             pp_printf (buffer, "<T%x>", TYPE_UID (node));
 358
 359           pp_character (buffer, ')');
 360           dump_function_declaration (buffer, fnode, spc, flags);
 361         }
 362       else
 363         {
 364           unsigned int quals = TYPE_QUALS (node);
 365
 366           dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 367           pp_space (buffer);
 368           pp_string (buffer, str);
 369
 370           if (quals & TYPE_QUAL_CONST)
 371             pp_string (buffer, " const");
 372           else if (quals & TYPE_QUAL_VOLATILE)
 373             pp_string (buffer,  "volatile");
 374           else if (quals & TYPE_QUAL_RESTRICT)
 375             pp_string (buffer, " restrict");
 376         }
 377       break;
 378
 379     case OFFSET_TYPE:
 380       NIY;
 381       break;
 382
 383     case METHOD_TYPE:
 384       dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
 385       pp_string (buffer, "::");
 386       break;
 387
 388     case FILE_TYPE:
 389       NIY;
 390       break;
 391
 392     case ARRAY_TYPE:
 393       {
 394         tree tmp;
 395
 396         /* Print the innermost component type.  */
 397         for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
 398              tmp = TREE_TYPE (tmp))
 399           ;
 400         dump_generic_node (buffer, tmp, spc, flags, false);
 401
 402         /* Print the dimensions.  */
 403         for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE;
 404              tmp = TREE_TYPE (tmp))
 405           {
 406             tree domain = TYPE_DOMAIN (tmp);
 407
 408             pp_character (buffer, '[');
 409             if (domain)
 410               {
 411                 if (TYPE_MIN_VALUE (domain)
 412                     && !integer_zerop (TYPE_MIN_VALUE (domain)))
 413                   {
 414                     dump_generic_node (buffer, TYPE_MIN_VALUE (domain),
 415                                        spc, flags, false);
 416                     pp_string (buffer, " .. ");
 417                   }
 418
 419                 if (TYPE_MAX_VALUE (domain))
 420                   dump_generic_node (buffer, TYPE_MAX_VALUE (domain),
 421                                      spc, flags, false);
 422               }
 423             else
 424               pp_string (buffer, "<unknown>");
 425
 426             pp_character (buffer, ']');
 427           }
 428         break;
 429       }
 430
 431     case SET_TYPE:
 432       NIY;
 433       break;
 434
 435     case RECORD_TYPE:
 436     case UNION_TYPE:
 437     case QUAL_UNION_TYPE:
 438       /* Print the name of the structure.  */
 439       if (TREE_CODE (node) == RECORD_TYPE)
 440         pp_string (buffer, "struct ");
 441       else if (TREE_CODE (node) == UNION_TYPE)
 442         pp_string (buffer, "union ");
 443
 444       if (TYPE_NAME (node))
 445         dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
 446       else
 447         print_struct_decl (buffer, node, spc, flags);
 448       break;
 449
 450     case LANG_TYPE:
 451       NIY;
 452       break;
 453
 454     case INTEGER_CST:
 455       if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
 456         {
 457           /* In the case of a pointer, one may want to divide by the
 458              size of the pointed-to type.  Unfortunately, this not
 459              straightforward.  The C front-end maps expressions
 460
 461              (int *) 5
 462              int *p; (p + 5)
 463
 464              in such a way that the two INTEGER_CST nodes for "5" have
 465              different values but identical types.  In the latter
 466              case, the 5 is multiplied by sizeof (int) in c-common.c
 467              (pointer_int_sum) to convert it to a byte address, and
 468              yet the type of the node is left unchanged.  Argh.  What
 469              is consistent though is that the number value corresponds
 470              to bytes (UNITS) offset.
 471
 472              NB: Neither of the following divisors can be trivially
 473              used to recover the original literal:
 474
 475              TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
 476              TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))  */
 477           pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
 478           pp_string (buffer, "B"); /* pseudo-unit */
 479         }
 480       else if (! host_integerp (node, 0))
 481         {
 482           tree val = node;
 483
 484           if (tree_int_cst_sgn (val) < 0)
 485             {
 486               pp_character (buffer, '-');
 487               val = build_int_cst_wide (NULL_TREE,
 488                                         -TREE_INT_CST_LOW (val),
 489                                         ~TREE_INT_CST_HIGH (val)
 490                                         + !TREE_INT_CST_LOW (val));
 491             }
 492           /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
 493              systems?  */
 494           {
 495             static char format[10]; /* "%x%09999x\0" */
 496             if (!format[0])
 497               sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
 498             sprintf (pp_buffer (buffer)->digit_buffer, format,
 499                      TREE_INT_CST_HIGH (val),
 500                      TREE_INT_CST_LOW (val));
 501             pp_string (buffer, pp_buffer (buffer)->digit_buffer);
 502           }
 503         }
 504       else
 505         pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
 506       break;
 507
 508     case REAL_CST:
 509       /* Code copied from print_node.  */
 510       {
 511         REAL_VALUE_TYPE d;
 512         if (TREE_OVERFLOW (node))
 513           pp_string (buffer, " overflow");
 514
 515 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
 516         d = TREE_REAL_CST (node);
 517         if (REAL_VALUE_ISINF (d))
 518           pp_string (buffer, " Inf");
 519         else if (REAL_VALUE_ISNAN (d))
 520           pp_string (buffer, " Nan");
 521         else
 522           {
 523             char string[100];
 524             real_to_decimal (string, &d, sizeof (string), 0, 1);
 525             pp_string (buffer, string);
 526           }
 527 #else
 528         {
 529           HOST_WIDE_INT i;
 530           unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
 531           pp_string (buffer, "0x");
 532           for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
 533             output_formatted_integer (buffer, "%02x", *p++);
 534         }
 535 #endif
 536         break;
 537       }
 538
 539     case COMPLEX_CST:
 540       pp_string (buffer, "__complex__ (");
 541       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
 542       pp_string (buffer, ", ");
 543       dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
 544       pp_string (buffer, ")");
 545       break;
 546
 547     case STRING_CST:
 548       pp_string (buffer, "\"");
 549       pretty_print_string (buffer, TREE_STRING_POINTER (node));
 550       pp_string (buffer, "\"");
 551       break;
 552
 553     case VECTOR_CST:
 554       {
 555         tree elt;
 556         pp_string (buffer, "{ ");
 557         for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
 558           {
 559             dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
 560             if (TREE_CHAIN (elt))
 561               pp_string (buffer, ", ");
 562           }
 563         pp_string (buffer, " }");
 564       }
 565       break;
 566
 567     case FUNCTION_TYPE:
 568       break;
 569
 570     case FUNCTION_DECL:
 571     case CONST_DECL:
 572       dump_decl_name (buffer, node, flags);
 573       break;
 574
 575     case LABEL_DECL:
 576       if (DECL_NAME (node))
 577         dump_decl_name (buffer, node, flags);
 578       else if (LABEL_DECL_UID (node) != -1)
 579         pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
 580                    LABEL_DECL_UID (node));
 581       else
 582         pp_printf (buffer, "<D%u>", DECL_UID (node));
 583       break;
 584
 585     case TYPE_DECL:
 586       if (DECL_IS_BUILTIN (node))
 587         {
 588           /* Don't print the declaration of built-in types.  */
 589           break;
 590         }
 591       if (DECL_NAME (node))
 592         dump_decl_name (buffer, node, flags);
 593       else
 594         {
 595           if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
 596                || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
 597               && TYPE_METHODS (TREE_TYPE (node)))
 598             {
 599               /* The type is a c++ class: all structures have at least
 600                  4 methods.  */
 601               pp_string (buffer, "class ");
 602               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 603             }
 604           else
 605             {
 606               pp_string (buffer,
 607                          (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
 608                           ? "union" : "struct "));
 609               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 610             }
 611         }
 612       break;
 613
 614     case VAR_DECL:
 615     case PARM_DECL:
 616     case FIELD_DECL:
 617     case NAMESPACE_DECL:
 618       dump_decl_name (buffer, node, flags);
 619       break;
 620
 621     case RESULT_DECL:
 622       pp_string (buffer, "<retval>");
 623       break;
 624
 625     case COMPONENT_REF:
 626       op0 = TREE_OPERAND (node, 0);
 627       str = ".";
 628       if (TREE_CODE (op0) == INDIRECT_REF)
 629         {
 630           op0 = TREE_OPERAND (op0, 0);
 631           str = "->";
 632         }
 633       if (op_prio (op0) < op_prio (node))
 634         pp_character (buffer, '(');
 635       dump_generic_node (buffer, op0, spc, flags, false);
 636       if (op_prio (op0) < op_prio (node))
 637         pp_character (buffer, ')');
 638       pp_string (buffer, str);
 639       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 640
 641       if (TREE_CODE (op0) != VALUE_HANDLE)
 642         {
 643           op0 = component_ref_field_offset (node);
 644           if (op0 && TREE_CODE (op0) != INTEGER_CST)
 645             {
 646               pp_string (buffer, "{off: ");
 647               dump_generic_node (buffer, op0, spc, flags, false);
 648               pp_character (buffer, '}');
 649             }
 650         }
 651       break;
 652
 653     case BIT_FIELD_REF:
 654       pp_string (buffer, "BIT_FIELD_REF <");
 655       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
 656       pp_string (buffer, ", ");
 657       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 658       pp_string (buffer, ", ");
 659       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
 660       pp_string (buffer, ">");
 661       break;
 662
 663     case ARRAY_REF:
 664     case ARRAY_RANGE_REF:
 665       op0 = TREE_OPERAND (node, 0);
 666       if (op_prio (op0) < op_prio (node))
 667         pp_character (buffer, '(');
 668       dump_generic_node (buffer, op0, spc, flags, false);
 669       if (op_prio (op0) < op_prio (node))
 670         pp_character (buffer, ')');
 671       pp_character (buffer, '[');
 672       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 673       if (TREE_CODE (node) == ARRAY_RANGE_REF)
 674         pp_string (buffer, " ...");
 675       pp_character (buffer, ']');
 676
 677       op0 = array_ref_low_bound (node);
 678       op1 = array_ref_element_size (node);
 679
 680       if (!integer_zerop (op0)
 681           || (TYPE_SIZE_UNIT (TREE_TYPE (node))
 682               && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
 683         {
 684           pp_string (buffer, "{lb: ");
 685           dump_generic_node (buffer, op0, spc, flags, false);
 686           pp_string (buffer, " sz: ");
 687           dump_generic_node (buffer, op1, spc, flags, false);
 688           pp_character (buffer, '}');
 689         }
 690       break;
 691
 692     case CONSTRUCTOR:
 693       {
 694         tree lnode;
 695         bool is_struct_init = FALSE;
 696         pp_character (buffer, '{');
 697         lnode = CONSTRUCTOR_ELTS (node);
 698         if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
 699             || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
 700           is_struct_init = TRUE;
 701         while (lnode && lnode != error_mark_node)
 702           {
 703             tree val;
 704             if (TREE_PURPOSE (lnode) && is_struct_init)
 705               {
 706                 pp_character (buffer, '.');
 707                 dump_generic_node (buffer, TREE_PURPOSE (lnode), spc, flags, false);
 708                 pp_string (buffer, "=");
 709               }
 710             val = TREE_VALUE (lnode);
 711             if (val && TREE_CODE (val) == ADDR_EXPR)
 712               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
 713                 val = TREE_OPERAND (val, 0);
 714             if (val && TREE_CODE (val) == FUNCTION_DECL)
 715               {
 716                 dump_decl_name (buffer, val, flags);
 717               }
 718             else
 719               {
 720                 dump_generic_node (buffer, TREE_VALUE (lnode), spc, flags, false);
 721               }
 722             lnode = TREE_CHAIN (lnode);
 723             if (lnode && TREE_CODE (lnode) == TREE_LIST)
 724               {
 725                 pp_character (buffer, ',');
 726                 pp_space (buffer);
 727               }
 728           }
 729         pp_character (buffer, '}');
 730       }
 731       break;
 732
 733     case COMPOUND_EXPR:
 734       {
 735         tree *tp;
 736         if (flags & TDF_SLIM)
 737           {
 738             pp_string (buffer, "<COMPOUND_EXPR>");
 739             break;
 740           }
 741
 742         dump_generic_node (buffer, TREE_OPERAND (node, 0),
 743                            spc, flags, dumping_stmts);
 744         if (dumping_stmts)
 745           newline_and_indent (buffer, spc);
 746         else
 747           {
 748             pp_character (buffer, ',');
 749             pp_space (buffer);
 750           }
 751
 752         for (tp = &TREE_OPERAND (node, 1);
 753              TREE_CODE (*tp) == COMPOUND_EXPR;
 754              tp = &TREE_OPERAND (*tp, 1))
 755           {
 756             dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
 757                                spc, flags, dumping_stmts);
 758             if (dumping_stmts)
 759               newline_and_indent (buffer, spc);
 760             else
 761               {
 762                 pp_character (buffer, ',');
 763                 pp_space (buffer);
 764               }
 765           }
 766
 767         dump_generic_node (buffer, *tp, spc, flags, dumping_stmts);
 768       }
 769       break;
 770
 771     case STATEMENT_LIST:
 772       {
 773         tree_stmt_iterator si;
 774         bool first = true;
 775
 776         if ((flags & TDF_SLIM) || !dumping_stmts)
 777           {
 778             pp_string (buffer, "<STATEMENT_LIST>");
 779             break;
 780           }
 781
 782         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
 783           {
 784             if (!first)
 785               newline_and_indent (buffer, spc);
 786             else
 787               first = false;
 788             dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
 789           }
 790       }
 791       break;
 792
 793     case MODIFY_EXPR:
 794     case INIT_EXPR:
 795       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
 796       pp_space (buffer);
 797       pp_character (buffer, '=');
 798       pp_space (buffer);
 799       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 800       break;
 801
 802     case TARGET_EXPR:
 803       pp_string (buffer, "TARGET_EXPR <");
 804       dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
 805       pp_character (buffer, ',');
 806       pp_space (buffer);
 807       dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
 808       pp_character (buffer, '>');
 809       break;
 810
 811     case DECL_EXPR:
 812       print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
 813       is_stmt = false;
 814       break;
 815
 816     case COND_EXPR:
 817       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
 818         {
 819           pp_string (buffer, "if (");
 820           dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
 821           pp_character (buffer, ')');
 822           /* The lowered cond_exprs should always be printed in full.  */
 823           if (COND_EXPR_THEN (node)
 824               && TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR
 825               && COND_EXPR_ELSE (node)
 826               && TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR)
 827             {
 828               pp_space (buffer);
 829               dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
 830               pp_string (buffer, " else ");
 831               dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
 832             }
 833           else if (!(flags & TDF_SLIM))
 834             {
 835               /* Output COND_EXPR_THEN.  */
 836               if (COND_EXPR_THEN (node))
 837                 {
 838                   newline_and_indent (buffer, spc+2);
 839                   pp_character (buffer, '{');
 840                   newline_and_indent (buffer, spc+4);
 841                   dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
 842                                      flags, true);
 843                   newline_and_indent (buffer, spc+2);
 844                   pp_character (buffer, '}');
 845                 }
 846
 847               /* Output COND_EXPR_ELSE.  */
 848               if (COND_EXPR_ELSE (node))
 849                 {
 850                   newline_and_indent (buffer, spc);
 851                   pp_string (buffer, "else");
 852                   newline_and_indent (buffer, spc+2);
 853                   pp_character (buffer, '{');
 854                   newline_and_indent (buffer, spc+4);
 855                   dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
 856                                      flags, true);
 857                   newline_and_indent (buffer, spc+2);
 858                   pp_character (buffer, '}');
 859                 }
 860             }
 861           is_expr = false;
 862         }
 863       else
 864         {
 865           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
 866           pp_space (buffer);
 867           pp_character (buffer, '?');
 868           pp_space (buffer);
 869           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 870           pp_space (buffer);
 871           pp_character (buffer, ':');
 872           pp_space (buffer);
 873           dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
 874         }
 875       break;
 876
 877     case BIND_EXPR:
 878       pp_character (buffer, '{');
 879       if (!(flags & TDF_SLIM))
 880         {
 881           if (BIND_EXPR_VARS (node))
 882             {
 883               pp_newline (buffer);
 884
 885               for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
 886                 {
 887                   print_declaration (buffer, op0, spc+2, flags);
 888                   pp_newline (buffer);
 889                 }
 890             }
 891
 892           newline_and_indent (buffer, spc+2);
 893           dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
 894           newline_and_indent (buffer, spc);
 895           pp_character (buffer, '}');
 896         }
 897       is_expr = false;
 898       break;
 899
 900     case CALL_EXPR:
 901       print_call_name (buffer, node);
 902
 903       /* Print parameters.  */
 904       pp_space (buffer);
 905       pp_character (buffer, '(');
 906       op1 = TREE_OPERAND (node, 1);
 907       if (op1)
 908         dump_generic_node (buffer, op1, spc, flags, false);
 909       pp_character (buffer, ')');
 910
 911       op1 = TREE_OPERAND (node, 2);
 912       if (op1)
 913         {
 914           pp_string (buffer, " [static-chain: ");
 915           dump_generic_node (buffer, op1, spc, flags, false);
 916           pp_character (buffer, ']');
 917         }
 918
 919       if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (node))
 920         pp_string (buffer, " [return slot addr]");
 921       if (CALL_EXPR_TAILCALL (node))
 922         pp_string (buffer, " [tail call]");
 923       break;
 924
 925     case WITH_CLEANUP_EXPR:
 926       NIY;
 927       break;
 928
 929     case CLEANUP_POINT_EXPR:
 930       pp_string (buffer, "<<cleanup_point ");
 931       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
 932       pp_string (buffer, ">>");
 933       break;
 934
 935     case PLACEHOLDER_EXPR:
 936       pp_string (buffer, "<PLACEHOLDER_EXPR ");
 937       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 938       pp_character (buffer, '>');
 939       break;
 940
 941       /* Binary arithmetic and logic expressions.  */
 942     case MULT_EXPR:
 943     case PLUS_EXPR:
 944     case MINUS_EXPR:
 945     case TRUNC_DIV_EXPR:
 946     case CEIL_DIV_EXPR:
 947     case FLOOR_DIV_EXPR:
 948     case ROUND_DIV_EXPR:
 949     case TRUNC_MOD_EXPR:
 950     case CEIL_MOD_EXPR:
 951     case FLOOR_MOD_EXPR:
 952     case ROUND_MOD_EXPR:
 953     case RDIV_EXPR:
 954     case EXACT_DIV_EXPR:
 955     case LSHIFT_EXPR:
 956     case RSHIFT_EXPR:
 957     case LROTATE_EXPR:
 958     case RROTATE_EXPR:
 959     case BIT_IOR_EXPR:
 960     case BIT_XOR_EXPR:
 961     case BIT_AND_EXPR:
 962     case TRUTH_ANDIF_EXPR:
 963     case TRUTH_ORIF_EXPR:
 964     case TRUTH_AND_EXPR:
 965     case TRUTH_OR_EXPR:
 966     case TRUTH_XOR_EXPR:
 967     case LT_EXPR:
 968     case LE_EXPR:
 969     case GT_EXPR:
 970     case GE_EXPR:
 971     case EQ_EXPR:
 972     case NE_EXPR:
 973     case UNLT_EXPR:
 974     case UNLE_EXPR:
 975     case UNGT_EXPR:
 976     case UNGE_EXPR:
 977     case UNEQ_EXPR:
 978     case LTGT_EXPR:
 979     case ORDERED_EXPR:
 980     case UNORDERED_EXPR:
 981       {
 982         const char *op = op_symbol (node);
 983         op0 = TREE_OPERAND (node, 0);
 984         op1 = TREE_OPERAND (node, 1);
 985
 986         /* When the operands are expressions with less priority,
 987            keep semantics of the tree representation.  */
 988         if (op_prio (op0) < op_prio (node))
 989           {
 990             pp_character (buffer, '(');
 991             dump_generic_node (buffer, op0, spc, flags, false);
 992             pp_character (buffer, ')');
 993           }
 994         else
 995           dump_generic_node (buffer, op0, spc, flags, false);
 996
 997         pp_space (buffer);
 998         pp_string (buffer, op);
 999         pp_space (buffer);
1000
1001         /* When the operands are expressions with less priority,
1002            keep semantics of the tree representation.  */
1003         if (op_prio (op1) < op_prio (node))
1004           {
1005             pp_character (buffer, '(');
1006             dump_generic_node (buffer, op1, spc, flags, false);
1007             pp_character (buffer, ')');
1008           }
1009         else
1010           dump_generic_node (buffer, op1, spc, flags, false);
1011       }
1012       break;
1013
1014       /* Unary arithmetic and logic expressions.  */
1015     case NEGATE_EXPR:
1016     case BIT_NOT_EXPR:
1017     case TRUTH_NOT_EXPR:
1018     case ADDR_EXPR:
1019     case PREDECREMENT_EXPR:
1020     case PREINCREMENT_EXPR:
1021     case INDIRECT_REF:
1022       if (TREE_CODE (node) == ADDR_EXPR
1023           && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1024               || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1025         ;       /* Do not output '&' for strings and function pointers.  */
1026       else
1027         pp_string (buffer, op_symbol (node));
1028
1029       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1030         {
1031           pp_character (buffer, '(');
1032           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1033           pp_character (buffer, ')');
1034         }
1035       else
1036         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1037       break;
1038
1039     case POSTDECREMENT_EXPR:
1040     case POSTINCREMENT_EXPR:
1041       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1042         {
1043           pp_character (buffer, '(');
1044           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1045           pp_character (buffer, ')');
1046         }
1047       else
1048         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1049       pp_string (buffer, op_symbol (node));
1050       break;
1051
1052     case MIN_EXPR:
1053       pp_string (buffer, "MIN_EXPR <");
1054       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1055       pp_string (buffer, ", ");
1056       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1057       pp_character (buffer, '>');
1058       break;
1059
1060     case MAX_EXPR:
1061       pp_string (buffer, "MAX_EXPR <");
1062       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1063       pp_string (buffer, ", ");
1064       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1065       pp_character (buffer, '>');
1066       break;
1067
1068     case ABS_EXPR:
1069       pp_string (buffer, "ABS_EXPR <");
1070       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1071       pp_character (buffer, '>');
1072       break;
1073
1074     case RANGE_EXPR:
1075       NIY;
1076       break;
1077
1078     case FIX_TRUNC_EXPR:
1079     case FIX_CEIL_EXPR:
1080     case FIX_FLOOR_EXPR:
1081     case FIX_ROUND_EXPR:
1082     case FLOAT_EXPR:
1083     case CONVERT_EXPR:
1084     case NOP_EXPR:
1085       type = TREE_TYPE (node);
1086       op0 = TREE_OPERAND (node, 0);
1087       if (type != TREE_TYPE (op0))
1088         {
1089           pp_character (buffer, '(');
1090           dump_generic_node (buffer, type, spc, flags, false);
1091           pp_string (buffer, ") ");
1092         }
1093       if (op_prio (op0) < op_prio (node))
1094         pp_character (buffer, '(');
1095       dump_generic_node (buffer, op0, spc, flags, false);
1096       if (op_prio (op0) < op_prio (node))
1097         pp_character (buffer, ')');
1098       break;
1099
1100     case VIEW_CONVERT_EXPR:
1101       pp_string (buffer, "VIEW_CONVERT_EXPR<");
1102       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1103       pp_string (buffer, ">(");
1104       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1105       pp_character (buffer, ')');
1106       break;
1107
1108     case NON_LVALUE_EXPR:
1109       pp_string (buffer, "NON_LVALUE_EXPR <");
1110       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1111       pp_character (buffer, '>');
1112       break;
1113
1114     case SAVE_EXPR:
1115       pp_string (buffer, "SAVE_EXPR <");
1116       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1117       pp_character (buffer, '>');
1118       break;
1119
1120     case COMPLEX_EXPR:
1121       pp_string (buffer, "COMPLEX_EXPR <");
1122       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1123       pp_string (buffer, ", ");
1124       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1125       pp_string (buffer, ">");
1126       break;
1127
1128     case CONJ_EXPR:
1129       pp_string (buffer, "CONJ_EXPR <");
1130       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1131       pp_string (buffer, ">");
1132       break;
1133
1134     case REALPART_EXPR:
1135       pp_string (buffer, "REALPART_EXPR <");
1136       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1137       pp_string (buffer, ">");
1138       break;
1139
1140     case IMAGPART_EXPR:
1141       pp_string (buffer, "IMAGPART_EXPR <");
1142       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1143       pp_string (buffer, ">");
1144       break;
1145
1146     case VA_ARG_EXPR:
1147       pp_string (buffer, "VA_ARG_EXPR <");
1148       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1149       pp_string (buffer, ">");
1150       break;
1151
1152     case TRY_FINALLY_EXPR:
1153     case TRY_CATCH_EXPR:
1154       pp_string (buffer, "try");
1155       newline_and_indent (buffer, spc+2);
1156       pp_string (buffer, "{");
1157       newline_and_indent (buffer, spc+4);
1158       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1159       newline_and_indent (buffer, spc+2);
1160       pp_string (buffer, "}");
1161       newline_and_indent (buffer, spc);
1162       pp_string (buffer,
1163                          (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1164       newline_and_indent (buffer, spc+2);
1165       pp_string (buffer, "{");
1166       newline_and_indent (buffer, spc+4);
1167       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1168       newline_and_indent (buffer, spc+2);
1169       pp_string (buffer, "}");
1170       is_expr = false;
1171       break;
1172
1173     case CATCH_EXPR:
1174       pp_string (buffer, "catch (");
1175       dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1176       pp_string (buffer, ")");
1177       newline_and_indent (buffer, spc+2);
1178       pp_string (buffer, "{");
1179       newline_and_indent (buffer, spc+4);
1180       dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1181       newline_and_indent (buffer, spc+2);
1182       pp_string (buffer, "}");
1183       is_expr = false;
1184       break;
1185
1186     case EH_FILTER_EXPR:
1187       pp_string (buffer, "<<<eh_filter (");
1188       dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1189       pp_string (buffer, ")>>>");
1190       newline_and_indent (buffer, spc+2);
1191       pp_string (buffer, "{");
1192       newline_and_indent (buffer, spc+4);
1193       dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1194       newline_and_indent (buffer, spc+2);
1195       pp_string (buffer, "}");
1196       is_expr = false;
1197       break;
1198
1199     case LABEL_EXPR:
1200       op0 = TREE_OPERAND (node, 0);
1201       /* If this is for break or continue, don't bother printing it.  */
1202       if (DECL_NAME (op0))
1203         {
1204           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1205           if (strcmp (name, "break") == 0
1206               || strcmp (name, "continue") == 0)
1207             break;
1208         }
1209       dump_generic_node (buffer, op0, spc, flags, false);
1210       pp_character (buffer, ':');
1211       if (DECL_NONLOCAL (op0))
1212         pp_string (buffer, " [non-local]");
1213       break;
1214
1215     case LABELED_BLOCK_EXPR:
1216       op0 = LABELED_BLOCK_LABEL (node);
1217       /* If this is for break or continue, don't bother printing it.  */
1218       if (DECL_NAME (op0))
1219         {
1220           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1221           if (strcmp (name, "break") == 0
1222               || strcmp (name, "continue") == 0)
1223             {
1224               dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc, flags, false);
1225               break;
1226             }
1227         }
1228       dump_generic_node (buffer, LABELED_BLOCK_LABEL (node), spc, flags, false);
1229       pp_string (buffer, ": {");
1230       if (!(flags & TDF_SLIM))
1231         newline_and_indent (buffer, spc+2);
1232       dump_generic_node (buffer, LABELED_BLOCK_BODY (node), spc+2, flags, true);
1233       if (!flags)
1234         newline_and_indent (buffer, spc);
1235       pp_character (buffer, '}');
1236       is_expr = false;
1237       break;
1238
1239     case EXIT_BLOCK_EXPR:
1240       op0 = LABELED_BLOCK_LABEL (EXIT_BLOCK_LABELED_BLOCK (node));
1241       /* If this is for a break or continue, print it accordingly.  */
1242       if (DECL_NAME (op0))
1243         {
1244           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1245           if (strcmp (name, "break") == 0
1246               || strcmp (name, "continue") == 0)
1247             {
1248               pp_string (buffer, name);
1249               break;
1250             }
1251         }
1252       pp_string (buffer, "<<<exit block ");
1253       dump_generic_node (buffer, op0, spc, flags, false);
1254       pp_string (buffer, ">>>");
1255       break;
1256
1257     case EXC_PTR_EXPR:
1258       pp_string (buffer, "<<<exception object>>>");
1259       break;
1260
1261     case FILTER_EXPR:
1262       pp_string (buffer, "<<<filter object>>>");
1263       break;
1264
1265     case LOOP_EXPR:
1266       pp_string (buffer, "while (1)");
1267       if (!(flags & TDF_SLIM))
1268         {
1269           newline_and_indent (buffer, spc+2);
1270           pp_character (buffer, '{');
1271           newline_and_indent (buffer, spc+4);
1272           dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1273           newline_and_indent (buffer, spc+2);
1274           pp_character (buffer, '}');
1275         }
1276       is_expr = false;
1277       break;
1278
1279     case RETURN_EXPR:
1280       pp_string (buffer, "return");
1281       op0 = TREE_OPERAND (node, 0);
1282       if (op0)
1283         {
1284           pp_space (buffer);
1285           if (TREE_CODE (op0) == MODIFY_EXPR)
1286             dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
1287           else
1288             dump_generic_node (buffer, op0, spc, flags, false);
1289         }
1290       break;
1291
1292     case EXIT_EXPR:
1293       pp_string (buffer, "if (");
1294       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1295       pp_string (buffer, ") break");
1296       break;
1297
1298     case SWITCH_EXPR:
1299       pp_string (buffer, "switch (");
1300       dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1301       pp_character (buffer, ')');
1302       if (!(flags & TDF_SLIM))
1303         {
1304           newline_and_indent (buffer, spc+2);
1305           pp_character (buffer, '{');
1306           if (SWITCH_BODY (node))
1307             {
1308               newline_and_indent (buffer, spc+4);
1309               dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags, true);
1310             }
1311           else
1312             {
1313               tree vec = SWITCH_LABELS (node);
1314               size_t i, n = TREE_VEC_LENGTH (vec);
1315               for (i = 0; i < n; ++i)
1316                 {
1317                   tree elt = TREE_VEC_ELT (vec, i);
1318                   newline_and_indent (buffer, spc+4);
1319                   dump_generic_node (buffer, elt, spc+4, flags, false);
1320                   pp_string (buffer, " goto ");
1321                   dump_generic_node (buffer, CASE_LABEL (elt), spc+4, flags, true);
1322                   pp_semicolon (buffer);
1323                 }
1324             }
1325           newline_and_indent (buffer, spc+2);
1326           pp_character (buffer, '}');
1327         }
1328       is_expr = false;
1329       break;
1330
1331     case GOTO_EXPR:
1332       op0 = GOTO_DESTINATION (node);
1333       if (TREE_CODE (op0) != SSA_NAME
1334           && DECL_P (op0)
1335           && DECL_NAME (op0))
1336         {
1337           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1338           if (strcmp (name, "break") == 0
1339               || strcmp (name, "continue") == 0)
1340             {
1341               pp_string (buffer, name);
1342               break;
1343             }
1344         }
1345       pp_string (buffer, "goto ");
1346       dump_generic_node (buffer, op0, spc, flags, false);
1347       break;
1348
1349     case RESX_EXPR:
1350       pp_string (buffer, "resx");
1351       /* ??? Any sensible way to present the eh region?  */
1352       break;
1353
1354     case ASM_EXPR:
1355       pp_string (buffer, "__asm__");
1356       if (ASM_VOLATILE_P (node))
1357         pp_string (buffer, " __volatile__");
1358       pp_character (buffer, '(');
1359       dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1360       pp_character (buffer, ':');
1361       dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1362       pp_character (buffer, ':');
1363       dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1364       if (ASM_CLOBBERS (node))
1365         {
1366           pp_character (buffer, ':');
1367           dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1368         }
1369       pp_string (buffer, ")");
1370       break;
1371
1372     case CASE_LABEL_EXPR:
1373       if (CASE_LOW (node) && CASE_HIGH (node))
1374         {
1375           pp_string (buffer, "case ");
1376           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1377           pp_string (buffer, " ... ");
1378           dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1379         }
1380       else if (CASE_LOW (node))
1381         {
1382           pp_string (buffer, "case ");
1383           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1384         }
1385       else
1386         pp_string (buffer, "default ");
1387       pp_character (buffer, ':');
1388       break;
1389
1390     case OBJ_TYPE_REF:
1391       pp_string (buffer, "OBJ_TYPE_REF(");
1392       dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1393       pp_character (buffer, ';');
1394       dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1395       pp_character (buffer, '-');
1396       pp_character (buffer, '>');
1397       dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1398       pp_character (buffer, ')');
1399       break;
1400
1401     case PHI_NODE:
1402       {
1403         int i;
1404
1405         dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1406         pp_string (buffer, " = PHI <");
1407         for (i = 0; i < PHI_NUM_ARGS (node); i++)
1408           {
1409             dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1410             pp_string (buffer, "(");
1411             pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1412             pp_string (buffer, ")");
1413             if (i < PHI_NUM_ARGS (node) - 1)
1414               pp_string (buffer, ", ");
1415           }
1416         pp_string (buffer, ">;");
1417       }
1418       break;
1419
1420     case SSA_NAME:
1421       dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1422       pp_string (buffer, "_");
1423       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1424       break;
1425
1426     case WITH_SIZE_EXPR:
1427       pp_string (buffer, "WITH_SIZE_EXPR <");
1428       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1429       pp_string (buffer, ", ");
1430       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1431       pp_string (buffer, ">");
1432       break;
1433
1434     case VALUE_HANDLE:
1435       pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1436       break;
1437
1438     case SCEV_KNOWN:
1439       pp_string (buffer, "scev_known");
1440       break;
1441
1442     case SCEV_NOT_KNOWN:
1443       pp_string (buffer, "scev_not_known");
1444       break;
1445
1446     case POLYNOMIAL_CHREC:
1447       pp_string (buffer, "{");
1448       dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1449       pp_string (buffer, ", +, ");
1450       dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1451       pp_string (buffer, "}_");
1452       dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1453       is_stmt = false;
1454       break;
1455
1456     default:
1457       NIY;
1458     }
1459
1460   if (is_stmt && is_expr)
1461     pp_semicolon (buffer);
1462   pp_write_text_to_stream (buffer);
1463
1464   return spc;
1465 }
1466
1467 /* Print the declaration of a variable.  */
1468
1469 static void
1470 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
1471 {
1472   INDENT (spc);
1473
1474   if (TREE_CODE (t) == TYPE_DECL)
1475     pp_string (buffer, "typedef ");
1476
1477   if (DECL_REGISTER (t))
1478     pp_string (buffer, "register ");
1479
1480   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
1481     pp_string (buffer, "extern ");
1482   else if (TREE_STATIC (t))
1483     pp_string (buffer, "static ");
1484
1485   /* Print the type and name.  */
1486   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
1487     {
1488       tree tmp;
1489
1490       /* Print array's type.  */
1491       tmp = TREE_TYPE (t);
1492       while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
1493         tmp = TREE_TYPE (tmp);
1494       dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
1495
1496       /* Print variable's name.  */
1497       pp_space (buffer);
1498       dump_generic_node (buffer, t, spc, flags, false);
1499
1500       /* Print the dimensions.  */
1501       tmp = TREE_TYPE (t);
1502       while (TREE_CODE (tmp) == ARRAY_TYPE)
1503         {
1504           pp_character (buffer, '[');
1505           if (TYPE_DOMAIN (tmp))
1506             {
1507               if (TREE_CODE (TYPE_SIZE (tmp)) == INTEGER_CST)
1508                 pp_wide_integer (buffer,
1509                                 TREE_INT_CST_LOW (TYPE_SIZE (tmp)) /
1510                                 TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tmp))));
1511               else
1512                 dump_generic_node (buffer, TYPE_SIZE_UNIT (tmp), spc, flags,
1513                                    false);
1514             }
1515           pp_character (buffer, ']');
1516           tmp = TREE_TYPE (tmp);
1517         }
1518     }
1519   else if (TREE_CODE (t) == FUNCTION_DECL)
1520     {
1521       dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
1522       pp_space (buffer);
1523       dump_decl_name (buffer, t, flags);
1524       dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
1525     }
1526   else
1527     {
1528       /* Print type declaration.  */
1529       dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
1530
1531       /* Print variable's name.  */
1532       pp_space (buffer);
1533       dump_generic_node (buffer, t, spc, flags, false);
1534     }
1535
1536   /* The initial value of a function serves to determine wether the function
1537      is declared or defined.  So the following does not apply to function
1538      nodes.  */
1539   if (TREE_CODE (t) != FUNCTION_DECL)
1540     {
1541       /* Print the initial value.  */
1542       if (DECL_INITIAL (t))
1543         {
1544           pp_space (buffer);
1545           pp_character (buffer, '=');
1546           pp_space (buffer);
1547           dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
1548         }
1549     }
1550
1551   pp_character (buffer, ';');
1552 }
1553
1554
1555 /* Prints a structure: name, fields, and methods.
1556    FIXME: Still incomplete.  */
1557
1558 static void
1559 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
1560 {
1561   /* Print the name of the structure.  */
1562   if (TYPE_NAME (node))
1563     {
1564       INDENT (spc);
1565       if (TREE_CODE (node) == RECORD_TYPE)
1566         pp_string (buffer, "struct ");
1567       else if ((TREE_CODE (node) == UNION_TYPE
1568                 || TREE_CODE (node) == QUAL_UNION_TYPE))
1569         pp_string (buffer, "union ");
1570
1571       dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
1572     }
1573
1574   /* Print the contents of the structure.  */
1575   pp_newline (buffer);
1576   INDENT (spc);
1577   pp_character (buffer, '{');
1578   pp_newline (buffer);
1579
1580   /* Print the fields of the structure.  */
1581   {
1582     tree tmp;
1583     tmp = TYPE_FIELDS (node);
1584     while (tmp)
1585       {
1586         /* Avoid to print recursively the structure.  */
1587         /* FIXME : Not implemented correctly...,
1588            what about the case when we have a cycle in the contain graph? ...
1589            Maybe this could be solved by looking at the scope in which the
1590            structure was declared.  */
1591         if (TREE_TYPE (tmp) != node
1592             || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
1593                 && TREE_TYPE (TREE_TYPE (tmp)) != node))
1594           {
1595             print_declaration (buffer, tmp, spc+2, flags);
1596             pp_newline (buffer);
1597           }
1598         tmp = TREE_CHAIN (tmp);
1599       }
1600   }
1601   INDENT (spc);
1602   pp_character (buffer, '}');
1603 }
1604
1605 /* Return the priority of the operator OP.
1606
1607    From lowest to highest precedence with either left-to-right (L-R)
1608    or right-to-left (R-L) associativity]:
1609
1610      1  [L-R] ,
1611      2  [R-L] = += -= *= /= %= &= ^= |= <<= >>=
1612      3  [R-L] ?:
1613      4  [L-R] ||
1614      5  [L-R] &&
1615      6  [L-R] |
1616      7  [L-R] ^
1617      8  [L-R] &
1618      9  [L-R] == !=
1619     10  [L-R] < <= > >=
1620     11  [L-R] << >>
1621     12  [L-R] + -
1622     13  [L-R] * / %
1623     14  [R-L] ! ~ ++ -- + - * & (type) sizeof
1624     15  [L-R] fn() [] -> .
1625
1626    unary +, - and * have higher precedence than the corresponding binary
1627    operators.  */
1628
1629 static int
1630 op_prio (tree op)
1631 {
1632   if (op == NULL)
1633     return 9999;
1634
1635   switch (TREE_CODE (op))
1636     {
1637     case TREE_LIST:
1638     case COMPOUND_EXPR:
1639     case BIND_EXPR:
1640       return 1;
1641
1642     case MODIFY_EXPR:
1643     case INIT_EXPR:
1644       return 2;
1645
1646     case COND_EXPR:
1647       return 3;
1648
1649     case TRUTH_OR_EXPR:
1650     case TRUTH_ORIF_EXPR:
1651       return 4;
1652
1653     case TRUTH_AND_EXPR:
1654     case TRUTH_ANDIF_EXPR:
1655       return 5;
1656
1657     case BIT_IOR_EXPR:
1658       return 6;
1659
1660     case BIT_XOR_EXPR:
1661     case TRUTH_XOR_EXPR:
1662       return 7;
1663
1664     case BIT_AND_EXPR:
1665       return 8;
1666
1667     case EQ_EXPR:
1668     case NE_EXPR:
1669       return 9;
1670
1671     case UNLT_EXPR:
1672     case UNLE_EXPR:
1673     case UNGT_EXPR:
1674     case UNGE_EXPR:
1675     case UNEQ_EXPR:
1676     case LTGT_EXPR:
1677     case ORDERED_EXPR:
1678     case UNORDERED_EXPR:
1679     case LT_EXPR:
1680     case LE_EXPR:
1681     case GT_EXPR:
1682     case GE_EXPR:
1683       return 10;
1684
1685     case LSHIFT_EXPR:
1686     case RSHIFT_EXPR:
1687     case LROTATE_EXPR:
1688     case RROTATE_EXPR:
1689       return 11;
1690
1691     case PLUS_EXPR:
1692     case MINUS_EXPR:
1693       return 12;
1694
1695     case MULT_EXPR:
1696     case TRUNC_DIV_EXPR:
1697     case CEIL_DIV_EXPR:
1698     case FLOOR_DIV_EXPR:
1699     case ROUND_DIV_EXPR:
1700     case RDIV_EXPR:
1701     case EXACT_DIV_EXPR:
1702     case TRUNC_MOD_EXPR:
1703     case CEIL_MOD_EXPR:
1704     case FLOOR_MOD_EXPR:
1705     case ROUND_MOD_EXPR:
1706       return 13;
1707
1708     case TRUTH_NOT_EXPR:
1709     case BIT_NOT_EXPR:
1710     case POSTINCREMENT_EXPR:
1711     case POSTDECREMENT_EXPR:
1712     case PREINCREMENT_EXPR:
1713     case PREDECREMENT_EXPR:
1714     case NEGATE_EXPR:
1715     case INDIRECT_REF:
1716     case ADDR_EXPR:
1717     case FLOAT_EXPR:
1718     case NOP_EXPR:
1719     case CONVERT_EXPR:
1720     case FIX_TRUNC_EXPR:
1721     case FIX_CEIL_EXPR:
1722     case FIX_FLOOR_EXPR:
1723     case FIX_ROUND_EXPR:
1724     case TARGET_EXPR:
1725       return 14;
1726
1727     case CALL_EXPR:
1728     case ARRAY_REF:
1729     case ARRAY_RANGE_REF:
1730     case COMPONENT_REF:
1731       return 15;
1732
1733       /* Special expressions.  */
1734     case MIN_EXPR:
1735     case MAX_EXPR:
1736     case ABS_EXPR:
1737     case REALPART_EXPR:
1738     case IMAGPART_EXPR:
1739       return 16;
1740
1741     case SAVE_EXPR:
1742     case NON_LVALUE_EXPR:
1743       return op_prio (TREE_OPERAND (op, 0));
1744
1745     default:
1746       /* Return an arbitrarily high precedence to avoid surrounding single
1747          VAR_DECLs in ()s.  */
1748       return 9999;
1749     }
1750 }
1751
1752
1753 /* Return the symbol associated with operator OP.  */
1754
1755 static const char *
1756 op_symbol (tree op)
1757 {
1758   gcc_assert (op);
1759
1760   switch (TREE_CODE (op))
1761     {
1762     case MODIFY_EXPR:
1763       return "=";
1764
1765     case TRUTH_OR_EXPR:
1766     case TRUTH_ORIF_EXPR:
1767       return "||";
1768
1769     case TRUTH_AND_EXPR:
1770     case TRUTH_ANDIF_EXPR:
1771       return "&&";
1772
1773     case BIT_IOR_EXPR:
1774       return "|";
1775
1776     case TRUTH_XOR_EXPR:
1777     case BIT_XOR_EXPR:
1778       return "^";
1779
1780     case ADDR_EXPR:
1781     case BIT_AND_EXPR:
1782       return "&";
1783
1784     case ORDERED_EXPR:
1785       return "ord";
1786     case UNORDERED_EXPR:
1787       return "unord";
1788
1789     case EQ_EXPR:
1790       return "==";
1791     case UNEQ_EXPR:
1792       return "u==";
1793
1794     case NE_EXPR:
1795       return "!=";
1796
1797     case LT_EXPR:
1798       return "<";
1799     case UNLT_EXPR:
1800       return "u<";
1801
1802     case LE_EXPR:
1803       return "<=";
1804     case UNLE_EXPR:
1805       return "u<=";
1806
1807     case GT_EXPR:
1808       return ">";
1809     case UNGT_EXPR:
1810       return "u>";
1811
1812     case GE_EXPR:
1813       return ">=";
1814     case UNGE_EXPR:
1815       return "u>=";
1816
1817     case LTGT_EXPR:
1818       return "<>";
1819
1820     case LSHIFT_EXPR:
1821       return "<<";
1822
1823     case RSHIFT_EXPR:
1824       return ">>";
1825
1826     case PLUS_EXPR:
1827       return "+";
1828
1829     case NEGATE_EXPR:
1830     case MINUS_EXPR:
1831       return "-";
1832
1833     case BIT_NOT_EXPR:
1834       return "~";
1835
1836     case TRUTH_NOT_EXPR:
1837       return "!";
1838
1839     case MULT_EXPR:
1840     case INDIRECT_REF:
1841       return "*";
1842
1843     case TRUNC_DIV_EXPR:
1844     case RDIV_EXPR:
1845       return "/";
1846
1847     case CEIL_DIV_EXPR:
1848       return "/[cl]";
1849
1850     case FLOOR_DIV_EXPR:
1851       return "/[fl]";
1852
1853     case ROUND_DIV_EXPR:
1854       return "/[rd]";
1855
1856     case EXACT_DIV_EXPR:
1857       return "/[ex]";
1858
1859     case TRUNC_MOD_EXPR:
1860       return "%";
1861
1862     case CEIL_MOD_EXPR:
1863       return "%[cl]";
1864
1865     case FLOOR_MOD_EXPR:
1866       return "%[fl]";
1867
1868     case ROUND_MOD_EXPR:
1869       return "%[rd]";
1870
1871     case PREDECREMENT_EXPR:
1872       return " --";
1873
1874     case PREINCREMENT_EXPR:
1875       return " ++";
1876
1877     case POSTDECREMENT_EXPR:
1878       return "-- ";
1879
1880     case POSTINCREMENT_EXPR:
1881       return "++ ";
1882
1883     default:
1884       return "<<< ??? >>>";
1885     }
1886 }
1887
1888 /* Prints the name of a CALL_EXPR.  */
1889
1890 static void
1891 print_call_name (pretty_printer *buffer, tree node)
1892 {
1893   tree op0;
1894
1895   gcc_assert (TREE_CODE (node) == CALL_EXPR);
1896
1897   op0 = TREE_OPERAND (node, 0);
1898
1899   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
1900     op0 = TREE_OPERAND (op0, 0);
1901
1902   switch (TREE_CODE (op0))
1903     {
1904     case VAR_DECL:
1905     case PARM_DECL:
1906       dump_function_name (buffer, op0);
1907       break;
1908
1909     case ADDR_EXPR:
1910     case INDIRECT_REF:
1911     case NOP_EXPR:
1912       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1913       break;
1914
1915     case COND_EXPR:
1916       pp_string (buffer, "(");
1917       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1918       pp_string (buffer, ") ? ");
1919       dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
1920       pp_string (buffer, " : ");
1921       dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
1922       break;
1923
1924     case COMPONENT_REF:
1925       /* The function is a pointer contained in a structure.  */
1926       if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
1927           TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
1928         dump_function_name (buffer, TREE_OPERAND (op0, 1));
1929       else
1930         dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
1931       /* else
1932          We can have several levels of structures and a function
1933          pointer inside.  This is not implemented yet...  */
1934       /*                  NIY;*/
1935       break;
1936
1937     case ARRAY_REF:
1938       if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
1939         dump_function_name (buffer, TREE_OPERAND (op0, 0));
1940       else
1941         dump_generic_node (buffer, op0, 0, 0, false);
1942       break;
1943
1944     case SSA_NAME:
1945     case OBJ_TYPE_REF:
1946       dump_generic_node (buffer, op0, 0, 0, false);
1947       break;
1948
1949     default:
1950       NIY;
1951     }
1952 }
1953
1954 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ...  */
1955
1956 static void
1957 pretty_print_string (pretty_printer *buffer, const char *str)
1958 {
1959   if (str == NULL)
1960     return;
1961
1962   while (*str)
1963     {
1964       switch (str[0])
1965         {
1966         case '\b':
1967           pp_string (buffer, "\\b");
1968           break;
1969
1970         case '\f':
1971           pp_string (buffer, "\\f");
1972           break;
1973
1974         case '\n':
1975           pp_string (buffer, "\\n");
1976           break;
1977
1978         case '\r':
1979           pp_string (buffer, "\\r");
1980           break;
1981
1982         case '\t':
1983           pp_string (buffer, "\\t");
1984           break;
1985
1986         case '\v':
1987           pp_string (buffer, "\\v");
1988           break;
1989
1990         case '\\':
1991           pp_string (buffer, "\\\\");
1992           break;
1993
1994         case '\"':
1995           pp_string (buffer, "\\\"");
1996           break;
1997
1998         case '\'':
1999           pp_string (buffer, "\\'");
2000           break;
2001
2002         case '\0':
2003           pp_string (buffer, "\\0");
2004           break;
2005
2006         case '\1':
2007           pp_string (buffer, "\\1");
2008           break;
2009
2010         case '\2':
2011           pp_string (buffer, "\\2");
2012           break;
2013
2014         case '\3':
2015           pp_string (buffer, "\\3");
2016           break;
2017
2018         case '\4':
2019           pp_string (buffer, "\\4");
2020           break;
2021
2022         case '\5':
2023           pp_string (buffer, "\\5");
2024           break;
2025
2026         case '\6':
2027           pp_string (buffer, "\\6");
2028           break;
2029
2030         case '\7':
2031           pp_string (buffer, "\\7");
2032           break;
2033
2034         default:
2035           pp_character (buffer, str[0]);
2036           break;
2037         }
2038       str++;
2039     }
2040 }
2041
2042 static void
2043 maybe_init_pretty_print (FILE *file)
2044 {
2045   if (!initialized)
2046     {
2047       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2048       pp_needs_newline (&buffer) = true;
2049       initialized = 1;
2050     }
2051
2052   buffer.buffer->stream = file;
2053 }
2054
2055 static void
2056 newline_and_indent (pretty_printer *buffer, int spc)
2057 {
2058   pp_newline (buffer);
2059   INDENT (spc);
2060 }
2061
2062 static void
2063 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2064 {
2065   tree use, def;
2066   use_operand_p use_p;
2067   def_operand_p def_p;
2068   ssa_op_iter iter;
2069
2070   FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
2071     {
2072       pp_string (buffer, "#   ");
2073       dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2074                          spc + 2, flags, false);
2075       pp_string (buffer, " = V_MAY_DEF <");
2076       dump_generic_node (buffer, USE_FROM_PTR (use_p),
2077                          spc + 2, flags, false);
2078       pp_string (buffer, ">;");
2079       newline_and_indent (buffer, spc);
2080     }
2081
2082   FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMUSTDEF)
2083     {
2084       pp_string (buffer, "#   V_MUST_DEF <");
2085       dump_generic_node (buffer, def, spc + 2, flags, false);
2086       pp_string (buffer, ">;");
2087       newline_and_indent (buffer, spc);
2088     }
2089
2090   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
2091     {
2092       pp_string (buffer, "#   VUSE <");
2093       dump_generic_node (buffer, use, spc + 2, flags, false);
2094       pp_string (buffer, ">;");
2095       newline_and_indent (buffer, spc);
2096     }
2097 }
2098
2099 /* Dumps basic block BB to FILE with details described by FLAGS and
2100    indented by INDENT spaces.  */
2101
2102 void
2103 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2104 {
2105   maybe_init_pretty_print (file);
2106   dumping_stmts = true;
2107   dump_generic_bb_buff (&buffer, bb, indent, flags);
2108   pp_flush (&buffer);
2109 }
2110
2111 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2112    spaces and details described by flags.  */
2113
2114 static void
2115 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2116 {
2117   edge e;
2118   tree stmt;
2119
2120   if (flags & TDF_BLOCKS)
2121     {
2122       INDENT (indent);
2123       pp_string (buffer, "# BLOCK ");
2124       pp_decimal_int (buffer, bb->index);
2125
2126       if (flags & TDF_LINENO)
2127         {
2128           block_stmt_iterator bsi;
2129
2130           for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2131             if (get_lineno (bsi_stmt (bsi)) != -1)
2132               {
2133                 pp_string (buffer, ", starting at line ");
2134                 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2135                 break;
2136               }
2137         }
2138       newline_and_indent (buffer, indent);
2139
2140       pp_string (buffer, "# PRED:");
2141       pp_write_text_to_stream (buffer);
2142       for (e = bb->pred; e; e = e->pred_next)
2143         if (flags & TDF_SLIM)
2144           {
2145             pp_string (buffer, " ");
2146             if (e->src == ENTRY_BLOCK_PTR)
2147               pp_string (buffer, "ENTRY");
2148             else
2149               pp_decimal_int (buffer, e->src->index);
2150           }
2151         else
2152           dump_edge_info (buffer->buffer->stream, e, 0);
2153       pp_newline (buffer);
2154     }
2155   else
2156     {
2157       stmt = first_stmt (bb);
2158       if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2159         {
2160           INDENT (indent - 2);
2161           pp_string (buffer, "<bb ");
2162           pp_decimal_int (buffer, bb->index);
2163           pp_string (buffer, ">:");
2164           pp_newline (buffer);
2165         }
2166     }
2167   pp_write_text_to_stream (buffer);
2168   check_bb_profile (bb, buffer->buffer->stream);
2169 }
2170
2171 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2172    spaces.  */
2173
2174 static void
2175 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2176 {
2177   edge e;
2178
2179   INDENT (indent);
2180   pp_string (buffer, "# SUCC:");
2181   pp_write_text_to_stream (buffer);
2182   for (e = bb->succ; e; e = e->succ_next)
2183     if (flags & TDF_SLIM)
2184       {
2185         pp_string (buffer, " ");
2186         if (e->dest == EXIT_BLOCK_PTR)
2187           pp_string (buffer, "EXIT");
2188         else
2189           pp_decimal_int (buffer, e->dest->index);
2190       }
2191     else
2192       dump_edge_info (buffer->buffer->stream, e, 1);
2193   pp_newline (buffer);
2194 }
2195
2196 /* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2197    FLAGS indented by INDENT spaces.  */
2198
2199 static void
2200 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2201 {
2202   tree phi = phi_nodes (bb);
2203   if (!phi)
2204     return;
2205
2206   for (; phi; phi = PHI_CHAIN (phi))
2207     {
2208       if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2209         {
2210           INDENT (indent);
2211           pp_string (buffer, "# ");
2212           dump_generic_node (buffer, phi, indent, flags, false);
2213           pp_newline (buffer);
2214         }
2215     }
2216 }
2217
2218 /* Dump jump to basic block BB that is represented implicitly in the cfg
2219    to BUFFER.  */
2220
2221 static void
2222 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2223 {
2224   tree stmt;
2225
2226   stmt = first_stmt (bb);
2227
2228   pp_string (buffer, "goto <bb ");
2229   pp_decimal_int (buffer, bb->index);
2230   pp_string (buffer, ">");
2231   if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2232     {
2233       pp_string (buffer, " (");
2234       dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2235       pp_string (buffer, ")");
2236     }
2237   pp_semicolon (buffer);
2238 }
2239
2240 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2241    by INDENT spaces, with details given by FLAGS.  */
2242
2243 static void
2244 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2245                      int flags)
2246 {
2247   edge e;
2248
2249   /* If there is a fallthru edge, we may need to add an artificial goto to the
2250      dump.  */
2251   for (e = bb->succ; e; e = e->succ_next)
2252     if (e->flags & EDGE_FALLTHRU)
2253       break;
2254   if (e && e->dest != bb->next_bb)
2255     {
2256       INDENT (indent);
2257
2258       if ((flags & TDF_LINENO)
2259 #ifdef USE_MAPPED_LOCATION
2260           && e->goto_locus != UNKNOWN_LOCATION
2261 #else
2262           && e->goto_locus
2263 #endif
2264           )
2265         {
2266           expanded_location goto_xloc;
2267 #ifdef USE_MAPPED_LOCATION
2268           goto_xloc = expand_location (e->goto_locus);
2269 #else
2270           goto_xloc = *e->goto_locus;
2271 #endif
2272           pp_character (buffer, '[');
2273           if (goto_xloc.file)
2274             {
2275               pp_string (buffer, goto_xloc.file);
2276               pp_string (buffer, " : ");
2277             }
2278           pp_decimal_int (buffer, goto_xloc.line);
2279           pp_string (buffer, "] ");
2280         }
2281
2282       pp_cfg_jump (buffer, e->dest);
2283       pp_newline (buffer);
2284     }
2285 }
2286
2287 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2288    indented by INDENT spaces.  */
2289
2290 static void
2291 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2292                       int indent, int flags)
2293 {
2294   block_stmt_iterator bsi;
2295   tree stmt;
2296   int label_indent = indent - 2;
2297
2298   if (label_indent < 0)
2299     label_indent = 0;
2300
2301   dump_bb_header (buffer, bb, indent, flags);
2302
2303   if (bb_ann (bb))
2304     dump_phi_nodes (buffer, bb, indent, flags);
2305
2306   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2307     {
2308       int curr_indent;
2309
2310       stmt = bsi_stmt (bsi);
2311
2312       curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
2313
2314       INDENT (curr_indent);
2315       dump_generic_node (buffer, stmt, curr_indent, flags, true);
2316       pp_newline (buffer);
2317     }
2318
2319   dump_implicit_edges (buffer, bb, indent, flags);
2320
2321   if (flags & TDF_BLOCKS)
2322     dump_bb_end (buffer, bb, indent, flags);
2323 }