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