gcc/tree-pretty-print.c

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