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