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