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