gcc/tree-pretty-print.c

   1 /* Pretty formatting of GENERIC trees in C syntax.
   2    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
   3    Free Software Foundation, Inc.
   4    Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.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 #include "tree-pass.h"
  36
  37 /* Local functions, macros and variables.  */
  38 static int op_prio (tree);
  39 static const char *op_symbol_1 (enum tree_code);
  40 static const char *op_symbol (tree);
  41 static void pretty_print_string (pretty_printer *, const char*);
  42 static void print_call_name (pretty_printer *, tree);
  43 static void newline_and_indent (pretty_printer *, int);
  44 static void maybe_init_pretty_print (FILE *);
  45 static void print_declaration (pretty_printer *, tree, int, int);
  46 static void print_struct_decl (pretty_printer *, tree, int, int);
  47 static void do_niy (pretty_printer *, tree);
  48 static void dump_vops (pretty_printer *, tree, int, int);
  49 static void dump_generic_bb_buff (pretty_printer *, basic_block, int, int);
  50
  51 #define INDENT(SPACE) do { \
  52   int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
  53
  54 #define NIY do_niy(buffer,node)
  55
  56 #define PRINT_FUNCTION_NAME(NODE)  pp_printf             \
  57   (buffer, "%s", TREE_CODE (NODE) == NOP_EXPR ?              \
  58    lang_hooks.decl_printable_name (TREE_OPERAND (NODE, 0), 1) : \
  59    lang_hooks.decl_printable_name (NODE, 1))
  60
  61 static pretty_printer buffer;
  62 static int initialized = 0;
  63
  64 /* Try to print something for an unknown tree code.  */
  65
  66 static void
  67 do_niy (pretty_printer *buffer, tree node)
  68 {
  69   int i, len;
  70
  71   pp_string (buffer, "<<< Unknown tree: ");
  72   pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
  73
  74   if (EXPR_P (node))
  75     {
  76       len = TREE_CODE_LENGTH (TREE_CODE (node));
  77       for (i = 0; i < len; ++i)
  78         {
  79           newline_and_indent (buffer, 2);
  80           dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);
  81         }
  82     }
  83
  84   pp_string (buffer, " >>>\n");
  85 }
  86
  87 void
  88 debug_generic_expr (tree t)
  89 {
  90   print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
  91   fprintf (stderr, "\n");
  92 }
  93
  94 void
  95 debug_generic_stmt (tree t)
  96 {
  97   print_generic_stmt (stderr, t, TDF_VOPS|TDF_UID);
  98   fprintf (stderr, "\n");
  99 }
 100
 101 void
 102 debug_tree_chain (tree t)
 103 {
 104   while (t)
 105   {
 106     print_generic_expr (stderr, t, TDF_VOPS|TDF_UID);
 107     fprintf(stderr, " ");
 108     t = TREE_CHAIN (t);
 109   }
 110   fprintf (stderr, "\n");
 111 }
 112
 113 /* Prints declaration DECL to the FILE with details specified by FLAGS.  */
 114 void
 115 print_generic_decl (FILE *file, tree decl, int flags)
 116 {
 117   maybe_init_pretty_print (file);
 118   print_declaration (&buffer, decl, 2, flags);
 119   pp_write_text_to_stream (&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.  */
 124
 125 void
 126 print_generic_stmt (FILE *file, tree t, int flags)
 127 {
 128   maybe_init_pretty_print (file);
 129   dump_generic_node (&buffer, t, 0, flags, true);
 130   pp_flush (&buffer);
 131 }
 132
 133 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 134    to show in the dump.  See TDF_* in tree.h.  The output is indented by
 135    INDENT spaces.  */
 136
 137 void
 138 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
 139 {
 140   int i;
 141
 142   maybe_init_pretty_print (file);
 143
 144   for (i = 0; i < indent; i++)
 145     pp_space (&buffer);
 146   dump_generic_node (&buffer, t, indent, flags, true);
 147   pp_flush (&buffer);
 148 }
 149
 150 /* Print a single expression T on file FILE.  FLAGS specifies details to show
 151    in the dump.  See TDF_* in tree.h.  */
 152
 153 void
 154 print_generic_expr (FILE *file, tree t, int flags)
 155 {
 156   maybe_init_pretty_print (file);
 157   dump_generic_node (&buffer, t, 0, flags, false);
 158 }
 159
 160 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
 161    in FLAGS.  */
 162
 163 static void
 164 dump_decl_name (pretty_printer *buffer, tree node, int flags)
 165 {
 166   tree t = node;
 167
 168   if (DECL_NAME (t))
 169     pp_tree_identifier (buffer, DECL_NAME (t));
 170   if ((flags & TDF_UID)
 171       || DECL_NAME (t) == NULL_TREE)
 172     {
 173       if (TREE_CODE (t) == LABEL_DECL
 174           && LABEL_DECL_UID (t) != -1)
 175         pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
 176                    LABEL_DECL_UID (t));
 177       else
 178         {
 179           char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
 180           pp_printf (buffer, "%c.%u", c, DECL_UID (t));
 181         }
 182     }
 183 }
 184
 185 /* Like the above, but used for pretty printing function calls.  */
 186
 187 static void
 188 dump_function_name (pretty_printer *buffer, tree node)
 189 {
 190   if (DECL_NAME (node))
 191     PRINT_FUNCTION_NAME (node);
 192   else
 193     dump_decl_name (buffer, node, 0);
 194 }
 195
 196 /* Dump a function declaration.  NODE is the FUNCTION_TYPE.  BUFFER, SPC and
 197    FLAGS are as in dump_generic_node.  */
 198
 199 static void
 200 dump_function_declaration (pretty_printer *buffer, tree node,
 201                            int spc, int flags)
 202 {
 203   bool wrote_arg = false;
 204   tree arg;
 205
 206   pp_space (buffer);
 207   pp_character (buffer, '(');
 208
 209   /* Print the argument types.  The last element in the list is a VOID_TYPE.
 210      The following avoids printing the last element.  */
 211   arg = TYPE_ARG_TYPES (node);
 212   while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
 213     {
 214       wrote_arg = true;
 215       dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
 216       arg = TREE_CHAIN (arg);
 217       if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
 218         {
 219           pp_character (buffer, ',');
 220           pp_space (buffer);
 221         }
 222     }
 223
 224   if (!wrote_arg)
 225     pp_string (buffer, "void");
 226
 227   pp_character (buffer, ')');
 228 }
 229
 230 /* Dump the domain associated with an array.  */
 231
 232 static void
 233 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
 234 {
 235   pp_character (buffer, '[');
 236   if (domain)
 237     {
 238       tree min = TYPE_MIN_VALUE (domain);
 239       tree max = TYPE_MAX_VALUE (domain);
 240
 241       if (min && max
 242           && integer_zerop (min)
 243           && host_integerp (max, 0))
 244         pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
 245       else
 246         {
 247           if (min)
 248             dump_generic_node (buffer, min, spc, flags, false);
 249           pp_character (buffer, ':');
 250           if (max)
 251             dump_generic_node (buffer, max, spc, flags, false);
 252         }
 253     }
 254   else
 255     pp_string (buffer, "<unknown>");
 256   pp_character (buffer, ']');
 257 }
 258
 259
 260 /* Dump OpenMP clause CLAUSE.  BUFFER, CLAUSE, SPC and FLAGS are as in
 261    dump_generic_node.  */
 262
 263 static void
 264 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
 265 {
 266   const char *name;
 267
 268   switch (OMP_CLAUSE_CODE (clause))
 269     {
 270     case OMP_CLAUSE_PRIVATE:
 271       name = "private";
 272       goto print_remap;
 273     case OMP_CLAUSE_SHARED:
 274       name = "shared";
 275       goto print_remap;
 276     case OMP_CLAUSE_FIRSTPRIVATE:
 277       name = "firstprivate";
 278       goto print_remap;
 279     case OMP_CLAUSE_LASTPRIVATE:
 280       name = "lastprivate";
 281       goto print_remap;
 282     case OMP_CLAUSE_COPYIN:
 283       name = "copyin";
 284       goto print_remap;
 285     case OMP_CLAUSE_COPYPRIVATE:
 286       name = "copyprivate";
 287       goto print_remap;
 288   print_remap:
 289       pp_string (buffer, name);
 290       pp_character (buffer, '(');
 291       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 292           spc, flags, false);
 293       pp_character (buffer, ')');
 294       break;
 295
 296     case OMP_CLAUSE_REDUCTION:
 297       pp_string (buffer, "reduction(");
 298       pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));
 299       pp_character (buffer, ':');
 300       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 301           spc, flags, false);
 302       pp_character (buffer, ')');
 303       break;
 304
 305     case OMP_CLAUSE_IF:
 306       pp_string (buffer, "if(");
 307       dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
 308           spc, flags, false);
 309       pp_character (buffer, ')');
 310       break;
 311
 312     case OMP_CLAUSE_NUM_THREADS:
 313       pp_string (buffer, "num_threads(");
 314       dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
 315           spc, flags, false);
 316       pp_character (buffer, ')');
 317       break;
 318
 319     case OMP_CLAUSE_NOWAIT:
 320       pp_string (buffer, "nowait");
 321       break;
 322     case OMP_CLAUSE_ORDERED:
 323       pp_string (buffer, "ordered");
 324       break;
 325
 326     case OMP_CLAUSE_DEFAULT:
 327       pp_string (buffer, "default(");
 328       switch (OMP_CLAUSE_DEFAULT_KIND (clause))
 329         {
 330       case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
 331         break;
 332       case OMP_CLAUSE_DEFAULT_SHARED:
 333         pp_string (buffer, "shared");
 334         break;
 335       case OMP_CLAUSE_DEFAULT_NONE:
 336         pp_string (buffer, "none");
 337         break;
 338       case OMP_CLAUSE_DEFAULT_PRIVATE:
 339         pp_string (buffer, "private");
 340         break;
 341       default:
 342         gcc_unreachable ();
 343         }
 344       pp_character (buffer, ')');
 345       break;
 346
 347     case OMP_CLAUSE_SCHEDULE:
 348       pp_string (buffer, "schedule(");
 349       switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
 350         {
 351       case OMP_CLAUSE_SCHEDULE_STATIC:
 352         pp_string (buffer, "static");
 353         break;
 354       case OMP_CLAUSE_SCHEDULE_DYNAMIC:
 355         pp_string (buffer, "dynamic");
 356         break;
 357       case OMP_CLAUSE_SCHEDULE_GUIDED:
 358         pp_string (buffer, "guided");
 359         break;
 360       case OMP_CLAUSE_SCHEDULE_RUNTIME:
 361         pp_string (buffer, "runtime");
 362         break;
 363       default:
 364         gcc_unreachable ();
 365         }
 366       if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
 367         {
 368           pp_character (buffer, ',');
 369           dump_generic_node (buffer,
 370               OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
 371               spc, flags, false);
 372         }
 373       pp_character (buffer, ')');
 374       break;
 375
 376     default:
 377       /* Should never happen.  */
 378       dump_generic_node (buffer, clause, spc, flags, false);
 379       break;
 380     }
 381 }
 382
 383
 384 /* Dump the list of OpenMP clauses.  BUFFER, SPC and FLAGS are as in
 385    dump_generic_node.  */
 386
 387 static void
 388 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
 389 {
 390   if (clause == NULL)
 391     return;
 392
 393   pp_space (buffer);
 394   while (1)
 395     {
 396       dump_omp_clause (buffer, clause, spc, flags);
 397       clause = OMP_CLAUSE_CHAIN (clause);
 398       if (clause == NULL)
 399         return;
 400       pp_space (buffer);
 401     }
 402 }
 403
 404
 405 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
 406    FLAGS specifies details to show in the dump (see TDF_* in tree.h).  If
 407    IS_STMT is true, the object printed is considered to be a statement
 408    and it is terminated by ';' if appropriate.  */
 409
 410 int
 411 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 412                    bool is_stmt)
 413 {
 414   tree type;
 415   tree op0, op1;
 416   const char *str;
 417   bool is_expr;
 418
 419   if (node == NULL_TREE)
 420     return spc;
 421
 422   is_expr = EXPR_P (node) || GIMPLE_STMT_P (node);
 423
 424   /* We use has_stmt_ann because CALL_EXPR can be both an expression
 425      and a statement, and we have no guarantee that it will have a
 426      stmt_ann when it is used as an RHS expression.  stmt_ann will assert
 427      if you call it on something with a non-stmt annotation attached.  */
 428   if (TREE_CODE (node) != ERROR_MARK
 429       && is_gimple_stmt (node)
 430       && (flags & TDF_VOPS)
 431       && has_stmt_ann (node)
 432       && TREE_CODE (node) != PHI_NODE)
 433     dump_vops (buffer, node, spc, flags);
 434
 435   if (is_stmt && (flags & TDF_STMTADDR))
 436     pp_printf (buffer, "<&%p> ", (void *)node);
 437
 438   if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
 439     {
 440       expanded_location xloc = expand_location (EXPR_LOCATION (node));
 441       pp_character (buffer, '[');
 442       if (xloc.file)
 443         {
 444           pp_string (buffer, xloc.file);
 445           pp_string (buffer, " : ");
 446         }
 447       pp_decimal_int (buffer, xloc.line);
 448       pp_string (buffer, "] ");
 449     }
 450
 451   switch (TREE_CODE (node))
 452     {
 453     case ERROR_MARK:
 454       pp_string (buffer, "<<< error >>>");
 455       break;
 456
 457     case IDENTIFIER_NODE:
 458       pp_tree_identifier (buffer, node);
 459       break;
 460
 461     case TREE_LIST:
 462       while (node && node != error_mark_node)
 463         {
 464           if (TREE_PURPOSE (node))
 465             {
 466               dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
 467               pp_space (buffer);
 468             }
 469           dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
 470           node = TREE_CHAIN (node);
 471           if (node && TREE_CODE (node) == TREE_LIST)
 472             {
 473               pp_character (buffer, ',');
 474               pp_space (buffer);
 475             }
 476         }
 477       break;
 478
 479     case TREE_BINFO:
 480       dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
 481
 482     case TREE_VEC:
 483       {
 484         size_t i;
 485         if (TREE_VEC_LENGTH (node) > 0)
 486           {
 487             size_t len = TREE_VEC_LENGTH (node);
 488             for (i = 0; i < len - 1; i++)
 489               {
 490                 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
 491                                    false);
 492                 pp_character (buffer, ',');
 493                 pp_space (buffer);
 494               }
 495             dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
 496                                flags, false);
 497           }
 498       }
 499       break;
 500
 501     case VOID_TYPE:
 502     case INTEGER_TYPE:
 503     case REAL_TYPE:
 504     case COMPLEX_TYPE:
 505     case VECTOR_TYPE:
 506     case ENUMERAL_TYPE:
 507     case BOOLEAN_TYPE:
 508       {
 509         unsigned int quals = TYPE_QUALS (node);
 510         enum tree_code_class class;
 511
 512         if (quals & TYPE_QUAL_CONST)
 513           pp_string (buffer, "const ");
 514         else if (quals & TYPE_QUAL_VOLATILE)
 515           pp_string (buffer, "volatile ");
 516         else if (quals & TYPE_QUAL_RESTRICT)
 517           pp_string (buffer, "restrict ");
 518
 519         class = TREE_CODE_CLASS (TREE_CODE (node));
 520
 521         if (class == tcc_declaration)
 522           {
 523             if (DECL_NAME (node))
 524               dump_decl_name (buffer, node, flags);
 525             else
 526               pp_string (buffer, "<unnamed type decl>");
 527           }
 528         else if (class == tcc_type)
 529           {
 530             if (TYPE_NAME (node))
 531               {
 532                 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
 533                   pp_tree_identifier (buffer, TYPE_NAME (node));
 534                 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
 535                          && DECL_NAME (TYPE_NAME (node)))
 536                   dump_decl_name (buffer, TYPE_NAME (node), flags);
 537                 else
 538                   pp_string (buffer, "<unnamed type>");
 539               }
 540             else if (TREE_CODE (node) == VECTOR_TYPE)
 541               {
 542                 pp_string (buffer, "vector ");
 543                 dump_generic_node (buffer, TREE_TYPE (node),
 544                                    spc, flags, false);
 545               }
 546             else
 547               pp_string (buffer, "<unnamed type>");
 548           }
 549         break;
 550       }
 551
 552     case POINTER_TYPE:
 553     case REFERENCE_TYPE:
 554       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
 555
 556       if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
 557         {
 558           tree fnode = TREE_TYPE (node);
 559
 560           dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
 561           pp_space (buffer);
 562           pp_character (buffer, '(');
 563           pp_string (buffer, str);
 564           if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
 565             dump_decl_name (buffer, TYPE_NAME (node), flags);
 566           else
 567             pp_printf (buffer, "<T%x>", TYPE_UID (node));
 568
 569           pp_character (buffer, ')');
 570           dump_function_declaration (buffer, fnode, spc, flags);
 571         }
 572       else
 573         {
 574           unsigned int quals = TYPE_QUALS (node);
 575
 576           dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 577           pp_space (buffer);
 578           pp_string (buffer, str);
 579
 580           if (quals & TYPE_QUAL_CONST)
 581             pp_string (buffer, " const");
 582           else if (quals & TYPE_QUAL_VOLATILE)
 583             pp_string (buffer,  "volatile");
 584           else if (quals & TYPE_QUAL_RESTRICT)
 585             pp_string (buffer, " restrict");
 586
 587           if (TYPE_REF_CAN_ALIAS_ALL (node))
 588             pp_string (buffer, " {ref-all}");
 589         }
 590       break;
 591
 592     case OFFSET_TYPE:
 593       NIY;
 594       break;
 595
 596     case METHOD_TYPE:
 597       dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
 598       pp_string (buffer, "::");
 599       break;
 600
 601     case TARGET_MEM_REF:
 602       {
 603         const char *sep = "";
 604         tree tmp;
 605
 606         pp_string (buffer, "MEM[");
 607
 608         tmp = TMR_SYMBOL (node);
 609         if (tmp)
 610           {
 611             pp_string (buffer, sep);
 612             sep = ", ";
 613             pp_string (buffer, "symbol: ");
 614             dump_generic_node (buffer, tmp, spc, flags, false);
 615           }
 616         tmp = TMR_BASE (node);
 617         if (tmp)
 618           {
 619             pp_string (buffer, sep);
 620             sep = ", ";
 621             pp_string (buffer, "base: ");
 622             dump_generic_node (buffer, tmp, spc, flags, false);
 623           }
 624         tmp = TMR_INDEX (node);
 625         if (tmp)
 626           {
 627             pp_string (buffer, sep);
 628             sep = ", ";
 629             pp_string (buffer, "index: ");
 630             dump_generic_node (buffer, tmp, spc, flags, false);
 631           }
 632         tmp = TMR_STEP (node);
 633         if (tmp)
 634           {
 635             pp_string (buffer, sep);
 636             sep = ", ";
 637             pp_string (buffer, "step: ");
 638             dump_generic_node (buffer, tmp, spc, flags, false);
 639           }
 640         tmp = TMR_OFFSET (node);
 641         if (tmp)
 642           {
 643             pp_string (buffer, sep);
 644             sep = ", ";
 645             pp_string (buffer, "offset: ");
 646             dump_generic_node (buffer, tmp, spc, flags, false);
 647           }
 648         pp_string (buffer, "]");
 649         if (flags & TDF_DETAILS)
 650           {
 651             pp_string (buffer, "{");
 652             dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
 653                                false);
 654             pp_string (buffer, "}");
 655           }
 656       }
 657       break;
 658
 659     case ARRAY_TYPE:
 660       {
 661         tree tmp;
 662
 663         /* Print the innermost component type.  */
 664         for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
 665              tmp = TREE_TYPE (tmp))
 666           ;
 667         dump_generic_node (buffer, tmp, spc, flags, false);
 668
 669         /* Print the dimensions.  */
 670         for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
 671           dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
 672         break;
 673       }
 674
 675     case RECORD_TYPE:
 676     case UNION_TYPE:
 677     case QUAL_UNION_TYPE:
 678       /* Print the name of the structure.  */
 679       if (TREE_CODE (node) == RECORD_TYPE)
 680         pp_string (buffer, "struct ");
 681       else if (TREE_CODE (node) == UNION_TYPE)
 682         pp_string (buffer, "union ");
 683
 684       if (TYPE_NAME (node))
 685         dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
 686       else
 687         print_struct_decl (buffer, node, spc, flags);
 688       break;
 689
 690     case LANG_TYPE:
 691       NIY;
 692       break;
 693
 694     case INTEGER_CST:
 695       if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
 696         {
 697           /* In the case of a pointer, one may want to divide by the
 698              size of the pointed-to type.  Unfortunately, this not
 699              straightforward.  The C front-end maps expressions
 700
 701              (int *) 5
 702              int *p; (p + 5)
 703
 704              in such a way that the two INTEGER_CST nodes for "5" have
 705              different values but identical types.  In the latter
 706              case, the 5 is multiplied by sizeof (int) in c-common.c
 707              (pointer_int_sum) to convert it to a byte address, and
 708              yet the type of the node is left unchanged.  Argh.  What
 709              is consistent though is that the number value corresponds
 710              to bytes (UNITS) offset.
 711
 712              NB: Neither of the following divisors can be trivially
 713              used to recover the original literal:
 714
 715              TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
 716              TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))  */
 717           pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
 718           pp_string (buffer, "B"); /* pseudo-unit */
 719         }
 720       else if (! host_integerp (node, 0))
 721         {
 722           tree val = node;
 723
 724           if (tree_int_cst_sgn (val) < 0)
 725             {
 726               pp_character (buffer, '-');
 727               val = build_int_cst_wide (NULL_TREE,
 728                                         -TREE_INT_CST_LOW (val),
 729                                         ~TREE_INT_CST_HIGH (val)
 730                                         + !TREE_INT_CST_LOW (val));
 731             }
 732           /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
 733              systems?  */
 734           {
 735             sprintf (pp_buffer (buffer)->digit_buffer, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
 736                      TREE_INT_CST_HIGH (val),
 737                      TREE_INT_CST_LOW (val));
 738             pp_string (buffer, pp_buffer (buffer)->digit_buffer);
 739           }
 740         }
 741       else
 742         pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
 743       break;
 744
 745     case REAL_CST:
 746       /* Code copied from print_node.  */
 747       {
 748         REAL_VALUE_TYPE d;
 749         if (TREE_OVERFLOW (node))
 750           pp_string (buffer, " overflow");
 751
 752 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
 753         d = TREE_REAL_CST (node);
 754         if (REAL_VALUE_ISINF (d))
 755           pp_string (buffer, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
 756         else if (REAL_VALUE_ISNAN (d))
 757           pp_string (buffer, " Nan");
 758         else
 759           {
 760             char string[100];
 761             real_to_decimal (string, &d, sizeof (string), 0, 1);
 762             pp_string (buffer, string);
 763           }
 764 #else
 765         {
 766           HOST_WIDE_INT i;
 767           unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
 768           pp_string (buffer, "0x");
 769           for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
 770             output_formatted_integer (buffer, "%02x", *p++);
 771         }
 772 #endif
 773         break;
 774       }
 775
 776     case COMPLEX_CST:
 777       pp_string (buffer, "__complex__ (");
 778       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
 779       pp_string (buffer, ", ");
 780       dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
 781       pp_string (buffer, ")");
 782       break;
 783
 784     case STRING_CST:
 785       pp_string (buffer, "\"");
 786       pretty_print_string (buffer, TREE_STRING_POINTER (node));
 787       pp_string (buffer, "\"");
 788       break;
 789
 790     case VECTOR_CST:
 791       {
 792         tree elt;
 793         pp_string (buffer, "{ ");
 794         for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
 795           {
 796             dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
 797             if (TREE_CHAIN (elt))
 798               pp_string (buffer, ", ");
 799           }
 800         pp_string (buffer, " }");
 801       }
 802       break;
 803
 804     case FUNCTION_TYPE:
 805       break;
 806
 807     case FUNCTION_DECL:
 808     case CONST_DECL:
 809       dump_decl_name (buffer, node, flags);
 810       break;
 811
 812     case LABEL_DECL:
 813       if (DECL_NAME (node))
 814         dump_decl_name (buffer, node, flags);
 815       else if (LABEL_DECL_UID (node) != -1)
 816         pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
 817                    LABEL_DECL_UID (node));
 818       else
 819         pp_printf (buffer, "<D%u>", DECL_UID (node));
 820       break;
 821
 822     case TYPE_DECL:
 823       if (DECL_IS_BUILTIN (node))
 824         {
 825           /* Don't print the declaration of built-in types.  */
 826           break;
 827         }
 828       if (DECL_NAME (node))
 829         dump_decl_name (buffer, node, flags);
 830       else
 831         {
 832           if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
 833                || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
 834               && TYPE_METHODS (TREE_TYPE (node)))
 835             {
 836               /* The type is a c++ class: all structures have at least
 837                  4 methods.  */
 838               pp_string (buffer, "class ");
 839               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 840             }
 841           else
 842             {
 843               pp_string (buffer,
 844                          (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
 845                           ? "union" : "struct "));
 846               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 847             }
 848         }
 849       break;
 850
 851     case SYMBOL_MEMORY_TAG:
 852     case NAME_MEMORY_TAG:
 853     case STRUCT_FIELD_TAG:
 854     case VAR_DECL:
 855     case PARM_DECL:
 856     case FIELD_DECL:
 857     case NAMESPACE_DECL:
 858       dump_decl_name (buffer, node, flags);
 859       break;
 860
 861     case RESULT_DECL:
 862       pp_string (buffer, "<retval>");
 863       break;
 864
 865     case COMPONENT_REF:
 866       op0 = TREE_OPERAND (node, 0);
 867       str = ".";
 868       if (TREE_CODE (op0) == INDIRECT_REF)
 869         {
 870           op0 = TREE_OPERAND (op0, 0);
 871           str = "->";
 872         }
 873       if (op_prio (op0) < op_prio (node))
 874         pp_character (buffer, '(');
 875       dump_generic_node (buffer, op0, spc, flags, false);
 876       if (op_prio (op0) < op_prio (node))
 877         pp_character (buffer, ')');
 878       pp_string (buffer, str);
 879       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 880
 881       if (TREE_CODE (op0) != VALUE_HANDLE)
 882         {
 883           op0 = component_ref_field_offset (node);
 884           if (op0 && TREE_CODE (op0) != INTEGER_CST)
 885             {
 886               pp_string (buffer, "{off: ");
 887               dump_generic_node (buffer, op0, spc, flags, false);
 888               pp_character (buffer, '}');
 889             }
 890         }
 891       break;
 892
 893     case BIT_FIELD_REF:
 894       pp_string (buffer, "BIT_FIELD_REF <");
 895       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
 896       pp_string (buffer, ", ");
 897       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 898       pp_string (buffer, ", ");
 899       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
 900       pp_string (buffer, ">");
 901       break;
 902
 903     case ARRAY_REF:
 904     case ARRAY_RANGE_REF:
 905       op0 = TREE_OPERAND (node, 0);
 906       if (op_prio (op0) < op_prio (node))
 907         pp_character (buffer, '(');
 908       dump_generic_node (buffer, op0, spc, flags, false);
 909       if (op_prio (op0) < op_prio (node))
 910         pp_character (buffer, ')');
 911       pp_character (buffer, '[');
 912       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 913       if (TREE_CODE (node) == ARRAY_RANGE_REF)
 914         pp_string (buffer, " ...");
 915       pp_character (buffer, ']');
 916
 917       op0 = array_ref_low_bound (node);
 918       op1 = array_ref_element_size (node);
 919
 920       if (!integer_zerop (op0)
 921           || (TYPE_SIZE_UNIT (TREE_TYPE (node))
 922               && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
 923         {
 924           pp_string (buffer, "{lb: ");
 925           dump_generic_node (buffer, op0, spc, flags, false);
 926           pp_string (buffer, " sz: ");
 927           dump_generic_node (buffer, op1, spc, flags, false);
 928           pp_character (buffer, '}');
 929         }
 930       break;
 931
 932     case CONSTRUCTOR:
 933       {
 934         unsigned HOST_WIDE_INT ix;
 935         tree field, val;
 936         bool is_struct_init = FALSE;
 937         pp_character (buffer, '{');
 938         if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
 939             || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
 940           is_struct_init = TRUE;
 941         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
 942           {
 943             if (field && is_struct_init)
 944               {
 945                 pp_character (buffer, '.');
 946                 dump_generic_node (buffer, field, spc, flags, false);
 947                 pp_string (buffer, "=");
 948               }
 949             if (val && TREE_CODE (val) == ADDR_EXPR)
 950               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
 951                 val = TREE_OPERAND (val, 0);
 952             if (val && TREE_CODE (val) == FUNCTION_DECL)
 953                 dump_decl_name (buffer, val, flags);
 954             else
 955                 dump_generic_node (buffer, val, spc, flags, false);
 956             if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
 957               {
 958                 pp_character (buffer, ',');
 959                 pp_space (buffer);
 960               }
 961           }
 962         pp_character (buffer, '}');
 963       }
 964       break;
 965
 966     case COMPOUND_EXPR:
 967       {
 968         tree *tp;
 969         if (flags & TDF_SLIM)
 970           {
 971             pp_string (buffer, "<COMPOUND_EXPR>");
 972             break;
 973           }
 974
 975         dump_generic_node (buffer, TREE_OPERAND (node, 0),
 976                            spc, flags, !(flags & TDF_SLIM));
 977         if (flags & TDF_SLIM)
 978           newline_and_indent (buffer, spc);
 979         else
 980           {
 981             pp_character (buffer, ',');
 982             pp_space (buffer);
 983           }
 984
 985         for (tp = &TREE_OPERAND (node, 1);
 986              TREE_CODE (*tp) == COMPOUND_EXPR;
 987              tp = &TREE_OPERAND (*tp, 1))
 988           {
 989             dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
 990                                spc, flags, !(flags & TDF_SLIM));
 991             if (flags & TDF_SLIM)
 992               newline_and_indent (buffer, spc);
 993             else
 994               {
 995                 pp_character (buffer, ',');
 996                 pp_space (buffer);
 997               }
 998           }
 999
1000         dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1001       }
1002       break;
1003
1004     case STATEMENT_LIST:
1005       {
1006         tree_stmt_iterator si;
1007         bool first = true;
1008
1009         if (flags & TDF_SLIM)
1010           {
1011             pp_string (buffer, "<STATEMENT_LIST>");
1012             break;
1013           }
1014
1015         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1016           {
1017             if (!first)
1018               newline_and_indent (buffer, spc);
1019             else
1020               first = false;
1021             dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1022           }
1023       }
1024       break;
1025
1026     case MODIFY_EXPR:
1027     case GIMPLE_MODIFY_STMT:
1028     case INIT_EXPR:
1029       dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 0), spc, flags,
1030                          false);
1031       pp_space (buffer);
1032       pp_character (buffer, '=');
1033       pp_space (buffer);
1034       dump_generic_node (buffer, GENERIC_TREE_OPERAND (node, 1), spc, flags,
1035                          false);
1036       break;
1037
1038     case TARGET_EXPR:
1039       pp_string (buffer, "TARGET_EXPR <");
1040       dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1041       pp_character (buffer, ',');
1042       pp_space (buffer);
1043       dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1044       pp_character (buffer, '>');
1045       break;
1046
1047     case DECL_EXPR:
1048       print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1049       is_stmt = false;
1050       break;
1051
1052     case COND_EXPR:
1053       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1054         {
1055           pp_string (buffer, "if (");
1056           dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1057           pp_character (buffer, ')');
1058           /* The lowered cond_exprs should always be printed in full.  */
1059           if (COND_EXPR_THEN (node)
1060               && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1061                   || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1062               && COND_EXPR_ELSE (node)
1063               && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1064                   || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1065             {
1066               pp_space (buffer);
1067               dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
1068               pp_string (buffer, " else ");
1069               dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
1070             }
1071           else if (!(flags & TDF_SLIM))
1072             {
1073               /* Output COND_EXPR_THEN.  */
1074               if (COND_EXPR_THEN (node))
1075                 {
1076                   newline_and_indent (buffer, spc+2);
1077                   pp_character (buffer, '{');
1078                   newline_and_indent (buffer, spc+4);
1079                   dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1080                                      flags, true);
1081                   newline_and_indent (buffer, spc+2);
1082                   pp_character (buffer, '}');
1083                 }
1084
1085               /* Output COND_EXPR_ELSE.  */
1086               if (COND_EXPR_ELSE (node))
1087                 {
1088                   newline_and_indent (buffer, spc);
1089                   pp_string (buffer, "else");
1090                   newline_and_indent (buffer, spc+2);
1091                   pp_character (buffer, '{');
1092                   newline_and_indent (buffer, spc+4);
1093                   dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1094                                      flags, true);
1095                   newline_and_indent (buffer, spc+2);
1096                   pp_character (buffer, '}');
1097                 }
1098             }
1099           is_expr = false;
1100         }
1101       else
1102         {
1103           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1104           pp_space (buffer);
1105           pp_character (buffer, '?');
1106           pp_space (buffer);
1107           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1108           pp_space (buffer);
1109           pp_character (buffer, ':');
1110           pp_space (buffer);
1111           dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1112         }
1113       break;
1114
1115     case BIND_EXPR:
1116       pp_character (buffer, '{');
1117       if (!(flags & TDF_SLIM))
1118         {
1119           if (BIND_EXPR_VARS (node))
1120             {
1121               pp_newline (buffer);
1122
1123               for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1124                 {
1125                   print_declaration (buffer, op0, spc+2, flags);
1126                   pp_newline (buffer);
1127                 }
1128             }
1129
1130           newline_and_indent (buffer, spc+2);
1131           dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1132           newline_and_indent (buffer, spc);
1133           pp_character (buffer, '}');
1134         }
1135       is_expr = false;
1136       break;
1137
1138     case CALL_EXPR:
1139       print_call_name (buffer, node);
1140
1141       /* Print parameters.  */
1142       pp_space (buffer);
1143       pp_character (buffer, '(');
1144       op1 = TREE_OPERAND (node, 1);
1145       if (op1)
1146         dump_generic_node (buffer, op1, spc, flags, false);
1147       pp_character (buffer, ')');
1148
1149       op1 = TREE_OPERAND (node, 2);
1150       if (op1)
1151         {
1152           pp_string (buffer, " [static-chain: ");
1153           dump_generic_node (buffer, op1, spc, flags, false);
1154           pp_character (buffer, ']');
1155         }
1156
1157       if (CALL_EXPR_RETURN_SLOT_OPT (node))
1158         pp_string (buffer, " [return slot optimization]");
1159       if (CALL_EXPR_TAILCALL (node))
1160         pp_string (buffer, " [tail call]");
1161       break;
1162
1163     case WITH_CLEANUP_EXPR:
1164       NIY;
1165       break;
1166
1167     case CLEANUP_POINT_EXPR:
1168       pp_string (buffer, "<<cleanup_point ");
1169       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1170       pp_string (buffer, ">>");
1171       break;
1172
1173     case PLACEHOLDER_EXPR:
1174       pp_string (buffer, "<PLACEHOLDER_EXPR ");
1175       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1176       pp_character (buffer, '>');
1177       break;
1178
1179       /* Binary arithmetic and logic expressions.  */
1180     case WIDEN_SUM_EXPR:
1181     case WIDEN_MULT_EXPR:
1182     case MULT_EXPR:
1183     case PLUS_EXPR:
1184     case MINUS_EXPR:
1185     case TRUNC_DIV_EXPR:
1186     case CEIL_DIV_EXPR:
1187     case FLOOR_DIV_EXPR:
1188     case ROUND_DIV_EXPR:
1189     case TRUNC_MOD_EXPR:
1190     case CEIL_MOD_EXPR:
1191     case FLOOR_MOD_EXPR:
1192     case ROUND_MOD_EXPR:
1193     case RDIV_EXPR:
1194     case EXACT_DIV_EXPR:
1195     case LSHIFT_EXPR:
1196     case RSHIFT_EXPR:
1197     case LROTATE_EXPR:
1198     case RROTATE_EXPR:
1199     case VEC_LSHIFT_EXPR:
1200     case VEC_RSHIFT_EXPR:
1201     case BIT_IOR_EXPR:
1202     case BIT_XOR_EXPR:
1203     case BIT_AND_EXPR:
1204     case TRUTH_ANDIF_EXPR:
1205     case TRUTH_ORIF_EXPR:
1206     case TRUTH_AND_EXPR:
1207     case TRUTH_OR_EXPR:
1208     case TRUTH_XOR_EXPR:
1209     case LT_EXPR:
1210     case LE_EXPR:
1211     case GT_EXPR:
1212     case GE_EXPR:
1213     case EQ_EXPR:
1214     case NE_EXPR:
1215     case UNLT_EXPR:
1216     case UNLE_EXPR:
1217     case UNGT_EXPR:
1218     case UNGE_EXPR:
1219     case UNEQ_EXPR:
1220     case LTGT_EXPR:
1221     case ORDERED_EXPR:
1222     case UNORDERED_EXPR:
1223       {
1224         const char *op = op_symbol (node);
1225         op0 = TREE_OPERAND (node, 0);
1226         op1 = TREE_OPERAND (node, 1);
1227
1228         /* When the operands are expressions with less priority,
1229            keep semantics of the tree representation.  */
1230         if (op_prio (op0) < op_prio (node))
1231           {
1232             pp_character (buffer, '(');
1233             dump_generic_node (buffer, op0, spc, flags, false);
1234             pp_character (buffer, ')');
1235           }
1236         else
1237           dump_generic_node (buffer, op0, spc, flags, false);
1238
1239         pp_space (buffer);
1240         pp_string (buffer, op);
1241         pp_space (buffer);
1242
1243         /* When the operands are expressions with less priority,
1244            keep semantics of the tree representation.  */
1245         if (op_prio (op1) < op_prio (node))
1246           {
1247             pp_character (buffer, '(');
1248             dump_generic_node (buffer, op1, spc, flags, false);
1249             pp_character (buffer, ')');
1250           }
1251         else
1252           dump_generic_node (buffer, op1, spc, flags, false);
1253       }
1254       break;
1255
1256       /* Unary arithmetic and logic expressions.  */
1257     case NEGATE_EXPR:
1258     case BIT_NOT_EXPR:
1259     case TRUTH_NOT_EXPR:
1260     case ADDR_EXPR:
1261     case PREDECREMENT_EXPR:
1262     case PREINCREMENT_EXPR:
1263     case ALIGN_INDIRECT_REF:
1264     case MISALIGNED_INDIRECT_REF:
1265     case INDIRECT_REF:
1266       if (TREE_CODE (node) == ADDR_EXPR
1267           && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1268               || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1269         ;       /* Do not output '&' for strings and function pointers.  */
1270       else
1271         pp_string (buffer, op_symbol (node));
1272
1273       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1274         {
1275           pp_character (buffer, '(');
1276           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1277           pp_character (buffer, ')');
1278         }
1279       else
1280         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1281
1282       if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1283         {
1284           pp_string (buffer, "{misalignment: ");
1285           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1286           pp_character (buffer, '}');
1287         }
1288       break;
1289
1290     case POSTDECREMENT_EXPR:
1291     case POSTINCREMENT_EXPR:
1292       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1293         {
1294           pp_character (buffer, '(');
1295           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1296           pp_character (buffer, ')');
1297         }
1298       else
1299         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1300       pp_string (buffer, op_symbol (node));
1301       break;
1302
1303     case MIN_EXPR:
1304       pp_string (buffer, "MIN_EXPR <");
1305       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1306       pp_string (buffer, ", ");
1307       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1308       pp_character (buffer, '>');
1309       break;
1310
1311     case MAX_EXPR:
1312       pp_string (buffer, "MAX_EXPR <");
1313       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1314       pp_string (buffer, ", ");
1315       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1316       pp_character (buffer, '>');
1317       break;
1318
1319     case ABS_EXPR:
1320       pp_string (buffer, "ABS_EXPR <");
1321       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1322       pp_character (buffer, '>');
1323       break;
1324
1325     case RANGE_EXPR:
1326       NIY;
1327       break;
1328
1329     case FIX_TRUNC_EXPR:
1330     case FLOAT_EXPR:
1331     case CONVERT_EXPR:
1332     case NOP_EXPR:
1333       type = TREE_TYPE (node);
1334       op0 = TREE_OPERAND (node, 0);
1335       if (type != TREE_TYPE (op0))
1336         {
1337           pp_character (buffer, '(');
1338           dump_generic_node (buffer, type, spc, flags, false);
1339           pp_string (buffer, ") ");
1340         }
1341       if (op_prio (op0) < op_prio (node))
1342         pp_character (buffer, '(');
1343       dump_generic_node (buffer, op0, spc, flags, false);
1344       if (op_prio (op0) < op_prio (node))
1345         pp_character (buffer, ')');
1346       break;
1347
1348     case VIEW_CONVERT_EXPR:
1349       pp_string (buffer, "VIEW_CONVERT_EXPR<");
1350       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1351       pp_string (buffer, ">(");
1352       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1353       pp_character (buffer, ')');
1354       break;
1355
1356     case NON_LVALUE_EXPR:
1357       pp_string (buffer, "NON_LVALUE_EXPR <");
1358       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1359       pp_character (buffer, '>');
1360       break;
1361
1362     case SAVE_EXPR:
1363       pp_string (buffer, "SAVE_EXPR <");
1364       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1365       pp_character (buffer, '>');
1366       break;
1367
1368     case COMPLEX_EXPR:
1369       pp_string (buffer, "COMPLEX_EXPR <");
1370       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1371       pp_string (buffer, ", ");
1372       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1373       pp_string (buffer, ">");
1374       break;
1375
1376     case CONJ_EXPR:
1377       pp_string (buffer, "CONJ_EXPR <");
1378       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1379       pp_string (buffer, ">");
1380       break;
1381
1382     case REALPART_EXPR:
1383       pp_string (buffer, "REALPART_EXPR <");
1384       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1385       pp_string (buffer, ">");
1386       break;
1387
1388     case IMAGPART_EXPR:
1389       pp_string (buffer, "IMAGPART_EXPR <");
1390       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1391       pp_string (buffer, ">");
1392       break;
1393
1394     case VA_ARG_EXPR:
1395       pp_string (buffer, "VA_ARG_EXPR <");
1396       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1397       pp_string (buffer, ">");
1398       break;
1399
1400     case TRY_FINALLY_EXPR:
1401     case TRY_CATCH_EXPR:
1402       pp_string (buffer, "try");
1403       newline_and_indent (buffer, spc+2);
1404       pp_string (buffer, "{");
1405       newline_and_indent (buffer, spc+4);
1406       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1407       newline_and_indent (buffer, spc+2);
1408       pp_string (buffer, "}");
1409       newline_and_indent (buffer, spc);
1410       pp_string (buffer,
1411                          (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1412       newline_and_indent (buffer, spc+2);
1413       pp_string (buffer, "{");
1414       newline_and_indent (buffer, spc+4);
1415       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1416       newline_and_indent (buffer, spc+2);
1417       pp_string (buffer, "}");
1418       is_expr = false;
1419       break;
1420
1421     case CATCH_EXPR:
1422       pp_string (buffer, "catch (");
1423       dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1424       pp_string (buffer, ")");
1425       newline_and_indent (buffer, spc+2);
1426       pp_string (buffer, "{");
1427       newline_and_indent (buffer, spc+4);
1428       dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1429       newline_and_indent (buffer, spc+2);
1430       pp_string (buffer, "}");
1431       is_expr = false;
1432       break;
1433
1434     case EH_FILTER_EXPR:
1435       pp_string (buffer, "<<<eh_filter (");
1436       dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1437       pp_string (buffer, ")>>>");
1438       newline_and_indent (buffer, spc+2);
1439       pp_string (buffer, "{");
1440       newline_and_indent (buffer, spc+4);
1441       dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1442       newline_and_indent (buffer, spc+2);
1443       pp_string (buffer, "}");
1444       is_expr = false;
1445       break;
1446
1447     case LABEL_EXPR:
1448       op0 = TREE_OPERAND (node, 0);
1449       /* If this is for break or continue, don't bother printing it.  */
1450       if (DECL_NAME (op0))
1451         {
1452           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1453           if (strcmp (name, "break") == 0
1454               || strcmp (name, "continue") == 0)
1455             break;
1456         }
1457       dump_generic_node (buffer, op0, spc, flags, false);
1458       pp_character (buffer, ':');
1459       if (DECL_NONLOCAL (op0))
1460         pp_string (buffer, " [non-local]");
1461       break;
1462
1463     case EXC_PTR_EXPR:
1464       pp_string (buffer, "<<<exception object>>>");
1465       break;
1466
1467     case FILTER_EXPR:
1468       pp_string (buffer, "<<<filter object>>>");
1469       break;
1470
1471     case LOOP_EXPR:
1472       pp_string (buffer, "while (1)");
1473       if (!(flags & TDF_SLIM))
1474         {
1475           newline_and_indent (buffer, spc+2);
1476           pp_character (buffer, '{');
1477           newline_and_indent (buffer, spc+4);
1478           dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1479           newline_and_indent (buffer, spc+2);
1480           pp_character (buffer, '}');
1481         }
1482       is_expr = false;
1483       break;
1484
1485     case RETURN_EXPR:
1486       pp_string (buffer, "return");
1487       op0 = TREE_OPERAND (node, 0);
1488       if (op0)
1489         {
1490           pp_space (buffer);
1491           if (TREE_CODE (op0) == MODIFY_EXPR
1492               || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
1493             dump_generic_node (buffer, GENERIC_TREE_OPERAND (op0, 1),
1494                                spc, flags, false);
1495           else
1496             dump_generic_node (buffer, op0, spc, flags, false);
1497         }
1498       break;
1499
1500     case EXIT_EXPR:
1501       pp_string (buffer, "if (");
1502       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1503       pp_string (buffer, ") break");
1504       break;
1505
1506     case SWITCH_EXPR:
1507       pp_string (buffer, "switch (");
1508       dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1509       pp_character (buffer, ')');
1510       if (!(flags & TDF_SLIM))
1511         {
1512           newline_and_indent (buffer, spc+2);
1513           pp_character (buffer, '{');
1514           if (SWITCH_BODY (node))
1515             {
1516               newline_and_indent (buffer, spc+4);
1517               dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1518                                  true);
1519             }
1520           else
1521             {
1522               tree vec = SWITCH_LABELS (node);
1523               size_t i, n = TREE_VEC_LENGTH (vec);
1524               for (i = 0; i < n; ++i)
1525                 {
1526                   tree elt = TREE_VEC_ELT (vec, i);
1527                   newline_and_indent (buffer, spc+4);
1528                   if (elt)
1529                     {
1530                       dump_generic_node (buffer, elt, spc+4, flags, false);
1531                       pp_string (buffer, " goto ");
1532                       dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1533                                          flags, true);
1534                       pp_semicolon (buffer);
1535                     }
1536                   else
1537                     pp_string (buffer, "case ???: goto ???;");
1538                 }
1539             }
1540           newline_and_indent (buffer, spc+2);
1541           pp_character (buffer, '}');
1542         }
1543       is_expr = false;
1544       break;
1545
1546     case GOTO_EXPR:
1547       op0 = GOTO_DESTINATION (node);
1548       if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1549         {
1550           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1551           if (strcmp (name, "break") == 0
1552               || strcmp (name, "continue") == 0)
1553             {
1554               pp_string (buffer, name);
1555               break;
1556             }
1557         }
1558       pp_string (buffer, "goto ");
1559       dump_generic_node (buffer, op0, spc, flags, false);
1560       break;
1561
1562     case RESX_EXPR:
1563       pp_string (buffer, "resx ");
1564       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1565       break;
1566
1567     case ASM_EXPR:
1568       pp_string (buffer, "__asm__");
1569       if (ASM_VOLATILE_P (node))
1570         pp_string (buffer, " __volatile__");
1571       pp_character (buffer, '(');
1572       dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1573       pp_character (buffer, ':');
1574       dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1575       pp_character (buffer, ':');
1576       dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1577       if (ASM_CLOBBERS (node))
1578         {
1579           pp_character (buffer, ':');
1580           dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1581         }
1582       pp_string (buffer, ")");
1583       break;
1584
1585     case CASE_LABEL_EXPR:
1586       if (CASE_LOW (node) && CASE_HIGH (node))
1587         {
1588           pp_string (buffer, "case ");
1589           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1590           pp_string (buffer, " ... ");
1591           dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1592         }
1593       else if (CASE_LOW (node))
1594         {
1595           pp_string (buffer, "case ");
1596           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1597         }
1598       else
1599         pp_string (buffer, "default ");
1600       pp_character (buffer, ':');
1601       break;
1602
1603     case OBJ_TYPE_REF:
1604       pp_string (buffer, "OBJ_TYPE_REF(");
1605       dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1606       pp_character (buffer, ';');
1607       dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1608       pp_character (buffer, '-');
1609       pp_character (buffer, '>');
1610       dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1611       pp_character (buffer, ')');
1612       break;
1613
1614     case PHI_NODE:
1615       {
1616         int i;
1617
1618         dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1619         pp_string (buffer, " = PHI <");
1620         for (i = 0; i < PHI_NUM_ARGS (node); i++)
1621           {
1622             dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1623             pp_string (buffer, "(");
1624             pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1625             pp_string (buffer, ")");
1626             if (i < PHI_NUM_ARGS (node) - 1)
1627               pp_string (buffer, ", ");
1628           }
1629         pp_string (buffer, ">;");
1630       }
1631       break;
1632
1633     case SSA_NAME:
1634       dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1635       pp_string (buffer, "_");
1636       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1637       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1638         pp_string (buffer, "(ab)");
1639       break;
1640
1641     case WITH_SIZE_EXPR:
1642       pp_string (buffer, "WITH_SIZE_EXPR <");
1643       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1644       pp_string (buffer, ", ");
1645       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1646       pp_string (buffer, ">");
1647       break;
1648
1649     case VALUE_HANDLE:
1650       pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1651       break;
1652
1653     case ASSERT_EXPR:
1654       pp_string (buffer, "ASSERT_EXPR <");
1655       dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1656       pp_string (buffer, ", ");
1657       dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1658       pp_string (buffer, ">");
1659       break;
1660
1661     case SCEV_KNOWN:
1662       pp_string (buffer, "scev_known");
1663       break;
1664
1665     case SCEV_NOT_KNOWN:
1666       pp_string (buffer, "scev_not_known");
1667       break;
1668
1669     case POLYNOMIAL_CHREC:
1670       pp_string (buffer, "{");
1671       dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1672       pp_string (buffer, ", +, ");
1673       dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1674       pp_string (buffer, "}_");
1675       dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1676       is_stmt = false;
1677       break;
1678
1679     case REALIGN_LOAD_EXPR:
1680       pp_string (buffer, "REALIGN_LOAD <");
1681       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1682       pp_string (buffer, ", ");
1683       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1684       pp_string (buffer, ", ");
1685       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1686       pp_string (buffer, ">");
1687       break;
1688
1689     case VEC_COND_EXPR:
1690       pp_string (buffer, " VEC_COND_EXPR < ");
1691       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1692       pp_string (buffer, " , ");
1693       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1694       pp_string (buffer, " , ");
1695       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1696       pp_string (buffer, " > ");
1697       break;
1698
1699     case DOT_PROD_EXPR:
1700       pp_string (buffer, " DOT_PROD_EXPR < ");
1701       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1702       pp_string (buffer, ", ");
1703       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1704       pp_string (buffer, ", ");
1705       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1706       pp_string (buffer, " > ");
1707       break;
1708
1709     case OMP_PARALLEL:
1710       pp_string (buffer, "#pragma omp parallel");
1711       dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1712       if (OMP_PARALLEL_FN (node))
1713         {
1714           pp_string (buffer, " [child fn: ");
1715           dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1716
1717           pp_string (buffer, " (");
1718
1719           if (OMP_PARALLEL_DATA_ARG (node))
1720             dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1721                                false);
1722           else
1723             pp_string (buffer, "???");
1724
1725           pp_string (buffer, ")]");
1726         }
1727
1728     dump_omp_body:
1729       if (!(flags & TDF_SLIM) && OMP_BODY (node))
1730         {
1731           newline_and_indent (buffer, spc + 2);
1732           pp_character (buffer, '{');
1733           newline_and_indent (buffer, spc + 4);
1734           dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1735           newline_and_indent (buffer, spc + 2);
1736           pp_character (buffer, '}');
1737         }
1738       is_expr = false;
1739       break;
1740
1741     case OMP_FOR:
1742       pp_string (buffer, "#pragma omp for");
1743       dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1744
1745       if (!(flags & TDF_SLIM))
1746         {
1747           if (OMP_FOR_PRE_BODY (node))
1748             {
1749               newline_and_indent (buffer, spc + 2);
1750               pp_character (buffer, '{');
1751               spc += 4;
1752               newline_and_indent (buffer, spc);
1753               dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1754                   spc, flags, false);
1755             }
1756           newline_and_indent (buffer, spc);
1757           pp_string (buffer, "for (");
1758           dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1759           pp_string (buffer, "; ");
1760           dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1761           pp_string (buffer, "; ");
1762           dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1763           pp_string (buffer, ")");
1764           if (OMP_FOR_BODY (node))
1765             {
1766               newline_and_indent (buffer, spc + 2);
1767               pp_character (buffer, '{');
1768               newline_and_indent (buffer, spc + 4);
1769               dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1770                   false);
1771               newline_and_indent (buffer, spc + 2);
1772               pp_character (buffer, '}');
1773             }
1774           if (OMP_FOR_PRE_BODY (node))
1775             {
1776               spc -= 4;
1777               newline_and_indent (buffer, spc + 2);
1778               pp_character (buffer, '}');
1779             }
1780         }
1781       is_expr = false;
1782       break;
1783
1784     case OMP_SECTIONS:
1785       pp_string (buffer, "#pragma omp sections");
1786       dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1787       goto dump_omp_body;
1788
1789     case OMP_SECTION:
1790       pp_string (buffer, "#pragma omp section");
1791       goto dump_omp_body;
1792
1793     case OMP_MASTER:
1794       pp_string (buffer, "#pragma omp master");
1795       goto dump_omp_body;
1796
1797     case OMP_ORDERED:
1798       pp_string (buffer, "#pragma omp ordered");
1799       goto dump_omp_body;
1800
1801     case OMP_CRITICAL:
1802       pp_string (buffer, "#pragma omp critical");
1803       if (OMP_CRITICAL_NAME (node))
1804         {
1805           pp_space (buffer);
1806           pp_character (buffer, '(');
1807           dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1808                              flags, false);
1809           pp_character (buffer, ')');
1810         }
1811       goto dump_omp_body;
1812
1813     case OMP_ATOMIC:
1814       pp_string (buffer, "#pragma omp atomic");
1815       newline_and_indent (buffer, spc + 2);
1816       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1817       pp_space (buffer);
1818       pp_character (buffer, '=');
1819       pp_space (buffer);
1820       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1821       break;
1822
1823     case OMP_SINGLE:
1824       pp_string (buffer, "#pragma omp single");
1825       dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1826       goto dump_omp_body;
1827
1828     case OMP_RETURN:
1829       pp_string (buffer, "OMP_RETURN");
1830       if (OMP_RETURN_NOWAIT (node))
1831         pp_string (buffer, " [nowait]");
1832       is_expr = false;
1833       break;
1834
1835     case OMP_CONTINUE:
1836       pp_string (buffer, "OMP_CONTINUE");
1837       is_expr = false;
1838       break;
1839
1840     case OMP_CLAUSE:
1841       dump_omp_clause (buffer, node, spc, flags);
1842       is_expr = false;
1843       break;
1844
1845     case REDUC_MAX_EXPR:
1846       pp_string (buffer, " REDUC_MAX_EXPR < ");
1847       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1848       pp_string (buffer, " > ");
1849       break;
1850
1851     case REDUC_MIN_EXPR:
1852       pp_string (buffer, " REDUC_MIN_EXPR < ");
1853       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1854       pp_string (buffer, " > ");
1855       break;
1856
1857     case REDUC_PLUS_EXPR:
1858       pp_string (buffer, " REDUC_PLUS_EXPR < ");
1859       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1860       pp_string (buffer, " > ");
1861       break;
1862
1863     case VEC_WIDEN_MULT_HI_EXPR:
1864       pp_string (buffer, " VEC_WIDEN_MULT_HI_EXPR < ");
1865       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1866       pp_string (buffer, ", ");
1867       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1868       pp_string (buffer, " > ");
1869       break;
1870
1871     case VEC_WIDEN_MULT_LO_EXPR:
1872       pp_string (buffer, " VEC_WIDEN_MULT_LO_EXPR < ");
1873       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1874       pp_string (buffer, ", ");
1875       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1876       pp_string (buffer, " > ");
1877       break;
1878
1879     case VEC_UNPACK_HI_EXPR:
1880       pp_string (buffer, " VEC_UNPACK_HI_EXPR < ");
1881       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1882       pp_string (buffer, " > ");
1883       break;
1884
1885     case VEC_UNPACK_LO_EXPR:
1886       pp_string (buffer, " VEC_UNPACK_LO_EXPR < ");
1887       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1888       pp_string (buffer, " > ");
1889       break;
1890
1891     case VEC_PACK_MOD_EXPR:
1892       pp_string (buffer, " VEC_PACK_MOD_EXPR < ");
1893       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1894       pp_string (buffer, ", ");
1895       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1896       pp_string (buffer, " > ");
1897       break;
1898
1899     case VEC_PACK_SAT_EXPR:
1900       pp_string (buffer, " VEC_PACK_SAT_EXPR < ");
1901       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1902       pp_string (buffer, ", ");
1903       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1904       pp_string (buffer, " > ");
1905       break;
1906
1907     case BLOCK:
1908       {
1909         tree t;
1910         pp_string (buffer, "BLOCK");
1911
1912         if (BLOCK_ABSTRACT (node))
1913           pp_string (buffer, " [abstract]");
1914
1915         if (TREE_ASM_WRITTEN (node))
1916           pp_string (buffer, " [written]");
1917
1918         newline_and_indent (buffer, spc + 2);
1919
1920         if (BLOCK_SUPERCONTEXT (node))
1921           {
1922             pp_string (buffer, "SUPERCONTEXT: ");
1923             if (TREE_CODE (BLOCK_SUPERCONTEXT (node)) == BLOCK)
1924               pp_printf (buffer, "BLOCK %p",
1925                          (void *)BLOCK_SUPERCONTEXT (node));
1926             else
1927               dump_generic_node (buffer, BLOCK_SUPERCONTEXT (node), 0, flags,
1928                                  false);
1929             newline_and_indent (buffer, spc + 2);
1930           }
1931
1932         if (BLOCK_SUBBLOCKS (node))
1933           {
1934             pp_string (buffer, "SUBBLOCKS: ");
1935             for (t = BLOCK_SUBBLOCKS (node); t; t = BLOCK_CHAIN (t))
1936               pp_printf (buffer, "%p ", (void *)t);
1937             newline_and_indent (buffer, spc + 2);
1938           }
1939
1940         if (BLOCK_VARS (node))
1941           {
1942             pp_string (buffer, "VARS: ");
1943             for (t = BLOCK_VARS (node); t; t = TREE_CHAIN (t))
1944               {
1945                 dump_generic_node (buffer, t, 0, flags, false);
1946                 pp_string (buffer, " ");
1947               }
1948             newline_and_indent (buffer, spc + 2);
1949           }
1950
1951         if (BLOCK_ABSTRACT_ORIGIN (node))
1952           {
1953             pp_string (buffer, "ABSTRACT_ORIGIN: ");
1954             if (TREE_CODE (BLOCK_ABSTRACT_ORIGIN (node)) == BLOCK)
1955               pp_printf (buffer, "BLOCK %p",
1956                          (void *)BLOCK_ABSTRACT_ORIGIN (node));
1957             else
1958               dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (node), 0, flags,
1959                                  false);
1960             newline_and_indent (buffer, spc + 2);
1961           }
1962       }
1963     break;
1964
1965     case VEC_EXTRACT_EVEN_EXPR:
1966       pp_string (buffer, " VEC_EXTRACT_EVEN_EXPR < ");
1967       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1968       pp_string (buffer, ", ");
1969       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1970       pp_string (buffer, " > ");
1971       break;
1972
1973     case VEC_EXTRACT_ODD_EXPR:
1974       pp_string (buffer, " VEC_EXTRACT_ODD_EXPR < ");
1975       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1976       pp_string (buffer, ", ");
1977       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1978       pp_string (buffer, " > ");
1979       break;
1980
1981     case VEC_INTERLEAVE_HIGH_EXPR:
1982       pp_string (buffer, " VEC_INTERLEAVE_HIGH_EXPR < ");
1983       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1984       pp_string (buffer, ", ");
1985       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1986       pp_string (buffer, " > ");
1987       break;
1988
1989     case VEC_INTERLEAVE_LOW_EXPR:
1990       pp_string (buffer, " VEC_INTERLEAVE_LOW_EXPR < ");
1991       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1992       pp_string (buffer, ", ");
1993       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1994       pp_string (buffer, " > ");
1995       break;
1996
1997     default:
1998       NIY;
1999     }
2000
2001   if (is_stmt && is_expr)
2002     pp_semicolon (buffer);
2003   pp_write_text_to_stream (buffer);
2004
2005   return spc;
2006 }
2007
2008 /* Print the declaration of a variable.  */
2009
2010 static void
2011 print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
2012 {
2013   INDENT (spc);
2014
2015   if (TREE_CODE (t) == TYPE_DECL)
2016     pp_string (buffer, "typedef ");
2017
2018   if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_WRTL) && DECL_REGISTER (t))
2019     pp_string (buffer, "register ");
2020
2021   if (TREE_PUBLIC (t) && DECL_EXTERNAL (t))
2022     pp_string (buffer, "extern ");
2023   else if (TREE_STATIC (t))
2024     pp_string (buffer, "static ");
2025
2026   /* Print the type and name.  */
2027   if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
2028     {
2029       tree tmp;
2030
2031       /* Print array's type.  */
2032       tmp = TREE_TYPE (t);
2033       while (TREE_CODE (TREE_TYPE (tmp)) == ARRAY_TYPE)
2034         tmp = TREE_TYPE (tmp);
2035       dump_generic_node (buffer, TREE_TYPE (tmp), spc, flags, false);
2036
2037       /* Print variable's name.  */
2038       pp_space (buffer);
2039       dump_generic_node (buffer, t, spc, flags, false);
2040
2041       /* Print the dimensions.  */
2042       tmp = TREE_TYPE (t);
2043       while (TREE_CODE (tmp) == ARRAY_TYPE)
2044         {
2045           dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
2046           tmp = TREE_TYPE (tmp);
2047         }
2048     }
2049   else if (TREE_CODE (t) == FUNCTION_DECL)
2050     {
2051       dump_generic_node (buffer, TREE_TYPE (TREE_TYPE (t)), spc, flags, false);
2052       pp_space (buffer);
2053       dump_decl_name (buffer, t, flags);
2054       dump_function_declaration (buffer, TREE_TYPE (t), spc, flags);
2055     }
2056   else
2057     {
2058       /* Print type declaration.  */
2059       dump_generic_node (buffer, TREE_TYPE (t), spc, flags, false);
2060
2061       /* Print variable's name.  */
2062       pp_space (buffer);
2063       dump_generic_node (buffer, t, spc, flags, false);
2064     }
2065
2066   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
2067     {
2068       pp_string (buffer, " __asm__ ");
2069       pp_character (buffer, '(');
2070       dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
2071       pp_character (buffer, ')');
2072     }
2073
2074   /* The initial value of a function serves to determine wether the function
2075      is declared or defined.  So the following does not apply to function
2076      nodes.  */
2077   if (TREE_CODE (t) != FUNCTION_DECL)
2078     {
2079       /* Print the initial value.  */
2080       if (DECL_INITIAL (t))
2081         {
2082           pp_space (buffer);
2083           pp_character (buffer, '=');
2084           pp_space (buffer);
2085           dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
2086         }
2087     }
2088
2089   if (TREE_CODE (t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (t))
2090     {
2091       pp_string (buffer, " [value-expr: ");
2092       dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
2093       pp_character (buffer, ']');
2094     }
2095
2096   pp_character (buffer, ';');
2097 }
2098
2099
2100 /* Prints a structure: name, fields, and methods.
2101    FIXME: Still incomplete.  */
2102
2103 static void
2104 print_struct_decl (pretty_printer *buffer, tree node, int spc, int flags)
2105 {
2106   /* Print the name of the structure.  */
2107   if (TYPE_NAME (node))
2108     {
2109       INDENT (spc);
2110       if (TREE_CODE (node) == RECORD_TYPE)
2111         pp_string (buffer, "struct ");
2112       else if ((TREE_CODE (node) == UNION_TYPE
2113                 || TREE_CODE (node) == QUAL_UNION_TYPE))
2114         pp_string (buffer, "union ");
2115
2116       dump_generic_node (buffer, TYPE_NAME (node), spc, 0, false);
2117     }
2118
2119   /* Print the contents of the structure.  */
2120   pp_newline (buffer);
2121   INDENT (spc);
2122   pp_character (buffer, '{');
2123   pp_newline (buffer);
2124
2125   /* Print the fields of the structure.  */
2126   {
2127     tree tmp;
2128     tmp = TYPE_FIELDS (node);
2129     while (tmp)
2130       {
2131         /* Avoid to print recursively the structure.  */
2132         /* FIXME : Not implemented correctly...,
2133            what about the case when we have a cycle in the contain graph? ...
2134            Maybe this could be solved by looking at the scope in which the
2135            structure was declared.  */
2136         if (TREE_TYPE (tmp) != node
2137             || (TREE_CODE (TREE_TYPE (tmp)) == POINTER_TYPE
2138                 && TREE_TYPE (TREE_TYPE (tmp)) != node))
2139           {
2140             print_declaration (buffer, tmp, spc+2, flags);
2141             pp_newline (buffer);
2142           }
2143         tmp = TREE_CHAIN (tmp);
2144       }
2145   }
2146   INDENT (spc);
2147   pp_character (buffer, '}');
2148 }
2149
2150 /* Return the priority of the operator OP.
2151
2152    From lowest to highest precedence with either left-to-right (L-R)
2153    or right-to-left (R-L) associativity]:
2154
2155      1  [L-R] ,
2156      2  [R-L] = += -= *= /= %= &= ^= |= <<= >>=
2157      3  [R-L] ?:
2158      4  [L-R] ||
2159      5  [L-R] &&
2160      6  [L-R] |
2161      7  [L-R] ^
2162      8  [L-R] &
2163      9  [L-R] == !=
2164     10  [L-R] < <= > >=
2165     11  [L-R] << >>
2166     12  [L-R] + -
2167     13  [L-R] * / %
2168     14  [R-L] ! ~ ++ -- + - * & (type) sizeof
2169     15  [L-R] fn() [] -> .
2170
2171    unary +, - and * have higher precedence than the corresponding binary
2172    operators.  */
2173
2174 static int
2175 op_prio (tree op)
2176 {
2177   if (op == NULL)
2178     return 9999;
2179
2180   switch (TREE_CODE (op))
2181     {
2182     case TREE_LIST:
2183     case COMPOUND_EXPR:
2184     case BIND_EXPR:
2185       return 1;
2186
2187     case MODIFY_EXPR:
2188     case GIMPLE_MODIFY_STMT:
2189     case INIT_EXPR:
2190       return 2;
2191
2192     case COND_EXPR:
2193       return 3;
2194
2195     case TRUTH_OR_EXPR:
2196     case TRUTH_ORIF_EXPR:
2197       return 4;
2198
2199     case TRUTH_AND_EXPR:
2200     case TRUTH_ANDIF_EXPR:
2201       return 5;
2202
2203     case BIT_IOR_EXPR:
2204       return 6;
2205
2206     case BIT_XOR_EXPR:
2207     case TRUTH_XOR_EXPR:
2208       return 7;
2209
2210     case BIT_AND_EXPR:
2211       return 8;
2212
2213     case EQ_EXPR:
2214     case NE_EXPR:
2215       return 9;
2216
2217     case UNLT_EXPR:
2218     case UNLE_EXPR:
2219     case UNGT_EXPR:
2220     case UNGE_EXPR:
2221     case UNEQ_EXPR:
2222     case LTGT_EXPR:
2223     case ORDERED_EXPR:
2224     case UNORDERED_EXPR:
2225     case LT_EXPR:
2226     case LE_EXPR:
2227     case GT_EXPR:
2228     case GE_EXPR:
2229       return 10;
2230
2231     case LSHIFT_EXPR:
2232     case RSHIFT_EXPR:
2233     case LROTATE_EXPR:
2234     case RROTATE_EXPR:
2235       return 11;
2236
2237     case WIDEN_SUM_EXPR:
2238     case PLUS_EXPR:
2239     case MINUS_EXPR:
2240       return 12;
2241
2242     case VEC_WIDEN_MULT_HI_EXPR:
2243     case VEC_WIDEN_MULT_LO_EXPR:
2244     case WIDEN_MULT_EXPR:
2245     case DOT_PROD_EXPR:
2246     case MULT_EXPR:
2247     case TRUNC_DIV_EXPR:
2248     case CEIL_DIV_EXPR:
2249     case FLOOR_DIV_EXPR:
2250     case ROUND_DIV_EXPR:
2251     case RDIV_EXPR:
2252     case EXACT_DIV_EXPR:
2253     case TRUNC_MOD_EXPR:
2254     case CEIL_MOD_EXPR:
2255     case FLOOR_MOD_EXPR:
2256     case ROUND_MOD_EXPR:
2257       return 13;
2258
2259     case TRUTH_NOT_EXPR:
2260     case BIT_NOT_EXPR:
2261     case POSTINCREMENT_EXPR:
2262     case POSTDECREMENT_EXPR:
2263     case PREINCREMENT_EXPR:
2264     case PREDECREMENT_EXPR:
2265     case NEGATE_EXPR:
2266     case ALIGN_INDIRECT_REF:
2267     case MISALIGNED_INDIRECT_REF:
2268     case INDIRECT_REF:
2269     case ADDR_EXPR:
2270     case FLOAT_EXPR:
2271     case NOP_EXPR:
2272     case CONVERT_EXPR:
2273     case FIX_TRUNC_EXPR:
2274     case TARGET_EXPR:
2275       return 14;
2276
2277     case CALL_EXPR:
2278     case ARRAY_REF:
2279     case ARRAY_RANGE_REF:
2280     case COMPONENT_REF:
2281       return 15;
2282
2283       /* Special expressions.  */
2284     case MIN_EXPR:
2285     case MAX_EXPR:
2286     case ABS_EXPR:
2287     case REALPART_EXPR:
2288     case IMAGPART_EXPR:
2289     case REDUC_MAX_EXPR:
2290     case REDUC_MIN_EXPR:
2291     case REDUC_PLUS_EXPR:
2292     case VEC_LSHIFT_EXPR:
2293     case VEC_RSHIFT_EXPR:
2294     case VEC_UNPACK_HI_EXPR:
2295     case VEC_UNPACK_LO_EXPR:
2296     case VEC_PACK_MOD_EXPR:
2297     case VEC_PACK_SAT_EXPR:
2298       return 16;
2299
2300     case SAVE_EXPR:
2301     case NON_LVALUE_EXPR:
2302       return op_prio (TREE_OPERAND (op, 0));
2303
2304     default:
2305       /* Return an arbitrarily high precedence to avoid surrounding single
2306          VAR_DECLs in ()s.  */
2307       return 9999;
2308     }
2309 }
2310
2311
2312 /* Return the symbol associated with operator OP.  */
2313
2314 static const char *
2315 op_symbol_1 (enum tree_code code)
2316 {
2317   switch (code)
2318     {
2319     case MODIFY_EXPR:
2320     case GIMPLE_MODIFY_STMT:
2321       return "=";
2322
2323     case TRUTH_OR_EXPR:
2324     case TRUTH_ORIF_EXPR:
2325       return "||";
2326
2327     case TRUTH_AND_EXPR:
2328     case TRUTH_ANDIF_EXPR:
2329       return "&&";
2330
2331     case BIT_IOR_EXPR:
2332       return "|";
2333
2334     case TRUTH_XOR_EXPR:
2335     case BIT_XOR_EXPR:
2336       return "^";
2337
2338     case ADDR_EXPR:
2339     case BIT_AND_EXPR:
2340       return "&";
2341
2342     case ORDERED_EXPR:
2343       return "ord";
2344     case UNORDERED_EXPR:
2345       return "unord";
2346
2347     case EQ_EXPR:
2348       return "==";
2349     case UNEQ_EXPR:
2350       return "u==";
2351
2352     case NE_EXPR:
2353       return "!=";
2354
2355     case LT_EXPR:
2356       return "<";
2357     case UNLT_EXPR:
2358       return "u<";
2359
2360     case LE_EXPR:
2361       return "<=";
2362     case UNLE_EXPR:
2363       return "u<=";
2364
2365     case GT_EXPR:
2366       return ">";
2367     case UNGT_EXPR:
2368       return "u>";
2369
2370     case GE_EXPR:
2371       return ">=";
2372     case UNGE_EXPR:
2373       return "u>=";
2374
2375     case LTGT_EXPR:
2376       return "<>";
2377
2378     case LSHIFT_EXPR:
2379       return "<<";
2380
2381     case RSHIFT_EXPR:
2382       return ">>";
2383
2384     case LROTATE_EXPR:
2385       return "r<<";
2386
2387     case RROTATE_EXPR:
2388       return "r>>";
2389
2390     case VEC_LSHIFT_EXPR:
2391       return "v<<";
2392
2393     case VEC_RSHIFT_EXPR:
2394       return "v>>";
2395
2396     case PLUS_EXPR:
2397       return "+";
2398
2399     case REDUC_PLUS_EXPR:
2400       return "r+";
2401
2402     case WIDEN_SUM_EXPR:
2403       return "w+";
2404
2405     case WIDEN_MULT_EXPR:
2406       return "w*";
2407
2408     case NEGATE_EXPR:
2409     case MINUS_EXPR:
2410       return "-";
2411
2412     case BIT_NOT_EXPR:
2413       return "~";
2414
2415     case TRUTH_NOT_EXPR:
2416       return "!";
2417
2418     case MULT_EXPR:
2419     case INDIRECT_REF:
2420       return "*";
2421
2422     case ALIGN_INDIRECT_REF:
2423       return "A*";
2424
2425     case MISALIGNED_INDIRECT_REF:
2426       return "M*";
2427
2428     case TRUNC_DIV_EXPR:
2429     case RDIV_EXPR:
2430       return "/";
2431
2432     case CEIL_DIV_EXPR:
2433       return "/[cl]";
2434
2435     case FLOOR_DIV_EXPR:
2436       return "/[fl]";
2437
2438     case ROUND_DIV_EXPR:
2439       return "/[rd]";
2440
2441     case EXACT_DIV_EXPR:
2442       return "/[ex]";
2443
2444     case TRUNC_MOD_EXPR:
2445       return "%";
2446
2447     case CEIL_MOD_EXPR:
2448       return "%[cl]";
2449
2450     case FLOOR_MOD_EXPR:
2451       return "%[fl]";
2452
2453     case ROUND_MOD_EXPR:
2454       return "%[rd]";
2455
2456     case PREDECREMENT_EXPR:
2457       return " --";
2458
2459     case PREINCREMENT_EXPR:
2460       return " ++";
2461
2462     case POSTDECREMENT_EXPR:
2463       return "-- ";
2464
2465     case POSTINCREMENT_EXPR:
2466       return "++ ";
2467
2468     case MAX_EXPR:
2469       return "max";
2470
2471     case MIN_EXPR:
2472       return "min";
2473
2474     default:
2475       return "<<< ??? >>>";
2476     }
2477 }
2478
2479 static const char *
2480 op_symbol (tree op)
2481 {
2482   return op_symbol_1 (TREE_CODE (op));
2483 }
2484
2485 /* Prints the name of a CALL_EXPR.  */
2486
2487 static void
2488 print_call_name (pretty_printer *buffer, tree node)
2489 {
2490   tree op0;
2491
2492   gcc_assert (TREE_CODE (node) == CALL_EXPR);
2493
2494   op0 = TREE_OPERAND (node, 0);
2495
2496   if (TREE_CODE (op0) == NON_LVALUE_EXPR)
2497     op0 = TREE_OPERAND (op0, 0);
2498
2499   switch (TREE_CODE (op0))
2500     {
2501     case VAR_DECL:
2502     case PARM_DECL:
2503       dump_function_name (buffer, op0);
2504       break;
2505
2506     case ADDR_EXPR:
2507     case INDIRECT_REF:
2508     case NOP_EXPR:
2509       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2510       break;
2511
2512     case COND_EXPR:
2513       pp_string (buffer, "(");
2514       dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2515       pp_string (buffer, ") ? ");
2516       dump_generic_node (buffer, TREE_OPERAND (op0, 1), 0, 0, false);
2517       pp_string (buffer, " : ");
2518       dump_generic_node (buffer, TREE_OPERAND (op0, 2), 0, 0, false);
2519       break;
2520
2521     case COMPONENT_REF:
2522       /* The function is a pointer contained in a structure.  */
2523       if (TREE_CODE (TREE_OPERAND (op0, 0)) == INDIRECT_REF ||
2524           TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2525         dump_function_name (buffer, TREE_OPERAND (op0, 1));
2526       else
2527         dump_generic_node (buffer, TREE_OPERAND (op0, 0), 0, 0, false);
2528       /* else
2529          We can have several levels of structures and a function
2530          pointer inside.  This is not implemented yet...  */
2531       /*                  NIY;*/
2532       break;
2533
2534     case ARRAY_REF:
2535       if (TREE_CODE (TREE_OPERAND (op0, 0)) == VAR_DECL)
2536         dump_function_name (buffer, TREE_OPERAND (op0, 0));
2537       else
2538         dump_generic_node (buffer, op0, 0, 0, false);
2539       break;
2540
2541     case SSA_NAME:
2542     case OBJ_TYPE_REF:
2543       dump_generic_node (buffer, op0, 0, 0, false);
2544       break;
2545
2546     default:
2547       NIY;
2548     }
2549 }
2550
2551 /* Parses the string STR and replaces new-lines by '\n', tabs by '\t', ...  */
2552
2553 static void
2554 pretty_print_string (pretty_printer *buffer, const char *str)
2555 {
2556   if (str == NULL)
2557     return;
2558
2559   while (*str)
2560     {
2561       switch (str[0])
2562         {
2563         case '\b':
2564           pp_string (buffer, "\\b");
2565           break;
2566
2567         case '\f':
2568           pp_string (buffer, "\\f");
2569           break;
2570
2571         case '\n':
2572           pp_string (buffer, "\\n");
2573           break;
2574
2575         case '\r':
2576           pp_string (buffer, "\\r");
2577           break;
2578
2579         case '\t':
2580           pp_string (buffer, "\\t");
2581           break;
2582
2583         case '\v':
2584           pp_string (buffer, "\\v");
2585           break;
2586
2587         case '\\':
2588           pp_string (buffer, "\\\\");
2589           break;
2590
2591         case '\"':
2592           pp_string (buffer, "\\\"");
2593           break;
2594
2595         case '\'':
2596           pp_string (buffer, "\\'");
2597           break;
2598
2599           /* No need to handle \0; the loop terminates on \0.  */
2600
2601         case '\1':
2602           pp_string (buffer, "\\1");
2603           break;
2604
2605         case '\2':
2606           pp_string (buffer, "\\2");
2607           break;
2608
2609         case '\3':
2610           pp_string (buffer, "\\3");
2611           break;
2612
2613         case '\4':
2614           pp_string (buffer, "\\4");
2615           break;
2616
2617         case '\5':
2618           pp_string (buffer, "\\5");
2619           break;
2620
2621         case '\6':
2622           pp_string (buffer, "\\6");
2623           break;
2624
2625         case '\7':
2626           pp_string (buffer, "\\7");
2627           break;
2628
2629         default:
2630           pp_character (buffer, str[0]);
2631           break;
2632         }
2633       str++;
2634     }
2635 }
2636
2637 static void
2638 maybe_init_pretty_print (FILE *file)
2639 {
2640   if (!initialized)
2641     {
2642       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2643       pp_needs_newline (&buffer) = true;
2644       initialized = 1;
2645     }
2646
2647   buffer.buffer->stream = file;
2648 }
2649
2650 static void
2651 newline_and_indent (pretty_printer *buffer, int spc)
2652 {
2653   pp_newline (buffer);
2654   INDENT (spc);
2655 }
2656
2657 static void
2658 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2659 {
2660   tree use;
2661   use_operand_p use_p;
2662   def_operand_p def_p;
2663   use_operand_p kill_p;
2664   ssa_op_iter iter;
2665
2666   if (!ssa_operands_active ())
2667     return;
2668
2669   FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
2670     {
2671       pp_string (buffer, "#   ");
2672       dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2673                          spc + 2, flags, false);
2674       pp_string (buffer, " = V_MAY_DEF <");
2675       dump_generic_node (buffer, USE_FROM_PTR (use_p),
2676                          spc + 2, flags, false);
2677       pp_string (buffer, ">;");
2678       newline_and_indent (buffer, spc);
2679     }
2680
2681   FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
2682     {
2683       pp_string (buffer, "#   ");
2684       dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2685                          spc + 2, flags, false);
2686       pp_string (buffer, " = V_MUST_DEF <");
2687       dump_generic_node (buffer, USE_FROM_PTR (kill_p),
2688                          spc + 2, flags, false);
2689       pp_string (buffer, ">;");
2690       newline_and_indent (buffer, spc);
2691     }
2692
2693   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
2694     {
2695       pp_string (buffer, "#   VUSE <");
2696       dump_generic_node (buffer, use, spc + 2, flags, false);
2697       pp_string (buffer, ">;");
2698       newline_and_indent (buffer, spc);
2699     }
2700 }
2701
2702 /* Dumps basic block BB to FILE with details described by FLAGS and
2703    indented by INDENT spaces.  */
2704
2705 void
2706 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2707 {
2708   maybe_init_pretty_print (file);
2709   dump_generic_bb_buff (&buffer, bb, indent, flags);
2710   pp_flush (&buffer);
2711 }
2712
2713 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2714    spaces and details described by flags.  */
2715
2716 static void
2717 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2718 {
2719   edge e;
2720   tree stmt;
2721   edge_iterator ei;
2722
2723   if (flags & TDF_BLOCKS)
2724     {
2725       INDENT (indent);
2726       pp_string (buffer, "# BLOCK ");
2727       pp_decimal_int (buffer, bb->index);
2728       if (bb->frequency)
2729         {
2730           pp_string (buffer, " freq:");
2731           pp_decimal_int (buffer, bb->frequency);
2732         }
2733       if (bb->count)
2734         {
2735           pp_string (buffer, " count:");
2736           pp_widest_integer (buffer, bb->count);
2737         }
2738
2739       if (flags & TDF_LINENO)
2740         {
2741           block_stmt_iterator bsi;
2742
2743           for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2744             if (get_lineno (bsi_stmt (bsi)) != -1)
2745               {
2746                 pp_string (buffer, ", starting at line ");
2747                 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2748                 break;
2749               }
2750         }
2751       newline_and_indent (buffer, indent);
2752
2753       pp_string (buffer, "# PRED:");
2754       pp_write_text_to_stream (buffer);
2755       FOR_EACH_EDGE (e, ei, bb->preds)
2756         if (flags & TDF_SLIM)
2757           {
2758             pp_string (buffer, " ");
2759             if (e->src == ENTRY_BLOCK_PTR)
2760               pp_string (buffer, "ENTRY");
2761             else
2762               pp_decimal_int (buffer, e->src->index);
2763           }
2764         else
2765           dump_edge_info (buffer->buffer->stream, e, 0);
2766       pp_newline (buffer);
2767     }
2768   else
2769     {
2770       stmt = first_stmt (bb);
2771       if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2772         {
2773           INDENT (indent - 2);
2774           pp_string (buffer, "<bb ");
2775           pp_decimal_int (buffer, bb->index);
2776           pp_string (buffer, ">:");
2777           pp_newline (buffer);
2778         }
2779     }
2780   pp_write_text_to_stream (buffer);
2781   check_bb_profile (bb, buffer->buffer->stream);
2782 }
2783
2784 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2785    spaces.  */
2786
2787 static void
2788 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2789 {
2790   edge e;
2791   edge_iterator ei;
2792
2793   INDENT (indent);
2794   pp_string (buffer, "# SUCC:");
2795   pp_write_text_to_stream (buffer);
2796   FOR_EACH_EDGE (e, ei, bb->succs)
2797     if (flags & TDF_SLIM)
2798       {
2799         pp_string (buffer, " ");
2800         if (e->dest == EXIT_BLOCK_PTR)
2801           pp_string (buffer, "EXIT");
2802         else
2803           pp_decimal_int (buffer, e->dest->index);
2804       }
2805     else
2806       dump_edge_info (buffer->buffer->stream, e, 1);
2807   pp_newline (buffer);
2808 }
2809
2810 /* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2811    FLAGS indented by INDENT spaces.  */
2812
2813 static void
2814 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2815 {
2816   tree phi = phi_nodes (bb);
2817   if (!phi)
2818     return;
2819
2820   for (; phi; phi = PHI_CHAIN (phi))
2821     {
2822       if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2823         {
2824           INDENT (indent);
2825           pp_string (buffer, "# ");
2826           dump_generic_node (buffer, phi, indent, flags, false);
2827           pp_newline (buffer);
2828         }
2829     }
2830 }
2831
2832 /* Dump jump to basic block BB that is represented implicitly in the cfg
2833    to BUFFER.  */
2834
2835 static void
2836 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2837 {
2838   tree stmt;
2839
2840   stmt = first_stmt (bb);
2841
2842   pp_string (buffer, "goto <bb ");
2843   pp_decimal_int (buffer, bb->index);
2844   pp_string (buffer, ">");
2845   if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2846     {
2847       pp_string (buffer, " (");
2848       dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2849       pp_string (buffer, ")");
2850     }
2851   pp_semicolon (buffer);
2852 }
2853
2854 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2855    by INDENT spaces, with details given by FLAGS.  */
2856
2857 static void
2858 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2859                      int flags)
2860 {
2861   edge e;
2862   edge_iterator ei;
2863
2864   /* If there is a fallthru edge, we may need to add an artificial goto to the
2865      dump.  */
2866   FOR_EACH_EDGE (e, ei, bb->succs)
2867     if (e->flags & EDGE_FALLTHRU)
2868       break;
2869   if (e && e->dest != bb->next_bb)
2870     {
2871       INDENT (indent);
2872
2873       if ((flags & TDF_LINENO)
2874 #ifdef USE_MAPPED_LOCATION
2875           && e->goto_locus != UNKNOWN_LOCATION
2876 #else
2877           && e->goto_locus
2878 #endif
2879           )
2880         {
2881           expanded_location goto_xloc;
2882 #ifdef USE_MAPPED_LOCATION
2883           goto_xloc = expand_location (e->goto_locus);
2884 #else
2885           goto_xloc = *e->goto_locus;
2886 #endif
2887           pp_character (buffer, '[');
2888           if (goto_xloc.file)
2889             {
2890               pp_string (buffer, goto_xloc.file);
2891               pp_string (buffer, " : ");
2892             }
2893           pp_decimal_int (buffer, goto_xloc.line);
2894           pp_string (buffer, "] ");
2895         }
2896
2897       pp_cfg_jump (buffer, e->dest);
2898       pp_newline (buffer);
2899     }
2900 }
2901
2902 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2903    indented by INDENT spaces.  */
2904
2905 static void
2906 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2907                       int indent, int flags)
2908 {
2909   block_stmt_iterator bsi;
2910   tree stmt;
2911   int label_indent = indent - 2;
2912
2913   if (label_indent < 0)
2914     label_indent = 0;
2915
2916   dump_bb_header (buffer, bb, indent, flags);
2917
2918   dump_phi_nodes (buffer, bb, indent, flags);
2919
2920   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2921     {
2922       int curr_indent;
2923
2924       stmt = bsi_stmt (bsi);
2925
2926       curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
2927
2928       INDENT (curr_indent);
2929       dump_generic_node (buffer, stmt, curr_indent, flags, true);
2930       pp_newline (buffer);
2931     }
2932
2933   dump_implicit_edges (buffer, bb, indent, flags);
2934
2935   if (flags & TDF_BLOCKS)
2936     dump_bb_end (buffer, bb, indent, flags);
2937 }