gcc/tree-pretty-print.c

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