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   print_generic_expr (stderr, t, TDF_VOPS|TDF_UID|TDF_CHAIN);
 105   fprintf (stderr, "\n");
 106 }
 107
 108 /* Prints declaration DECL to the FILE with details specified by FLAGS.  */
 109 void
 110 print_generic_decl (FILE *file, tree decl, int flags)
 111 {
 112   maybe_init_pretty_print (file);
 113   print_declaration (&buffer, decl, 2, flags);
 114   pp_write_text_to_stream (&buffer);
 115 }
 116
 117 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 118    to show in the dump.  See TDF_* in tree.h.  */
 119
 120 void
 121 print_generic_stmt (FILE *file, tree t, int flags)
 122 {
 123   maybe_init_pretty_print (file);
 124   dump_generic_node (&buffer, t, 0, flags, true);
 125   pp_flush (&buffer);
 126 }
 127
 128 /* Print tree T, and its successors, on file FILE.  FLAGS specifies details
 129    to show in the dump.  See TDF_* in tree.h.  The output is indented by
 130    INDENT spaces.  */
 131
 132 void
 133 print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)
 134 {
 135   int i;
 136
 137   maybe_init_pretty_print (file);
 138
 139   for (i = 0; i < indent; i++)
 140     pp_space (&buffer);
 141   dump_generic_node (&buffer, t, indent, flags, true);
 142   pp_flush (&buffer);
 143 }
 144
 145 /* Print a single expression T on file FILE.  FLAGS specifies details to show
 146    in the dump.  See TDF_* in tree.h.  */
 147
 148 void
 149 print_generic_expr (FILE *file, tree t, int flags)
 150 {
 151   maybe_init_pretty_print (file);
 152   dump_generic_node (&buffer, t, 0, flags, false);
 153 }
 154
 155 /* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set
 156    in FLAGS.  */
 157
 158 static void
 159 dump_decl_name (pretty_printer *buffer, tree node, int flags)
 160 {
 161   tree t = node;
 162
 163   while (t)
 164     {
 165       if (DECL_NAME (t))
 166         pp_tree_identifier (buffer, DECL_NAME (t));
 167
 168       if ((flags & TDF_UID)
 169           || DECL_NAME (t) == NULL_TREE)
 170         {
 171           if (TREE_CODE (t) == LABEL_DECL
 172               && LABEL_DECL_UID (t) != -1)
 173             pp_printf (buffer, "L." HOST_WIDE_INT_PRINT_DEC,
 174                 LABEL_DECL_UID (t));
 175           else
 176             {
 177               char c = TREE_CODE (t) == CONST_DECL ? 'C' : 'D';
 178               pp_printf (buffer, "%c.%u", c, DECL_UID (t));
 179             }
 180         }
 181
 182       if (flags & TDF_CHAIN)
 183         {
 184           t = TREE_CHAIN (t);
 185           pp_string (buffer, " ");
 186         }
 187       else
 188         t = NULL_TREE;
 189     }
 190 }
 191
 192 /* Like the above, but used for pretty printing function calls.  */
 193
 194 static void
 195 dump_function_name (pretty_printer *buffer, tree node)
 196 {
 197   if (DECL_NAME (node))
 198     PRINT_FUNCTION_NAME (node);
 199   else
 200     dump_decl_name (buffer, node, 0);
 201 }
 202
 203 /* Dump a function declaration.  NODE is the FUNCTION_TYPE.  BUFFER, SPC and
 204    FLAGS are as in dump_generic_node.  */
 205
 206 static void
 207 dump_function_declaration (pretty_printer *buffer, tree node,
 208                            int spc, int flags)
 209 {
 210   bool wrote_arg = false;
 211   tree arg;
 212
 213   pp_space (buffer);
 214   pp_character (buffer, '(');
 215
 216   /* Print the argument types.  The last element in the list is a VOID_TYPE.
 217      The following avoids printing the last element.  */
 218   arg = TYPE_ARG_TYPES (node);
 219   while (arg && TREE_CHAIN (arg) && arg != error_mark_node)
 220     {
 221       wrote_arg = true;
 222       dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);
 223       arg = TREE_CHAIN (arg);
 224       if (TREE_CHAIN (arg) && TREE_CODE (TREE_CHAIN (arg)) == TREE_LIST)
 225         {
 226           pp_character (buffer, ',');
 227           pp_space (buffer);
 228         }
 229     }
 230
 231   if (!wrote_arg)
 232     pp_string (buffer, "void");
 233
 234   pp_character (buffer, ')');
 235 }
 236
 237 /* Dump the domain associated with an array.  */
 238
 239 static void
 240 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
 241 {
 242   pp_character (buffer, '[');
 243   if (domain)
 244     {
 245       tree min = TYPE_MIN_VALUE (domain);
 246       tree max = TYPE_MAX_VALUE (domain);
 247
 248       if (min && max
 249           && integer_zerop (min)
 250           && host_integerp (max, 0))
 251         pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);
 252       else
 253         {
 254           if (min)
 255             dump_generic_node (buffer, min, spc, flags, false);
 256           pp_character (buffer, ':');
 257           if (max)
 258             dump_generic_node (buffer, max, spc, flags, false);
 259         }
 260     }
 261   else
 262     pp_string (buffer, "<unknown>");
 263   pp_character (buffer, ']');
 264 }
 265
 266
 267 /* Dump OpenMP clause CLAUSE.  BUFFER, CLAUSE, SPC and FLAGS are as in
 268    dump_generic_node.  */
 269
 270 static void
 271 dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
 272 {
 273   const char *name;
 274
 275   switch (OMP_CLAUSE_CODE (clause))
 276     {
 277     case OMP_CLAUSE_PRIVATE:
 278       name = "private";
 279       goto print_remap;
 280     case OMP_CLAUSE_SHARED:
 281       name = "shared";
 282       goto print_remap;
 283     case OMP_CLAUSE_FIRSTPRIVATE:
 284       name = "firstprivate";
 285       goto print_remap;
 286     case OMP_CLAUSE_LASTPRIVATE:
 287       name = "lastprivate";
 288       goto print_remap;
 289     case OMP_CLAUSE_COPYIN:
 290       name = "copyin";
 291       goto print_remap;
 292     case OMP_CLAUSE_COPYPRIVATE:
 293       name = "copyprivate";
 294       goto print_remap;
 295   print_remap:
 296       pp_string (buffer, name);
 297       pp_character (buffer, '(');
 298       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 299           spc, flags, false);
 300       pp_character (buffer, ')');
 301       break;
 302
 303     case OMP_CLAUSE_REDUCTION:
 304       pp_string (buffer, "reduction(");
 305       pp_string (buffer, op_symbol_1 (OMP_CLAUSE_REDUCTION_CODE (clause)));
 306       pp_character (buffer, ':');
 307       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 308           spc, flags, false);
 309       pp_character (buffer, ')');
 310       break;
 311
 312     case OMP_CLAUSE_IF:
 313       pp_string (buffer, "if(");
 314       dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
 315           spc, flags, false);
 316       pp_character (buffer, ')');
 317       break;
 318
 319     case OMP_CLAUSE_NUM_THREADS:
 320       pp_string (buffer, "num_threads(");
 321       dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
 322           spc, flags, false);
 323       pp_character (buffer, ')');
 324       break;
 325
 326     case OMP_CLAUSE_NOWAIT:
 327       pp_string (buffer, "nowait");
 328       break;
 329     case OMP_CLAUSE_ORDERED:
 330       pp_string (buffer, "ordered");
 331       break;
 332
 333     case OMP_CLAUSE_DEFAULT:
 334       pp_string (buffer, "default(");
 335       switch (OMP_CLAUSE_DEFAULT_KIND (clause))
 336         {
 337       case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
 338         break;
 339       case OMP_CLAUSE_DEFAULT_SHARED:
 340         pp_string (buffer, "shared");
 341         break;
 342       case OMP_CLAUSE_DEFAULT_NONE:
 343         pp_string (buffer, "none");
 344         break;
 345       case OMP_CLAUSE_DEFAULT_PRIVATE:
 346         pp_string (buffer, "private");
 347         break;
 348       default:
 349         gcc_unreachable ();
 350         }
 351       pp_character (buffer, ')');
 352       break;
 353
 354     case OMP_CLAUSE_SCHEDULE:
 355       pp_string (buffer, "schedule(");
 356       switch (OMP_CLAUSE_SCHEDULE_KIND (clause))
 357         {
 358       case OMP_CLAUSE_SCHEDULE_STATIC:
 359         pp_string (buffer, "static");
 360         break;
 361       case OMP_CLAUSE_SCHEDULE_DYNAMIC:
 362         pp_string (buffer, "dynamic");
 363         break;
 364       case OMP_CLAUSE_SCHEDULE_GUIDED:
 365         pp_string (buffer, "guided");
 366         break;
 367       case OMP_CLAUSE_SCHEDULE_RUNTIME:
 368         pp_string (buffer, "runtime");
 369         break;
 370       default:
 371         gcc_unreachable ();
 372         }
 373       if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
 374         {
 375           pp_character (buffer, ',');
 376           dump_generic_node (buffer,
 377               OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
 378               spc, flags, false);
 379         }
 380       pp_character (buffer, ')');
 381       break;
 382
 383     default:
 384       /* Should never happen.  */
 385       dump_generic_node (buffer, clause, spc, flags, false);
 386       break;
 387     }
 388 }
 389
 390
 391 /* Dump the list of OpenMP clauses.  BUFFER, SPC and FLAGS are as in
 392    dump_generic_node.  */
 393
 394 static void
 395 dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)
 396 {
 397   if (clause == NULL)
 398     return;
 399
 400   pp_space (buffer);
 401   while (1)
 402     {
 403       dump_omp_clause (buffer, clause, spc, flags);
 404       clause = OMP_CLAUSE_CHAIN (clause);
 405       if (clause == NULL)
 406         return;
 407       pp_space (buffer);
 408     }
 409 }
 410
 411
 412 /* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of indent.
 413    FLAGS specifies details to show in the dump (see TDF_* in tree.h).  If
 414    IS_STMT is true, the object printed is considered to be a statement
 415    and it is terminated by ';' if appropriate.  */
 416
 417 int
 418 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 419                    bool is_stmt)
 420 {
 421   tree type;
 422   tree op0, op1;
 423   const char *str;
 424   bool is_expr;
 425
 426   if (node == NULL_TREE)
 427     return spc;
 428
 429   is_expr = EXPR_P (node);
 430
 431   if (TREE_CODE (node) != ERROR_MARK
 432       && is_gimple_stmt (node)
 433       && (flags & TDF_VOPS)
 434       && stmt_ann (node)
 435       && TREE_CODE (node) != PHI_NODE)
 436     dump_vops (buffer, node, spc, flags);
 437
 438   if (is_stmt && (flags & TDF_STMTADDR))
 439     pp_printf (buffer, "<&%p> ", (void *)node);
 440
 441   if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))
 442     {
 443       expanded_location xloc = expand_location (EXPR_LOCATION (node));
 444       pp_character (buffer, '[');
 445       if (xloc.file)
 446         {
 447           pp_string (buffer, xloc.file);
 448           pp_string (buffer, " : ");
 449         }
 450       pp_decimal_int (buffer, xloc.line);
 451       pp_string (buffer, "] ");
 452     }
 453
 454   switch (TREE_CODE (node))
 455     {
 456     case ERROR_MARK:
 457       pp_string (buffer, "<<< error >>>");
 458       break;
 459
 460     case IDENTIFIER_NODE:
 461       pp_tree_identifier (buffer, node);
 462       break;
 463
 464     case TREE_LIST:
 465       while (node && node != error_mark_node)
 466         {
 467           if (TREE_PURPOSE (node))
 468             {
 469               dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);
 470               pp_space (buffer);
 471             }
 472           dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);
 473           node = TREE_CHAIN (node);
 474           if (node && TREE_CODE (node) == TREE_LIST)
 475             {
 476               pp_character (buffer, ',');
 477               pp_space (buffer);
 478             }
 479         }
 480       break;
 481
 482     case TREE_BINFO:
 483       dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);
 484
 485     case TREE_VEC:
 486       {
 487         size_t i;
 488         if (TREE_VEC_LENGTH (node) > 0)
 489           {
 490             size_t len = TREE_VEC_LENGTH (node);
 491             for (i = 0; i < len - 1; i++)
 492               {
 493                 dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
 494                                    false);
 495                 pp_character (buffer, ',');
 496                 pp_space (buffer);
 497               }
 498             dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
 499                                flags, false);
 500           }
 501       }
 502       break;
 503
 504     case VOID_TYPE:
 505     case INTEGER_TYPE:
 506     case REAL_TYPE:
 507     case COMPLEX_TYPE:
 508     case VECTOR_TYPE:
 509     case ENUMERAL_TYPE:
 510     case BOOLEAN_TYPE:
 511       {
 512         unsigned int quals = TYPE_QUALS (node);
 513         enum tree_code_class class;
 514
 515         if (quals & TYPE_QUAL_CONST)
 516           pp_string (buffer, "const ");
 517         else if (quals & TYPE_QUAL_VOLATILE)
 518           pp_string (buffer, "volatile ");
 519         else if (quals & TYPE_QUAL_RESTRICT)
 520           pp_string (buffer, "restrict ");
 521
 522         class = TREE_CODE_CLASS (TREE_CODE (node));
 523
 524         if (class == tcc_declaration)
 525           {
 526             if (DECL_NAME (node))
 527               dump_decl_name (buffer, node, flags);
 528             else
 529               pp_string (buffer, "<unnamed type decl>");
 530           }
 531         else if (class == tcc_type)
 532           {
 533             if (TYPE_NAME (node))
 534               {
 535                 if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
 536                   pp_tree_identifier (buffer, TYPE_NAME (node));
 537                 else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
 538                          && DECL_NAME (TYPE_NAME (node)))
 539                   dump_decl_name (buffer, TYPE_NAME (node), flags);
 540                 else
 541                   pp_string (buffer, "<unnamed type>");
 542               }
 543             else if (TREE_CODE (node) == VECTOR_TYPE)
 544               {
 545                 pp_string (buffer, "vector ");
 546                 dump_generic_node (buffer, TREE_TYPE (node),
 547                                    spc, flags, false);
 548               }
 549             else
 550               pp_string (buffer, "<unnamed type>");
 551           }
 552         break;
 553       }
 554
 555     case POINTER_TYPE:
 556     case REFERENCE_TYPE:
 557       str = (TREE_CODE (node) == POINTER_TYPE ? "*" : "&");
 558
 559       if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE)
 560         {
 561           tree fnode = TREE_TYPE (node);
 562
 563           dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
 564           pp_space (buffer);
 565           pp_character (buffer, '(');
 566           pp_string (buffer, str);
 567           if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
 568             dump_decl_name (buffer, TYPE_NAME (node), flags);
 569           else
 570             pp_printf (buffer, "<T%x>", TYPE_UID (node));
 571
 572           pp_character (buffer, ')');
 573           dump_function_declaration (buffer, fnode, spc, flags);
 574         }
 575       else
 576         {
 577           unsigned int quals = TYPE_QUALS (node);
 578
 579           dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 580           pp_space (buffer);
 581           pp_string (buffer, str);
 582
 583           if (quals & TYPE_QUAL_CONST)
 584             pp_string (buffer, " const");
 585           else if (quals & TYPE_QUAL_VOLATILE)
 586             pp_string (buffer,  "volatile");
 587           else if (quals & TYPE_QUAL_RESTRICT)
 588             pp_string (buffer, " restrict");
 589
 590           if (TYPE_REF_CAN_ALIAS_ALL (node))
 591             pp_string (buffer, " {ref-all}");
 592         }
 593       break;
 594
 595     case OFFSET_TYPE:
 596       NIY;
 597       break;
 598
 599     case METHOD_TYPE:
 600       dump_decl_name (buffer, TYPE_NAME (TYPE_METHOD_BASETYPE (node)), flags);
 601       pp_string (buffer, "::");
 602       break;
 603
 604     case TARGET_MEM_REF:
 605       {
 606         const char *sep = "";
 607         tree tmp;
 608
 609         pp_string (buffer, "MEM[");
 610
 611         tmp = TMR_SYMBOL (node);
 612         if (tmp)
 613           {
 614             pp_string (buffer, sep);
 615             sep = ", ";
 616             pp_string (buffer, "symbol: ");
 617             dump_generic_node (buffer, tmp, spc, flags, false);
 618           }
 619         tmp = TMR_BASE (node);
 620         if (tmp)
 621           {
 622             pp_string (buffer, sep);
 623             sep = ", ";
 624             pp_string (buffer, "base: ");
 625             dump_generic_node (buffer, tmp, spc, flags, false);
 626           }
 627         tmp = TMR_INDEX (node);
 628         if (tmp)
 629           {
 630             pp_string (buffer, sep);
 631             sep = ", ";
 632             pp_string (buffer, "index: ");
 633             dump_generic_node (buffer, tmp, spc, flags, false);
 634           }
 635         tmp = TMR_STEP (node);
 636         if (tmp)
 637           {
 638             pp_string (buffer, sep);
 639             sep = ", ";
 640             pp_string (buffer, "step: ");
 641             dump_generic_node (buffer, tmp, spc, flags, false);
 642           }
 643         tmp = TMR_OFFSET (node);
 644         if (tmp)
 645           {
 646             pp_string (buffer, sep);
 647             sep = ", ";
 648             pp_string (buffer, "offset: ");
 649             dump_generic_node (buffer, tmp, spc, flags, false);
 650           }
 651         pp_string (buffer, "]");
 652         if (flags & TDF_DETAILS)
 653           {
 654             pp_string (buffer, "{");
 655             dump_generic_node (buffer, TMR_ORIGINAL (node), spc, flags,
 656                                false);
 657             pp_string (buffer, "}");
 658           }
 659       }
 660       break;
 661
 662     case ARRAY_TYPE:
 663       {
 664         tree tmp;
 665
 666         /* Print the innermost component type.  */
 667         for (tmp = TREE_TYPE (node); TREE_CODE (tmp) == ARRAY_TYPE;
 668              tmp = TREE_TYPE (tmp))
 669           ;
 670         dump_generic_node (buffer, tmp, spc, flags, false);
 671
 672         /* Print the dimensions.  */
 673         for (tmp = node; TREE_CODE (tmp) == ARRAY_TYPE; tmp = TREE_TYPE (tmp))
 674           dump_array_domain (buffer, TYPE_DOMAIN (tmp), spc, flags);
 675         break;
 676       }
 677
 678     case RECORD_TYPE:
 679     case UNION_TYPE:
 680     case QUAL_UNION_TYPE:
 681       /* Print the name of the structure.  */
 682       if (TREE_CODE (node) == RECORD_TYPE)
 683         pp_string (buffer, "struct ");
 684       else if (TREE_CODE (node) == UNION_TYPE)
 685         pp_string (buffer, "union ");
 686
 687       if (TYPE_NAME (node))
 688         dump_generic_node (buffer, TYPE_NAME (node), spc, flags, false);
 689       else
 690         print_struct_decl (buffer, node, spc, flags);
 691       break;
 692
 693     case LANG_TYPE:
 694       NIY;
 695       break;
 696
 697     case INTEGER_CST:
 698       if (TREE_CODE (TREE_TYPE (node)) == POINTER_TYPE)
 699         {
 700           /* In the case of a pointer, one may want to divide by the
 701              size of the pointed-to type.  Unfortunately, this not
 702              straightforward.  The C front-end maps expressions
 703
 704              (int *) 5
 705              int *p; (p + 5)
 706
 707              in such a way that the two INTEGER_CST nodes for "5" have
 708              different values but identical types.  In the latter
 709              case, the 5 is multiplied by sizeof (int) in c-common.c
 710              (pointer_int_sum) to convert it to a byte address, and
 711              yet the type of the node is left unchanged.  Argh.  What
 712              is consistent though is that the number value corresponds
 713              to bytes (UNITS) offset.
 714
 715              NB: Neither of the following divisors can be trivially
 716              used to recover the original literal:
 717
 718              TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (node)))
 719              TYPE_PRECISION (TREE_TYPE (TREE_TYPE (node)))  */
 720           pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
 721           pp_string (buffer, "B"); /* pseudo-unit */
 722         }
 723       else if (! host_integerp (node, 0))
 724         {
 725           tree val = node;
 726
 727           if (tree_int_cst_sgn (val) < 0)
 728             {
 729               pp_character (buffer, '-');
 730               val = build_int_cst_wide (NULL_TREE,
 731                                         -TREE_INT_CST_LOW (val),
 732                                         ~TREE_INT_CST_HIGH (val)
 733                                         + !TREE_INT_CST_LOW (val));
 734             }
 735           /* Would "%x%0*x" or "%x%*0x" get zero-padding on all
 736              systems?  */
 737           {
 738             static char format[10]; /* "%x%09999x\0" */
 739             if (!format[0])
 740               sprintf (format, "%%x%%0%dx", HOST_BITS_PER_INT / 4);
 741             sprintf (pp_buffer (buffer)->digit_buffer, format,
 742                      TREE_INT_CST_HIGH (val),
 743                      TREE_INT_CST_LOW (val));
 744             pp_string (buffer, pp_buffer (buffer)->digit_buffer);
 745           }
 746         }
 747       else
 748         pp_wide_integer (buffer, TREE_INT_CST_LOW (node));
 749       break;
 750
 751     case REAL_CST:
 752       /* Code copied from print_node.  */
 753       {
 754         REAL_VALUE_TYPE d;
 755         if (TREE_OVERFLOW (node))
 756           pp_string (buffer, " overflow");
 757
 758 #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC)
 759         d = TREE_REAL_CST (node);
 760         if (REAL_VALUE_ISINF (d))
 761           pp_string (buffer, " Inf");
 762         else if (REAL_VALUE_ISNAN (d))
 763           pp_string (buffer, " Nan");
 764         else
 765           {
 766             char string[100];
 767             real_to_decimal (string, &d, sizeof (string), 0, 1);
 768             pp_string (buffer, string);
 769           }
 770 #else
 771         {
 772           HOST_WIDE_INT i;
 773           unsigned char *p = (unsigned char *) &TREE_REAL_CST (node);
 774           pp_string (buffer, "0x");
 775           for (i = 0; i < sizeof TREE_REAL_CST (node); i++)
 776             output_formatted_integer (buffer, "%02x", *p++);
 777         }
 778 #endif
 779         break;
 780       }
 781
 782     case COMPLEX_CST:
 783       pp_string (buffer, "__complex__ (");
 784       dump_generic_node (buffer, TREE_REALPART (node), spc, flags, false);
 785       pp_string (buffer, ", ");
 786       dump_generic_node (buffer, TREE_IMAGPART (node), spc, flags, false);
 787       pp_string (buffer, ")");
 788       break;
 789
 790     case STRING_CST:
 791       pp_string (buffer, "\"");
 792       pretty_print_string (buffer, TREE_STRING_POINTER (node));
 793       pp_string (buffer, "\"");
 794       break;
 795
 796     case VECTOR_CST:
 797       {
 798         tree elt;
 799         pp_string (buffer, "{ ");
 800         for (elt = TREE_VECTOR_CST_ELTS (node); elt; elt = TREE_CHAIN (elt))
 801           {
 802             dump_generic_node (buffer, TREE_VALUE (elt), spc, flags, false);
 803             if (TREE_CHAIN (elt))
 804               pp_string (buffer, ", ");
 805           }
 806         pp_string (buffer, " }");
 807       }
 808       break;
 809
 810     case FUNCTION_TYPE:
 811       break;
 812
 813     case FUNCTION_DECL:
 814     case CONST_DECL:
 815       dump_decl_name (buffer, node, flags);
 816       break;
 817
 818     case LABEL_DECL:
 819       if (DECL_NAME (node))
 820         dump_decl_name (buffer, node, flags);
 821       else if (LABEL_DECL_UID (node) != -1)
 822         pp_printf (buffer, "<L" HOST_WIDE_INT_PRINT_DEC ">",
 823                    LABEL_DECL_UID (node));
 824       else
 825         pp_printf (buffer, "<D%u>", DECL_UID (node));
 826       break;
 827
 828     case TYPE_DECL:
 829       if (DECL_IS_BUILTIN (node))
 830         {
 831           /* Don't print the declaration of built-in types.  */
 832           break;
 833         }
 834       if (DECL_NAME (node))
 835         dump_decl_name (buffer, node, flags);
 836       else
 837         {
 838           if ((TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
 839                || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
 840               && TYPE_METHODS (TREE_TYPE (node)))
 841             {
 842               /* The type is a c++ class: all structures have at least
 843                  4 methods.  */
 844               pp_string (buffer, "class ");
 845               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 846             }
 847           else
 848             {
 849               pp_string (buffer,
 850                          (TREE_CODE (TREE_TYPE (node)) == UNION_TYPE
 851                           ? "union" : "struct "));
 852               dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
 853             }
 854         }
 855       break;
 856
 857     case TYPE_MEMORY_TAG:
 858     case NAME_MEMORY_TAG:
 859     case STRUCT_FIELD_TAG:
 860     case VAR_DECL:
 861     case PARM_DECL:
 862     case FIELD_DECL:
 863     case NAMESPACE_DECL:
 864       dump_decl_name (buffer, node, flags);
 865       break;
 866
 867     case RESULT_DECL:
 868       pp_string (buffer, "<retval>");
 869       break;
 870
 871     case COMPONENT_REF:
 872       op0 = TREE_OPERAND (node, 0);
 873       str = ".";
 874       if (TREE_CODE (op0) == INDIRECT_REF)
 875         {
 876           op0 = TREE_OPERAND (op0, 0);
 877           str = "->";
 878         }
 879       if (op_prio (op0) < op_prio (node))
 880         pp_character (buffer, '(');
 881       dump_generic_node (buffer, op0, spc, flags, false);
 882       if (op_prio (op0) < op_prio (node))
 883         pp_character (buffer, ')');
 884       pp_string (buffer, str);
 885       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 886
 887       if (TREE_CODE (op0) != VALUE_HANDLE)
 888         {
 889           op0 = component_ref_field_offset (node);
 890           if (op0 && TREE_CODE (op0) != INTEGER_CST)
 891             {
 892               pp_string (buffer, "{off: ");
 893               dump_generic_node (buffer, op0, spc, flags, false);
 894               pp_character (buffer, '}');
 895             }
 896         }
 897       break;
 898
 899     case BIT_FIELD_REF:
 900       pp_string (buffer, "BIT_FIELD_REF <");
 901       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
 902       pp_string (buffer, ", ");
 903       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 904       pp_string (buffer, ", ");
 905       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
 906       pp_string (buffer, ">");
 907       break;
 908
 909     case ARRAY_REF:
 910     case ARRAY_RANGE_REF:
 911       op0 = TREE_OPERAND (node, 0);
 912       if (op_prio (op0) < op_prio (node))
 913         pp_character (buffer, '(');
 914       dump_generic_node (buffer, op0, spc, flags, false);
 915       if (op_prio (op0) < op_prio (node))
 916         pp_character (buffer, ')');
 917       pp_character (buffer, '[');
 918       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 919       if (TREE_CODE (node) == ARRAY_RANGE_REF)
 920         pp_string (buffer, " ...");
 921       pp_character (buffer, ']');
 922
 923       op0 = array_ref_low_bound (node);
 924       op1 = array_ref_element_size (node);
 925
 926       if (!integer_zerop (op0)
 927           || (TYPE_SIZE_UNIT (TREE_TYPE (node))
 928               && !operand_equal_p (op1, TYPE_SIZE_UNIT (TREE_TYPE (node)), 0)))
 929         {
 930           pp_string (buffer, "{lb: ");
 931           dump_generic_node (buffer, op0, spc, flags, false);
 932           pp_string (buffer, " sz: ");
 933           dump_generic_node (buffer, op1, spc, flags, false);
 934           pp_character (buffer, '}');
 935         }
 936       break;
 937
 938     case CONSTRUCTOR:
 939       {
 940         unsigned HOST_WIDE_INT ix;
 941         tree field, val;
 942         bool is_struct_init = FALSE;
 943         pp_character (buffer, '{');
 944         if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
 945             || TREE_CODE (TREE_TYPE (node)) == UNION_TYPE)
 946           is_struct_init = TRUE;
 947         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (node), ix, field, val)
 948           {
 949             if (field && is_struct_init)
 950               {
 951                 pp_character (buffer, '.');
 952                 dump_generic_node (buffer, field, spc, flags, false);
 953                 pp_string (buffer, "=");
 954               }
 955             if (val && TREE_CODE (val) == ADDR_EXPR)
 956               if (TREE_CODE (TREE_OPERAND (val, 0)) == FUNCTION_DECL)
 957                 val = TREE_OPERAND (val, 0);
 958             if (val && TREE_CODE (val) == FUNCTION_DECL)
 959                 dump_decl_name (buffer, val, flags);
 960             else
 961                 dump_generic_node (buffer, val, spc, flags, false);
 962             if (ix != VEC_length (constructor_elt, CONSTRUCTOR_ELTS (node)) - 1)
 963               {
 964                 pp_character (buffer, ',');
 965                 pp_space (buffer);
 966               }
 967           }
 968         pp_character (buffer, '}');
 969       }
 970       break;
 971
 972     case COMPOUND_EXPR:
 973       {
 974         tree *tp;
 975         if (flags & TDF_SLIM)
 976           {
 977             pp_string (buffer, "<COMPOUND_EXPR>");
 978             break;
 979           }
 980
 981         dump_generic_node (buffer, TREE_OPERAND (node, 0),
 982                            spc, flags, !(flags & TDF_SLIM));
 983         if (flags & TDF_SLIM)
 984           newline_and_indent (buffer, spc);
 985         else
 986           {
 987             pp_character (buffer, ',');
 988             pp_space (buffer);
 989           }
 990
 991         for (tp = &TREE_OPERAND (node, 1);
 992              TREE_CODE (*tp) == COMPOUND_EXPR;
 993              tp = &TREE_OPERAND (*tp, 1))
 994           {
 995             dump_generic_node (buffer, TREE_OPERAND (*tp, 0),
 996                                spc, flags, !(flags & TDF_SLIM));
 997             if (flags & TDF_SLIM)
 998               newline_and_indent (buffer, spc);
 999             else
1000               {
1001                 pp_character (buffer, ',');
1002                 pp_space (buffer);
1003               }
1004           }
1005
1006         dump_generic_node (buffer, *tp, spc, flags, !(flags & TDF_SLIM));
1007       }
1008       break;
1009
1010     case STATEMENT_LIST:
1011       {
1012         tree_stmt_iterator si;
1013         bool first = true;
1014
1015         if (flags & TDF_SLIM)
1016           {
1017             pp_string (buffer, "<STATEMENT_LIST>");
1018             break;
1019           }
1020
1021         for (si = tsi_start (node); !tsi_end_p (si); tsi_next (&si))
1022           {
1023             if (!first)
1024               newline_and_indent (buffer, spc);
1025             else
1026               first = false;
1027             dump_generic_node (buffer, tsi_stmt (si), spc, flags, true);
1028           }
1029       }
1030       break;
1031
1032     case MODIFY_EXPR:
1033     case INIT_EXPR:
1034       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1035       pp_space (buffer);
1036       pp_character (buffer, '=');
1037       pp_space (buffer);
1038       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1039       break;
1040
1041     case TARGET_EXPR:
1042       pp_string (buffer, "TARGET_EXPR <");
1043       dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
1044       pp_character (buffer, ',');
1045       pp_space (buffer);
1046       dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
1047       pp_character (buffer, '>');
1048       break;
1049
1050     case DECL_EXPR:
1051       print_declaration (buffer, DECL_EXPR_DECL (node), spc, flags);
1052       is_stmt = false;
1053       break;
1054
1055     case COND_EXPR:
1056       if (TREE_TYPE (node) == NULL || TREE_TYPE (node) == void_type_node)
1057         {
1058           pp_string (buffer, "if (");
1059           dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
1060           pp_character (buffer, ')');
1061           /* The lowered cond_exprs should always be printed in full.  */
1062           if (COND_EXPR_THEN (node)
1063               && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
1064                   || TREE_CODE (COND_EXPR_THEN (node)) == GOTO_EXPR)
1065               && COND_EXPR_ELSE (node)
1066               && (IS_EMPTY_STMT (COND_EXPR_ELSE (node))
1067                   || TREE_CODE (COND_EXPR_ELSE (node)) == GOTO_EXPR))
1068             {
1069               pp_space (buffer);
1070               dump_generic_node (buffer, COND_EXPR_THEN (node), 0, flags, true);
1071               pp_string (buffer, " else ");
1072               dump_generic_node (buffer, COND_EXPR_ELSE (node), 0, flags, true);
1073             }
1074           else if (!(flags & TDF_SLIM))
1075             {
1076               /* Output COND_EXPR_THEN.  */
1077               if (COND_EXPR_THEN (node))
1078                 {
1079                   newline_and_indent (buffer, spc+2);
1080                   pp_character (buffer, '{');
1081                   newline_and_indent (buffer, spc+4);
1082                   dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
1083                                      flags, true);
1084                   newline_and_indent (buffer, spc+2);
1085                   pp_character (buffer, '}');
1086                 }
1087
1088               /* Output COND_EXPR_ELSE.  */
1089               if (COND_EXPR_ELSE (node))
1090                 {
1091                   newline_and_indent (buffer, spc);
1092                   pp_string (buffer, "else");
1093                   newline_and_indent (buffer, spc+2);
1094                   pp_character (buffer, '{');
1095                   newline_and_indent (buffer, spc+4);
1096                   dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
1097                                      flags, true);
1098                   newline_and_indent (buffer, spc+2);
1099                   pp_character (buffer, '}');
1100                 }
1101             }
1102           is_expr = false;
1103         }
1104       else
1105         {
1106           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1107           pp_space (buffer);
1108           pp_character (buffer, '?');
1109           pp_space (buffer);
1110           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1111           pp_space (buffer);
1112           pp_character (buffer, ':');
1113           pp_space (buffer);
1114           dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1115         }
1116       break;
1117
1118     case BIND_EXPR:
1119       pp_character (buffer, '{');
1120       if (!(flags & TDF_SLIM))
1121         {
1122           if (BIND_EXPR_VARS (node))
1123             {
1124               pp_newline (buffer);
1125
1126               for (op0 = BIND_EXPR_VARS (node); op0; op0 = TREE_CHAIN (op0))
1127                 {
1128                   print_declaration (buffer, op0, spc+2, flags);
1129                   pp_newline (buffer);
1130                 }
1131             }
1132
1133           newline_and_indent (buffer, spc+2);
1134           dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
1135           newline_and_indent (buffer, spc);
1136           pp_character (buffer, '}');
1137         }
1138       is_expr = false;
1139       break;
1140
1141     case CALL_EXPR:
1142       print_call_name (buffer, node);
1143
1144       /* Print parameters.  */
1145       pp_space (buffer);
1146       pp_character (buffer, '(');
1147       op1 = TREE_OPERAND (node, 1);
1148       if (op1)
1149         dump_generic_node (buffer, op1, spc, flags, false);
1150       pp_character (buffer, ')');
1151
1152       op1 = TREE_OPERAND (node, 2);
1153       if (op1)
1154         {
1155           pp_string (buffer, " [static-chain: ");
1156           dump_generic_node (buffer, op1, spc, flags, false);
1157           pp_character (buffer, ']');
1158         }
1159
1160       if (CALL_EXPR_RETURN_SLOT_OPT (node))
1161         pp_string (buffer, " [return slot optimization]");
1162       if (CALL_EXPR_TAILCALL (node))
1163         pp_string (buffer, " [tail call]");
1164       break;
1165
1166     case WITH_CLEANUP_EXPR:
1167       NIY;
1168       break;
1169
1170     case CLEANUP_POINT_EXPR:
1171       pp_string (buffer, "<<cleanup_point ");
1172       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1173       pp_string (buffer, ">>");
1174       break;
1175
1176     case PLACEHOLDER_EXPR:
1177       pp_string (buffer, "<PLACEHOLDER_EXPR ");
1178       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1179       pp_character (buffer, '>');
1180       break;
1181
1182       /* Binary arithmetic and logic expressions.  */
1183     case WIDEN_SUM_EXPR:
1184     case WIDEN_MULT_EXPR:
1185     case MULT_EXPR:
1186     case PLUS_EXPR:
1187     case MINUS_EXPR:
1188     case TRUNC_DIV_EXPR:
1189     case CEIL_DIV_EXPR:
1190     case FLOOR_DIV_EXPR:
1191     case ROUND_DIV_EXPR:
1192     case TRUNC_MOD_EXPR:
1193     case CEIL_MOD_EXPR:
1194     case FLOOR_MOD_EXPR:
1195     case ROUND_MOD_EXPR:
1196     case RDIV_EXPR:
1197     case EXACT_DIV_EXPR:
1198     case LSHIFT_EXPR:
1199     case RSHIFT_EXPR:
1200     case LROTATE_EXPR:
1201     case RROTATE_EXPR:
1202     case VEC_LSHIFT_EXPR:
1203     case VEC_RSHIFT_EXPR:
1204     case BIT_IOR_EXPR:
1205     case BIT_XOR_EXPR:
1206     case BIT_AND_EXPR:
1207     case TRUTH_ANDIF_EXPR:
1208     case TRUTH_ORIF_EXPR:
1209     case TRUTH_AND_EXPR:
1210     case TRUTH_OR_EXPR:
1211     case TRUTH_XOR_EXPR:
1212     case LT_EXPR:
1213     case LE_EXPR:
1214     case GT_EXPR:
1215     case GE_EXPR:
1216     case EQ_EXPR:
1217     case NE_EXPR:
1218     case UNLT_EXPR:
1219     case UNLE_EXPR:
1220     case UNGT_EXPR:
1221     case UNGE_EXPR:
1222     case UNEQ_EXPR:
1223     case LTGT_EXPR:
1224     case ORDERED_EXPR:
1225     case UNORDERED_EXPR:
1226       {
1227         const char *op = op_symbol (node);
1228         op0 = TREE_OPERAND (node, 0);
1229         op1 = TREE_OPERAND (node, 1);
1230
1231         /* When the operands are expressions with less priority,
1232            keep semantics of the tree representation.  */
1233         if (op_prio (op0) < op_prio (node))
1234           {
1235             pp_character (buffer, '(');
1236             dump_generic_node (buffer, op0, spc, flags, false);
1237             pp_character (buffer, ')');
1238           }
1239         else
1240           dump_generic_node (buffer, op0, spc, flags, false);
1241
1242         pp_space (buffer);
1243         pp_string (buffer, op);
1244         pp_space (buffer);
1245
1246         /* When the operands are expressions with less priority,
1247            keep semantics of the tree representation.  */
1248         if (op_prio (op1) < op_prio (node))
1249           {
1250             pp_character (buffer, '(');
1251             dump_generic_node (buffer, op1, spc, flags, false);
1252             pp_character (buffer, ')');
1253           }
1254         else
1255           dump_generic_node (buffer, op1, spc, flags, false);
1256       }
1257       break;
1258
1259       /* Unary arithmetic and logic expressions.  */
1260     case NEGATE_EXPR:
1261     case BIT_NOT_EXPR:
1262     case TRUTH_NOT_EXPR:
1263     case ADDR_EXPR:
1264     case PREDECREMENT_EXPR:
1265     case PREINCREMENT_EXPR:
1266     case ALIGN_INDIRECT_REF:
1267     case MISALIGNED_INDIRECT_REF:
1268     case INDIRECT_REF:
1269       if (TREE_CODE (node) == ADDR_EXPR
1270           && (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
1271               || TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL))
1272         ;       /* Do not output '&' for strings and function pointers.  */
1273       else
1274         pp_string (buffer, op_symbol (node));
1275
1276       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1277         {
1278           pp_character (buffer, '(');
1279           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1280           pp_character (buffer, ')');
1281         }
1282       else
1283         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1284
1285       if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
1286         {
1287           pp_string (buffer, "{misalignment: ");
1288           dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1289           pp_character (buffer, '}');
1290         }
1291       break;
1292
1293     case POSTDECREMENT_EXPR:
1294     case POSTINCREMENT_EXPR:
1295       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
1296         {
1297           pp_character (buffer, '(');
1298           dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1299           pp_character (buffer, ')');
1300         }
1301       else
1302         dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1303       pp_string (buffer, op_symbol (node));
1304       break;
1305
1306     case MIN_EXPR:
1307       pp_string (buffer, "MIN_EXPR <");
1308       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1309       pp_string (buffer, ", ");
1310       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1311       pp_character (buffer, '>');
1312       break;
1313
1314     case MAX_EXPR:
1315       pp_string (buffer, "MAX_EXPR <");
1316       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1317       pp_string (buffer, ", ");
1318       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1319       pp_character (buffer, '>');
1320       break;
1321
1322     case ABS_EXPR:
1323       pp_string (buffer, "ABS_EXPR <");
1324       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1325       pp_character (buffer, '>');
1326       break;
1327
1328     case RANGE_EXPR:
1329       NIY;
1330       break;
1331
1332     case FIX_TRUNC_EXPR:
1333     case FIX_CEIL_EXPR:
1334     case FIX_FLOOR_EXPR:
1335     case FIX_ROUND_EXPR:
1336     case FLOAT_EXPR:
1337     case CONVERT_EXPR:
1338     case NOP_EXPR:
1339       type = TREE_TYPE (node);
1340       op0 = TREE_OPERAND (node, 0);
1341       if (type != TREE_TYPE (op0))
1342         {
1343           pp_character (buffer, '(');
1344           dump_generic_node (buffer, type, spc, flags, false);
1345           pp_string (buffer, ") ");
1346         }
1347       if (op_prio (op0) < op_prio (node))
1348         pp_character (buffer, '(');
1349       dump_generic_node (buffer, op0, spc, flags, false);
1350       if (op_prio (op0) < op_prio (node))
1351         pp_character (buffer, ')');
1352       break;
1353
1354     case VIEW_CONVERT_EXPR:
1355       pp_string (buffer, "VIEW_CONVERT_EXPR<");
1356       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
1357       pp_string (buffer, ">(");
1358       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1359       pp_character (buffer, ')');
1360       break;
1361
1362     case NON_LVALUE_EXPR:
1363       pp_string (buffer, "NON_LVALUE_EXPR <");
1364       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1365       pp_character (buffer, '>');
1366       break;
1367
1368     case SAVE_EXPR:
1369       pp_string (buffer, "SAVE_EXPR <");
1370       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1371       pp_character (buffer, '>');
1372       break;
1373
1374     case COMPLEX_EXPR:
1375       pp_string (buffer, "COMPLEX_EXPR <");
1376       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1377       pp_string (buffer, ", ");
1378       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1379       pp_string (buffer, ">");
1380       break;
1381
1382     case CONJ_EXPR:
1383       pp_string (buffer, "CONJ_EXPR <");
1384       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1385       pp_string (buffer, ">");
1386       break;
1387
1388     case REALPART_EXPR:
1389       pp_string (buffer, "REALPART_EXPR <");
1390       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1391       pp_string (buffer, ">");
1392       break;
1393
1394     case IMAGPART_EXPR:
1395       pp_string (buffer, "IMAGPART_EXPR <");
1396       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1397       pp_string (buffer, ">");
1398       break;
1399
1400     case VA_ARG_EXPR:
1401       pp_string (buffer, "VA_ARG_EXPR <");
1402       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1403       pp_string (buffer, ">");
1404       break;
1405
1406     case TRY_FINALLY_EXPR:
1407     case TRY_CATCH_EXPR:
1408       pp_string (buffer, "try");
1409       newline_and_indent (buffer, spc+2);
1410       pp_string (buffer, "{");
1411       newline_and_indent (buffer, spc+4);
1412       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc+4, flags, true);
1413       newline_and_indent (buffer, spc+2);
1414       pp_string (buffer, "}");
1415       newline_and_indent (buffer, spc);
1416       pp_string (buffer,
1417                          (TREE_CODE (node) == TRY_CATCH_EXPR) ? "catch" : "finally");
1418       newline_and_indent (buffer, spc+2);
1419       pp_string (buffer, "{");
1420       newline_and_indent (buffer, spc+4);
1421       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc+4, flags, true);
1422       newline_and_indent (buffer, spc+2);
1423       pp_string (buffer, "}");
1424       is_expr = false;
1425       break;
1426
1427     case CATCH_EXPR:
1428       pp_string (buffer, "catch (");
1429       dump_generic_node (buffer, CATCH_TYPES (node), spc+2, flags, false);
1430       pp_string (buffer, ")");
1431       newline_and_indent (buffer, spc+2);
1432       pp_string (buffer, "{");
1433       newline_and_indent (buffer, spc+4);
1434       dump_generic_node (buffer, CATCH_BODY (node), spc+4, flags, true);
1435       newline_and_indent (buffer, spc+2);
1436       pp_string (buffer, "}");
1437       is_expr = false;
1438       break;
1439
1440     case EH_FILTER_EXPR:
1441       pp_string (buffer, "<<<eh_filter (");
1442       dump_generic_node (buffer, EH_FILTER_TYPES (node), spc+2, flags, false);
1443       pp_string (buffer, ")>>>");
1444       newline_and_indent (buffer, spc+2);
1445       pp_string (buffer, "{");
1446       newline_and_indent (buffer, spc+4);
1447       dump_generic_node (buffer, EH_FILTER_FAILURE (node), spc+4, flags, true);
1448       newline_and_indent (buffer, spc+2);
1449       pp_string (buffer, "}");
1450       is_expr = false;
1451       break;
1452
1453     case LABEL_EXPR:
1454       op0 = TREE_OPERAND (node, 0);
1455       /* If this is for break or continue, don't bother printing it.  */
1456       if (DECL_NAME (op0))
1457         {
1458           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1459           if (strcmp (name, "break") == 0
1460               || strcmp (name, "continue") == 0)
1461             break;
1462         }
1463       dump_generic_node (buffer, op0, spc, flags, false);
1464       pp_character (buffer, ':');
1465       if (DECL_NONLOCAL (op0))
1466         pp_string (buffer, " [non-local]");
1467       break;
1468
1469     case EXC_PTR_EXPR:
1470       pp_string (buffer, "<<<exception object>>>");
1471       break;
1472
1473     case FILTER_EXPR:
1474       pp_string (buffer, "<<<filter object>>>");
1475       break;
1476
1477     case LOOP_EXPR:
1478       pp_string (buffer, "while (1)");
1479       if (!(flags & TDF_SLIM))
1480         {
1481           newline_and_indent (buffer, spc+2);
1482           pp_character (buffer, '{');
1483           newline_and_indent (buffer, spc+4);
1484           dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
1485           newline_and_indent (buffer, spc+2);
1486           pp_character (buffer, '}');
1487         }
1488       is_expr = false;
1489       break;
1490
1491     case RETURN_EXPR:
1492       pp_string (buffer, "return");
1493       op0 = TREE_OPERAND (node, 0);
1494       if (op0)
1495         {
1496           pp_space (buffer);
1497           if (TREE_CODE (op0) == MODIFY_EXPR)
1498             dump_generic_node (buffer, TREE_OPERAND (op0, 1), spc, flags, false);
1499           else
1500             dump_generic_node (buffer, op0, spc, flags, false);
1501         }
1502       break;
1503
1504     case EXIT_EXPR:
1505       pp_string (buffer, "if (");
1506       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1507       pp_string (buffer, ") break");
1508       break;
1509
1510     case SWITCH_EXPR:
1511       pp_string (buffer, "switch (");
1512       dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
1513       pp_character (buffer, ')');
1514       if (!(flags & TDF_SLIM))
1515         {
1516           newline_and_indent (buffer, spc+2);
1517           pp_character (buffer, '{');
1518           if (SWITCH_BODY (node))
1519             {
1520               newline_and_indent (buffer, spc+4);
1521               dump_generic_node (buffer, SWITCH_BODY (node), spc+4, flags,
1522                                  true);
1523             }
1524           else
1525             {
1526               tree vec = SWITCH_LABELS (node);
1527               size_t i, n = TREE_VEC_LENGTH (vec);
1528               for (i = 0; i < n; ++i)
1529                 {
1530                   tree elt = TREE_VEC_ELT (vec, i);
1531                   newline_and_indent (buffer, spc+4);
1532                   if (elt)
1533                     {
1534                       dump_generic_node (buffer, elt, spc+4, flags, false);
1535                       pp_string (buffer, " goto ");
1536                       dump_generic_node (buffer, CASE_LABEL (elt), spc+4,
1537                                          flags, true);
1538                       pp_semicolon (buffer);
1539                     }
1540                   else
1541                     pp_string (buffer, "case ???: goto ???;");
1542                 }
1543             }
1544           newline_and_indent (buffer, spc+2);
1545           pp_character (buffer, '}');
1546         }
1547       is_expr = false;
1548       break;
1549
1550     case GOTO_EXPR:
1551       op0 = GOTO_DESTINATION (node);
1552       if (TREE_CODE (op0) != SSA_NAME && DECL_P (op0) && DECL_NAME (op0))
1553         {
1554           const char *name = IDENTIFIER_POINTER (DECL_NAME (op0));
1555           if (strcmp (name, "break") == 0
1556               || strcmp (name, "continue") == 0)
1557             {
1558               pp_string (buffer, name);
1559               break;
1560             }
1561         }
1562       pp_string (buffer, "goto ");
1563       dump_generic_node (buffer, op0, spc, flags, false);
1564       break;
1565
1566     case RESX_EXPR:
1567       pp_string (buffer, "resx");
1568       /* ??? Any sensible way to present the eh region?  */
1569       break;
1570
1571     case ASM_EXPR:
1572       pp_string (buffer, "__asm__");
1573       if (ASM_VOLATILE_P (node))
1574         pp_string (buffer, " __volatile__");
1575       pp_character (buffer, '(');
1576       dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
1577       pp_character (buffer, ':');
1578       dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
1579       pp_character (buffer, ':');
1580       dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
1581       if (ASM_CLOBBERS (node))
1582         {
1583           pp_character (buffer, ':');
1584           dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
1585         }
1586       pp_string (buffer, ")");
1587       break;
1588
1589     case CASE_LABEL_EXPR:
1590       if (CASE_LOW (node) && CASE_HIGH (node))
1591         {
1592           pp_string (buffer, "case ");
1593           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1594           pp_string (buffer, " ... ");
1595           dump_generic_node (buffer, CASE_HIGH (node), spc, flags, false);
1596         }
1597       else if (CASE_LOW (node))
1598         {
1599           pp_string (buffer, "case ");
1600           dump_generic_node (buffer, CASE_LOW (node), spc, flags, false);
1601         }
1602       else
1603         pp_string (buffer, "default ");
1604       pp_character (buffer, ':');
1605       break;
1606
1607     case OBJ_TYPE_REF:
1608       pp_string (buffer, "OBJ_TYPE_REF(");
1609       dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
1610       pp_character (buffer, ';');
1611       dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
1612       pp_character (buffer, '-');
1613       pp_character (buffer, '>');
1614       dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
1615       pp_character (buffer, ')');
1616       break;
1617
1618     case PHI_NODE:
1619       {
1620         int i;
1621
1622         dump_generic_node (buffer, PHI_RESULT (node), spc, flags, false);
1623         pp_string (buffer, " = PHI <");
1624         for (i = 0; i < PHI_NUM_ARGS (node); i++)
1625           {
1626             dump_generic_node (buffer, PHI_ARG_DEF (node, i), spc, flags, false);
1627             pp_string (buffer, "(");
1628             pp_decimal_int (buffer, PHI_ARG_EDGE (node, i)->src->index);
1629             pp_string (buffer, ")");
1630             if (i < PHI_NUM_ARGS (node) - 1)
1631               pp_string (buffer, ", ");
1632           }
1633         pp_string (buffer, ">;");
1634       }
1635       break;
1636
1637     case SSA_NAME:
1638       dump_generic_node (buffer, SSA_NAME_VAR (node), spc, flags, false);
1639       pp_string (buffer, "_");
1640       pp_decimal_int (buffer, SSA_NAME_VERSION (node));
1641       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (node))
1642         pp_string (buffer, "(ab)");
1643       break;
1644
1645     case WITH_SIZE_EXPR:
1646       pp_string (buffer, "WITH_SIZE_EXPR <");
1647       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1648       pp_string (buffer, ", ");
1649       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1650       pp_string (buffer, ">");
1651       break;
1652
1653     case VALUE_HANDLE:
1654       pp_printf (buffer, "VH.%d", VALUE_HANDLE_ID (node));
1655       break;
1656
1657     case ASSERT_EXPR:
1658       pp_string (buffer, "ASSERT_EXPR <");
1659       dump_generic_node (buffer, ASSERT_EXPR_VAR (node), spc, flags, false);
1660       pp_string (buffer, ", ");
1661       dump_generic_node (buffer, ASSERT_EXPR_COND (node), spc, flags, false);
1662       pp_string (buffer, ">");
1663       break;
1664
1665     case SCEV_KNOWN:
1666       pp_string (buffer, "scev_known");
1667       break;
1668
1669     case SCEV_NOT_KNOWN:
1670       pp_string (buffer, "scev_not_known");
1671       break;
1672
1673     case POLYNOMIAL_CHREC:
1674       pp_string (buffer, "{");
1675       dump_generic_node (buffer, CHREC_LEFT (node), spc, flags, false);
1676       pp_string (buffer, ", +, ");
1677       dump_generic_node (buffer, CHREC_RIGHT (node), spc, flags, false);
1678       pp_string (buffer, "}_");
1679       dump_generic_node (buffer, CHREC_VAR (node), spc, flags, false);
1680       is_stmt = false;
1681       break;
1682
1683     case REALIGN_LOAD_EXPR:
1684       pp_string (buffer, "REALIGN_LOAD <");
1685       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1686       pp_string (buffer, ", ");
1687       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1688       pp_string (buffer, ", ");
1689       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1690       pp_string (buffer, ">");
1691       break;
1692
1693     case VEC_COND_EXPR:
1694       pp_string (buffer, " VEC_COND_EXPR < ");
1695       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1696       pp_string (buffer, " , ");
1697       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1698       pp_string (buffer, " , ");
1699       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1700       pp_string (buffer, " > ");
1701       break;
1702
1703     case DOT_PROD_EXPR:
1704       pp_string (buffer, " DOT_PROD_EXPR < ");
1705       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1706       pp_string (buffer, " , ");
1707       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1708       pp_string (buffer, " , ");
1709       dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
1710       pp_string (buffer, " > ");
1711       break;
1712
1713     case OMP_PARALLEL:
1714       pp_string (buffer, "#pragma omp parallel");
1715       dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
1716       if (OMP_PARALLEL_FN (node))
1717         {
1718           pp_string (buffer, " [child fn: ");
1719           dump_generic_node (buffer, OMP_PARALLEL_FN (node), spc, flags, false);
1720
1721           pp_string (buffer, " (");
1722
1723           if (OMP_PARALLEL_DATA_ARG (node))
1724             dump_generic_node (buffer, OMP_PARALLEL_DATA_ARG (node), spc, flags,
1725                                false);
1726           else
1727             pp_string (buffer, "???");
1728
1729           pp_string (buffer, ")]");
1730         }
1731
1732     dump_omp_body:
1733       if (!(flags & TDF_SLIM) && OMP_BODY (node))
1734         {
1735           newline_and_indent (buffer, spc + 2);
1736           pp_character (buffer, '{');
1737           newline_and_indent (buffer, spc + 4);
1738           dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
1739           newline_and_indent (buffer, spc + 2);
1740           pp_character (buffer, '}');
1741         }
1742       is_expr = false;
1743       break;
1744
1745     case OMP_FOR:
1746       pp_string (buffer, "#pragma omp for");
1747       dump_omp_clauses (buffer, OMP_FOR_CLAUSES (node), spc, flags);
1748
1749       if (!(flags & TDF_SLIM))
1750         {
1751           if (OMP_FOR_PRE_BODY (node))
1752             {
1753               newline_and_indent (buffer, spc + 2);
1754               pp_character (buffer, '{');
1755               spc += 4;
1756               newline_and_indent (buffer, spc);
1757               dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
1758                   spc, flags, false);
1759             }
1760           newline_and_indent (buffer, spc);
1761           pp_string (buffer, "for (");
1762           dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
1763           pp_string (buffer, "; ");
1764           dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
1765           pp_string (buffer, "; ");
1766           dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
1767           pp_string (buffer, ")");
1768           if (OMP_FOR_BODY (node))
1769             {
1770               newline_and_indent (buffer, spc + 2);
1771               pp_character (buffer, '{');
1772               newline_and_indent (buffer, spc + 4);
1773               dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
1774                   false);
1775               newline_and_indent (buffer, spc + 2);
1776               pp_character (buffer, '}');
1777             }
1778           if (OMP_FOR_PRE_BODY (node))
1779             {
1780               spc -= 4;
1781               newline_and_indent (buffer, spc + 2);
1782               pp_character (buffer, '}');
1783             }
1784         }
1785       is_expr = false;
1786       break;
1787
1788     case OMP_SECTIONS:
1789       pp_string (buffer, "#pragma omp sections");
1790       dump_omp_clauses (buffer, OMP_SECTIONS_CLAUSES (node), spc, flags);
1791       goto dump_omp_body;
1792
1793     case OMP_SECTION:
1794       pp_string (buffer, "#pragma omp section");
1795       goto dump_omp_body;
1796
1797     case OMP_MASTER:
1798       pp_string (buffer, "#pragma omp master");
1799       goto dump_omp_body;
1800
1801     case OMP_ORDERED:
1802       pp_string (buffer, "#pragma omp ordered");
1803       goto dump_omp_body;
1804
1805     case OMP_CRITICAL:
1806       pp_string (buffer, "#pragma omp critical");
1807       if (OMP_CRITICAL_NAME (node))
1808         {
1809           pp_space (buffer);
1810           pp_character (buffer, '(');
1811           dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
1812                              flags, false);
1813           pp_character (buffer, ')');
1814         }
1815       goto dump_omp_body;
1816
1817     case OMP_ATOMIC:
1818       pp_string (buffer, "#pragma omp atomic");
1819       newline_and_indent (buffer, spc + 2);
1820       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
1821       pp_space (buffer);
1822       pp_character (buffer, '=');
1823       pp_space (buffer);
1824       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
1825       break;
1826
1827     case OMP_SINGLE:
1828       pp_string (buffer, "#pragma omp single");
1829       dump_omp_clauses (buffer, OMP_SINGLE_CLAUSES (node), spc, flags);
1830       goto dump_omp_body;
1831
1832     case OMP_RETURN_EXPR:
1833       pp_string (buffer, "OMP_RETURN");
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         case '\0':
2516           pp_string (buffer, "\\0");
2517           break;
2518
2519         case '\1':
2520           pp_string (buffer, "\\1");
2521           break;
2522
2523         case '\2':
2524           pp_string (buffer, "\\2");
2525           break;
2526
2527         case '\3':
2528           pp_string (buffer, "\\3");
2529           break;
2530
2531         case '\4':
2532           pp_string (buffer, "\\4");
2533           break;
2534
2535         case '\5':
2536           pp_string (buffer, "\\5");
2537           break;
2538
2539         case '\6':
2540           pp_string (buffer, "\\6");
2541           break;
2542
2543         case '\7':
2544           pp_string (buffer, "\\7");
2545           break;
2546
2547         default:
2548           pp_character (buffer, str[0]);
2549           break;
2550         }
2551       str++;
2552     }
2553 }
2554
2555 static void
2556 maybe_init_pretty_print (FILE *file)
2557 {
2558   if (!initialized)
2559     {
2560       pp_construct (&buffer, /* prefix */NULL, /* line-width */0);
2561       pp_needs_newline (&buffer) = true;
2562       initialized = 1;
2563     }
2564
2565   buffer.buffer->stream = file;
2566 }
2567
2568 static void
2569 newline_and_indent (pretty_printer *buffer, int spc)
2570 {
2571   pp_newline (buffer);
2572   INDENT (spc);
2573 }
2574
2575 static void
2576 dump_vops (pretty_printer *buffer, tree stmt, int spc, int flags)
2577 {
2578   tree use;
2579   use_operand_p use_p;
2580   def_operand_p def_p;
2581   use_operand_p kill_p;
2582   ssa_op_iter iter;
2583
2584   if (!ssa_operands_active ())
2585     return;
2586
2587   FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, stmt, iter)
2588     {
2589       pp_string (buffer, "#   ");
2590       dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2591                          spc + 2, flags, false);
2592       pp_string (buffer, " = V_MAY_DEF <");
2593       dump_generic_node (buffer, USE_FROM_PTR (use_p),
2594                          spc + 2, flags, false);
2595       pp_string (buffer, ">;");
2596       newline_and_indent (buffer, spc);
2597     }
2598
2599   FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, kill_p, stmt, iter)
2600     {
2601       pp_string (buffer, "#   ");
2602       dump_generic_node (buffer, DEF_FROM_PTR (def_p),
2603                          spc + 2, flags, false);
2604       pp_string (buffer, " = V_MUST_DEF <");
2605       dump_generic_node (buffer, USE_FROM_PTR (kill_p),
2606                          spc + 2, flags, false);
2607       pp_string (buffer, ">;");
2608       newline_and_indent (buffer, spc);
2609     }
2610
2611   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_VUSE)
2612     {
2613       pp_string (buffer, "#   VUSE <");
2614       dump_generic_node (buffer, use, spc + 2, flags, false);
2615       pp_string (buffer, ">;");
2616       newline_and_indent (buffer, spc);
2617     }
2618 }
2619
2620 /* Dumps basic block BB to FILE with details described by FLAGS and
2621    indented by INDENT spaces.  */
2622
2623 void
2624 dump_generic_bb (FILE *file, basic_block bb, int indent, int flags)
2625 {
2626   maybe_init_pretty_print (file);
2627   dump_generic_bb_buff (&buffer, bb, indent, flags);
2628   pp_flush (&buffer);
2629 }
2630
2631 /* Dumps header of basic block BB to buffer BUFFER indented by INDENT
2632    spaces and details described by flags.  */
2633
2634 static void
2635 dump_bb_header (pretty_printer *buffer, basic_block bb, int indent, int flags)
2636 {
2637   edge e;
2638   tree stmt;
2639   edge_iterator ei;
2640
2641   if (flags & TDF_BLOCKS)
2642     {
2643       INDENT (indent);
2644       pp_string (buffer, "# BLOCK ");
2645       pp_decimal_int (buffer, bb->index);
2646       if (bb->frequency)
2647         {
2648           pp_string (buffer, " freq:");
2649           pp_decimal_int (buffer, bb->frequency);
2650         }
2651       if (bb->count)
2652         {
2653           pp_string (buffer, " count:");
2654           pp_widest_integer (buffer, bb->count);
2655         }
2656
2657       if (flags & TDF_LINENO)
2658         {
2659           block_stmt_iterator bsi;
2660
2661           for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2662             if (get_lineno (bsi_stmt (bsi)) != -1)
2663               {
2664                 pp_string (buffer, ", starting at line ");
2665                 pp_decimal_int (buffer, get_lineno (bsi_stmt (bsi)));
2666                 break;
2667               }
2668         }
2669       newline_and_indent (buffer, indent);
2670
2671       pp_string (buffer, "# PRED:");
2672       pp_write_text_to_stream (buffer);
2673       FOR_EACH_EDGE (e, ei, bb->preds)
2674         if (flags & TDF_SLIM)
2675           {
2676             pp_string (buffer, " ");
2677             if (e->src == ENTRY_BLOCK_PTR)
2678               pp_string (buffer, "ENTRY");
2679             else
2680               pp_decimal_int (buffer, e->src->index);
2681           }
2682         else
2683           dump_edge_info (buffer->buffer->stream, e, 0);
2684       pp_newline (buffer);
2685     }
2686   else
2687     {
2688       stmt = first_stmt (bb);
2689       if (!stmt || TREE_CODE (stmt) != LABEL_EXPR)
2690         {
2691           INDENT (indent - 2);
2692           pp_string (buffer, "<bb ");
2693           pp_decimal_int (buffer, bb->index);
2694           pp_string (buffer, ">:");
2695           pp_newline (buffer);
2696         }
2697     }
2698   pp_write_text_to_stream (buffer);
2699   check_bb_profile (bb, buffer->buffer->stream);
2700 }
2701
2702 /* Dumps end of basic block BB to buffer BUFFER indented by INDENT
2703    spaces.  */
2704
2705 static void
2706 dump_bb_end (pretty_printer *buffer, basic_block bb, int indent, int flags)
2707 {
2708   edge e;
2709   edge_iterator ei;
2710
2711   INDENT (indent);
2712   pp_string (buffer, "# SUCC:");
2713   pp_write_text_to_stream (buffer);
2714   FOR_EACH_EDGE (e, ei, bb->succs)
2715     if (flags & TDF_SLIM)
2716       {
2717         pp_string (buffer, " ");
2718         if (e->dest == EXIT_BLOCK_PTR)
2719           pp_string (buffer, "EXIT");
2720         else
2721           pp_decimal_int (buffer, e->dest->index);
2722       }
2723     else
2724       dump_edge_info (buffer->buffer->stream, e, 1);
2725   pp_newline (buffer);
2726 }
2727
2728 /* Dumps phi nodes of basic block BB to buffer BUFFER with details described by
2729    FLAGS indented by INDENT spaces.  */
2730
2731 static void
2732 dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, int flags)
2733 {
2734   tree phi = phi_nodes (bb);
2735   if (!phi)
2736     return;
2737
2738   for (; phi; phi = PHI_CHAIN (phi))
2739     {
2740       if (is_gimple_reg (PHI_RESULT (phi)) || (flags & TDF_VOPS))
2741         {
2742           INDENT (indent);
2743           pp_string (buffer, "# ");
2744           dump_generic_node (buffer, phi, indent, flags, false);
2745           pp_newline (buffer);
2746         }
2747     }
2748 }
2749
2750 /* Dump jump to basic block BB that is represented implicitly in the cfg
2751    to BUFFER.  */
2752
2753 static void
2754 pp_cfg_jump (pretty_printer *buffer, basic_block bb)
2755 {
2756   tree stmt;
2757
2758   stmt = first_stmt (bb);
2759
2760   pp_string (buffer, "goto <bb ");
2761   pp_decimal_int (buffer, bb->index);
2762   pp_string (buffer, ">");
2763   if (stmt && TREE_CODE (stmt) == LABEL_EXPR)
2764     {
2765       pp_string (buffer, " (");
2766       dump_generic_node (buffer, LABEL_EXPR_LABEL (stmt), 0, 0, false);
2767       pp_string (buffer, ")");
2768     }
2769   pp_semicolon (buffer);
2770 }
2771
2772 /* Dump edges represented implicitly in basic block BB to BUFFER, indented
2773    by INDENT spaces, with details given by FLAGS.  */
2774
2775 static void
2776 dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
2777                      int flags)
2778 {
2779   edge e;
2780   edge_iterator ei;
2781
2782   /* If there is a fallthru edge, we may need to add an artificial goto to the
2783      dump.  */
2784   FOR_EACH_EDGE (e, ei, bb->succs)
2785     if (e->flags & EDGE_FALLTHRU)
2786       break;
2787   if (e && e->dest != bb->next_bb)
2788     {
2789       INDENT (indent);
2790
2791       if ((flags & TDF_LINENO)
2792 #ifdef USE_MAPPED_LOCATION
2793           && e->goto_locus != UNKNOWN_LOCATION
2794 #else
2795           && e->goto_locus
2796 #endif
2797           )
2798         {
2799           expanded_location goto_xloc;
2800 #ifdef USE_MAPPED_LOCATION
2801           goto_xloc = expand_location (e->goto_locus);
2802 #else
2803           goto_xloc = *e->goto_locus;
2804 #endif
2805           pp_character (buffer, '[');
2806           if (goto_xloc.file)
2807             {
2808               pp_string (buffer, goto_xloc.file);
2809               pp_string (buffer, " : ");
2810             }
2811           pp_decimal_int (buffer, goto_xloc.line);
2812           pp_string (buffer, "] ");
2813         }
2814
2815       pp_cfg_jump (buffer, e->dest);
2816       pp_newline (buffer);
2817     }
2818 }
2819
2820 /* Dumps basic block BB to buffer BUFFER with details described by FLAGS and
2821    indented by INDENT spaces.  */
2822
2823 static void
2824 dump_generic_bb_buff (pretty_printer *buffer, basic_block bb,
2825                       int indent, int flags)
2826 {
2827   block_stmt_iterator bsi;
2828   tree stmt;
2829   int label_indent = indent - 2;
2830
2831   if (label_indent < 0)
2832     label_indent = 0;
2833
2834   dump_bb_header (buffer, bb, indent, flags);
2835
2836   dump_phi_nodes (buffer, bb, indent, flags);
2837
2838   for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
2839     {
2840       int curr_indent;
2841
2842       stmt = bsi_stmt (bsi);
2843
2844       curr_indent = TREE_CODE (stmt) == LABEL_EXPR ? label_indent : indent;
2845
2846       INDENT (curr_indent);
2847       dump_generic_node (buffer, stmt, curr_indent, flags, true);
2848       pp_newline (buffer);
2849     }
2850
2851   dump_implicit_edges (buffer, bb, indent, flags);
2852
2853   if (flags & TDF_BLOCKS)
2854     dump_bb_end (buffer, bb, indent, flags);
2855 }