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