gcc/tree-pretty-print.c

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