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