gcc/tree-pretty-print.c

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