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